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 "gdbsupport/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_addrx or 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   /* Fetching the entry pc for THIS_FRAME won't necessarily result
1027      in an address that's within the range of FDE locations.  This
1028      is due to the possibility of the function occupying non-contiguous
1029      ranges.  */
1030   if (get_frame_func_if_available (this_frame, &entry_pc)
1031       && fde->initial_location <= entry_pc
1032       && entry_pc < fde->initial_location + fde->address_range)
1033     {
1034       /* Decode the insns in the FDE up to the entry PC.  */
1035       instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1036                                    entry_pc, &fs);
1037
1038       if (fs.regs.cfa_how == CFA_REG_OFFSET
1039           && (dwarf_reg_to_regnum (gdbarch, fs.regs.cfa_reg)
1040               == gdbarch_sp_regnum (gdbarch)))
1041         {
1042           cache->entry_cfa_sp_offset = fs.regs.cfa_offset;
1043           cache->entry_cfa_sp_offset_p = 1;
1044         }
1045     }
1046   else
1047     instr = fde->instructions;
1048
1049   /* Then decode the insns in the FDE up to our target PC.  */
1050   execute_cfa_program (fde, instr, fde->end, gdbarch,
1051                        get_frame_address_in_block (this_frame), &fs);
1052
1053   try
1054     {
1055       /* Calculate the CFA.  */
1056       switch (fs.regs.cfa_how)
1057         {
1058         case CFA_REG_OFFSET:
1059           cache->cfa = read_addr_from_reg (this_frame, fs.regs.cfa_reg);
1060           if (fs.armcc_cfa_offsets_reversed)
1061             cache->cfa -= fs.regs.cfa_offset;
1062           else
1063             cache->cfa += fs.regs.cfa_offset;
1064           break;
1065
1066         case CFA_EXP:
1067           cache->cfa =
1068             execute_stack_op (fs.regs.cfa_exp, fs.regs.cfa_exp_len,
1069                               cache->addr_size, cache->text_offset,
1070                               this_frame, 0, 0);
1071           break;
1072
1073         default:
1074           internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1075         }
1076     }
1077   catch (const gdb_exception_error &ex)
1078     {
1079       if (ex.error == NOT_AVAILABLE_ERROR)
1080         {
1081           cache->unavailable_retaddr = 1;
1082           return cache;
1083         }
1084
1085       throw;
1086     }
1087
1088   /* Initialize the register state.  */
1089   {
1090     int regnum;
1091
1092     for (regnum = 0; regnum < num_regs; regnum++)
1093       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1094   }
1095
1096   /* Go through the DWARF2 CFI generated table and save its register
1097      location information in the cache.  Note that we don't skip the
1098      return address column; it's perfectly all right for it to
1099      correspond to a real register.  */
1100   {
1101     int column;         /* CFI speak for "register number".  */
1102
1103     for (column = 0; column < fs.regs.reg.size (); column++)
1104       {
1105         /* Use the GDB register number as the destination index.  */
1106         int regnum = dwarf_reg_to_regnum (gdbarch, column);
1107
1108         /* Protect against a target returning a bad register.  */
1109         if (regnum < 0 || regnum >= num_regs)
1110           continue;
1111
1112         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1113            of all debug info registers.  If it doesn't, complain (but
1114            not too loudly).  It turns out that GCC assumes that an
1115            unspecified register implies "same value" when CFI (draft
1116            7) specifies nothing at all.  Such a register could equally
1117            be interpreted as "undefined".  Also note that this check
1118            isn't sufficient; it only checks that all registers in the
1119            range [0 .. max column] are specified, and won't detect
1120            problems when a debug info register falls outside of the
1121            table.  We need a way of iterating through all the valid
1122            DWARF2 register numbers.  */
1123         if (fs.regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1124           {
1125             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1126               complaint (_("\
1127 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1128                          gdbarch_register_name (gdbarch, regnum),
1129                          paddress (gdbarch, fs.pc));
1130           }
1131         else
1132           cache->reg[regnum] = fs.regs.reg[column];
1133       }
1134   }
1135
1136   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1137      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
1138   {
1139     int regnum;
1140
1141     for (regnum = 0; regnum < num_regs; regnum++)
1142       {
1143         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1144             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1145           {
1146             const std::vector<struct dwarf2_frame_state_reg> &regs
1147               = fs.regs.reg;
1148             ULONGEST retaddr_column = fs.retaddr_column;
1149
1150             /* It seems rather bizarre to specify an "empty" column as
1151                the return adress column.  However, this is exactly
1152                what GCC does on some targets.  It turns out that GCC
1153                assumes that the return address can be found in the
1154                register corresponding to the return address column.
1155                Incidentally, that's how we should treat a return
1156                address column specifying "same value" too.  */
1157             if (fs.retaddr_column < fs.regs.reg.size ()
1158                 && regs[retaddr_column].how != DWARF2_FRAME_REG_UNSPECIFIED
1159                 && regs[retaddr_column].how != DWARF2_FRAME_REG_SAME_VALUE)
1160               {
1161                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1162                   cache->reg[regnum] = regs[retaddr_column];
1163                 else
1164                   cache->retaddr_reg = regs[retaddr_column];
1165               }
1166             else
1167               {
1168                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1169                   {
1170                     cache->reg[regnum].loc.reg = fs.retaddr_column;
1171                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1172                   }
1173                 else
1174                   {
1175                     cache->retaddr_reg.loc.reg = fs.retaddr_column;
1176                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1177                   }
1178               }
1179           }
1180       }
1181   }
1182
1183   if (fs.retaddr_column < fs.regs.reg.size ()
1184       && fs.regs.reg[fs.retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1185     cache->undefined_retaddr = 1;
1186
1187   return cache;
1188 }
1189
1190 static enum unwind_stop_reason
1191 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1192                                  void **this_cache)
1193 {
1194   struct dwarf2_frame_cache *cache
1195     = dwarf2_frame_cache (this_frame, this_cache);
1196
1197   if (cache->unavailable_retaddr)
1198     return UNWIND_UNAVAILABLE;
1199
1200   if (cache->undefined_retaddr)
1201     return UNWIND_OUTERMOST;
1202
1203   return UNWIND_NO_REASON;
1204 }
1205
1206 static void
1207 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1208                       struct frame_id *this_id)
1209 {
1210   struct dwarf2_frame_cache *cache =
1211     dwarf2_frame_cache (this_frame, this_cache);
1212
1213   if (cache->unavailable_retaddr)
1214     (*this_id) = frame_id_build_unavailable_stack (get_frame_func (this_frame));
1215   else if (cache->undefined_retaddr)
1216     return;
1217   else
1218     (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1219 }
1220
1221 static struct value *
1222 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1223                             int regnum)
1224 {
1225   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1226   struct dwarf2_frame_cache *cache =
1227     dwarf2_frame_cache (this_frame, this_cache);
1228   CORE_ADDR addr;
1229   int realnum;
1230
1231   /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1232      call frame chain.  */
1233   if (!cache->checked_tailcall_bottom)
1234     {
1235       cache->checked_tailcall_bottom = 1;
1236       dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1237                                      (cache->entry_cfa_sp_offset_p
1238                                       ? &cache->entry_cfa_sp_offset : NULL));
1239     }
1240
1241   /* Non-bottom frames of a virtual tail call frames chain use
1242      dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1243      them.  If dwarf2_tailcall_prev_register_first does not have specific value
1244      unwind the register, tail call frames are assumed to have the register set
1245      of the top caller.  */
1246   if (cache->tailcall_cache)
1247     {
1248       struct value *val;
1249
1250       val = dwarf2_tailcall_prev_register_first (this_frame,
1251                                                  &cache->tailcall_cache,
1252                                                  regnum);
1253       if (val)
1254         return val;
1255     }
1256
1257   switch (cache->reg[regnum].how)
1258     {
1259     case DWARF2_FRAME_REG_UNDEFINED:
1260       /* If CFI explicitly specified that the value isn't defined,
1261          mark it as optimized away; the value isn't available.  */
1262       return frame_unwind_got_optimized (this_frame, regnum);
1263
1264     case DWARF2_FRAME_REG_SAVED_OFFSET:
1265       addr = cache->cfa + cache->reg[regnum].loc.offset;
1266       return frame_unwind_got_memory (this_frame, regnum, addr);
1267
1268     case DWARF2_FRAME_REG_SAVED_REG:
1269       realnum = dwarf_reg_to_regnum_or_error
1270         (gdbarch, cache->reg[regnum].loc.reg);
1271       return frame_unwind_got_register (this_frame, regnum, realnum);
1272
1273     case DWARF2_FRAME_REG_SAVED_EXP:
1274       addr = execute_stack_op (cache->reg[regnum].loc.exp.start,
1275                                cache->reg[regnum].loc.exp.len,
1276                                cache->addr_size, cache->text_offset,
1277                                this_frame, cache->cfa, 1);
1278       return frame_unwind_got_memory (this_frame, regnum, addr);
1279
1280     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1281       addr = cache->cfa + cache->reg[regnum].loc.offset;
1282       return frame_unwind_got_constant (this_frame, regnum, addr);
1283
1284     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1285       addr = execute_stack_op (cache->reg[regnum].loc.exp.start,
1286                                cache->reg[regnum].loc.exp.len,
1287                                cache->addr_size, cache->text_offset,
1288                                this_frame, cache->cfa, 1);
1289       return frame_unwind_got_constant (this_frame, regnum, addr);
1290
1291     case DWARF2_FRAME_REG_UNSPECIFIED:
1292       /* GCC, in its infinite wisdom decided to not provide unwind
1293          information for registers that are "same value".  Since
1294          DWARF2 (3 draft 7) doesn't define such behavior, said
1295          registers are actually undefined (which is different to CFI
1296          "undefined").  Code above issues a complaint about this.
1297          Here just fudge the books, assume GCC, and that the value is
1298          more inner on the stack.  */
1299       return frame_unwind_got_register (this_frame, regnum, regnum);
1300
1301     case DWARF2_FRAME_REG_SAME_VALUE:
1302       return frame_unwind_got_register (this_frame, regnum, regnum);
1303
1304     case DWARF2_FRAME_REG_CFA:
1305       return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1306
1307     case DWARF2_FRAME_REG_CFA_OFFSET:
1308       addr = cache->cfa + cache->reg[regnum].loc.offset;
1309       return frame_unwind_got_address (this_frame, regnum, addr);
1310
1311     case DWARF2_FRAME_REG_RA_OFFSET:
1312       addr = cache->reg[regnum].loc.offset;
1313       regnum = dwarf_reg_to_regnum_or_error
1314         (gdbarch, cache->retaddr_reg.loc.reg);
1315       addr += get_frame_register_unsigned (this_frame, regnum);
1316       return frame_unwind_got_address (this_frame, regnum, addr);
1317
1318     case DWARF2_FRAME_REG_FN:
1319       return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1320
1321     default:
1322       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1323     }
1324 }
1325
1326 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1327    call frames chain.  */
1328
1329 static void
1330 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1331 {
1332   struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1333
1334   if (cache->tailcall_cache)
1335     dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
1336 }
1337
1338 static int
1339 dwarf2_frame_sniffer (const struct frame_unwind *self,
1340                       struct frame_info *this_frame, void **this_cache)
1341 {
1342   if (!dwarf2_frame_unwinders_enabled_p)
1343     return 0;
1344
1345   /* Grab an address that is guarenteed to reside somewhere within the
1346      function.  get_frame_pc(), with a no-return next function, can
1347      end up returning something past the end of this function's body.
1348      If the frame we're sniffing for is a signal frame whose start
1349      address is placed on the stack by the OS, its FDE must
1350      extend one byte before its start address or we could potentially
1351      select the FDE of the previous function.  */
1352   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1353   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1354
1355   if (!fde)
1356     return 0;
1357
1358   /* On some targets, signal trampolines may have unwind information.
1359      We need to recognize them so that we set the frame type
1360      correctly.  */
1361
1362   if (fde->cie->signal_frame
1363       || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1364                                       this_frame))
1365     return self->type == SIGTRAMP_FRAME;
1366
1367   if (self->type != NORMAL_FRAME)
1368     return 0;
1369
1370   return 1;
1371 }
1372
1373 static const struct frame_unwind dwarf2_frame_unwind =
1374 {
1375   NORMAL_FRAME,
1376   dwarf2_frame_unwind_stop_reason,
1377   dwarf2_frame_this_id,
1378   dwarf2_frame_prev_register,
1379   NULL,
1380   dwarf2_frame_sniffer,
1381   dwarf2_frame_dealloc_cache
1382 };
1383
1384 static const struct frame_unwind dwarf2_signal_frame_unwind =
1385 {
1386   SIGTRAMP_FRAME,
1387   dwarf2_frame_unwind_stop_reason,
1388   dwarf2_frame_this_id,
1389   dwarf2_frame_prev_register,
1390   NULL,
1391   dwarf2_frame_sniffer,
1392
1393   /* TAILCALL_CACHE can never be in such frame to need dealloc_cache.  */
1394   NULL
1395 };
1396
1397 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
1398
1399 void
1400 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1401 {
1402   /* TAILCALL_FRAME must be first to find the record by
1403      dwarf2_tailcall_sniffer_first.  */
1404   frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind);
1405
1406   frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1407   frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1408 }
1409 \f
1410
1411 /* There is no explicitly defined relationship between the CFA and the
1412    location of frame's local variables and arguments/parameters.
1413    Therefore, frame base methods on this page should probably only be
1414    used as a last resort, just to avoid printing total garbage as a
1415    response to the "info frame" command.  */
1416
1417 static CORE_ADDR
1418 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1419 {
1420   struct dwarf2_frame_cache *cache =
1421     dwarf2_frame_cache (this_frame, this_cache);
1422
1423   return cache->cfa;
1424 }
1425
1426 static const struct frame_base dwarf2_frame_base =
1427 {
1428   &dwarf2_frame_unwind,
1429   dwarf2_frame_base_address,
1430   dwarf2_frame_base_address,
1431   dwarf2_frame_base_address
1432 };
1433
1434 const struct frame_base *
1435 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1436 {
1437   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1438
1439   if (dwarf2_frame_find_fde (&block_addr, NULL))
1440     return &dwarf2_frame_base;
1441
1442   return NULL;
1443 }
1444
1445 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1446    the DWARF unwinder.  This is used to implement
1447    DW_OP_call_frame_cfa.  */
1448
1449 CORE_ADDR
1450 dwarf2_frame_cfa (struct frame_info *this_frame)
1451 {
1452   if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind)
1453       || frame_unwinder_is (this_frame, &record_btrace_frame_unwind))
1454     throw_error (NOT_AVAILABLE_ERROR,
1455                  _("cfa not available for record btrace target"));
1456
1457   while (get_frame_type (this_frame) == INLINE_FRAME)
1458     this_frame = get_prev_frame (this_frame);
1459   if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1460     throw_error (NOT_AVAILABLE_ERROR,
1461                 _("can't compute CFA for this frame: "
1462                   "required registers or memory are unavailable"));
1463
1464   if (get_frame_id (this_frame).stack_status != FID_STACK_VALID)
1465     throw_error (NOT_AVAILABLE_ERROR,
1466                 _("can't compute CFA for this frame: "
1467                   "frame base not available"));
1468
1469   return get_frame_base (this_frame);
1470 }
1471 \f
1472 const struct objfile_key<dwarf2_fde_table,
1473                          gdb::noop_deleter<dwarf2_fde_table>>
1474   dwarf2_frame_objfile_data;
1475
1476 static unsigned int
1477 read_1_byte (bfd *abfd, const gdb_byte *buf)
1478 {
1479   return bfd_get_8 (abfd, buf);
1480 }
1481
1482 static unsigned int
1483 read_4_bytes (bfd *abfd, const gdb_byte *buf)
1484 {
1485   return bfd_get_32 (abfd, buf);
1486 }
1487
1488 static ULONGEST
1489 read_8_bytes (bfd *abfd, const gdb_byte *buf)
1490 {
1491   return bfd_get_64 (abfd, buf);
1492 }
1493
1494 static ULONGEST
1495 read_initial_length (bfd *abfd, const gdb_byte *buf,
1496                      unsigned int *bytes_read_ptr)
1497 {
1498   ULONGEST result;
1499
1500   result = bfd_get_32 (abfd, buf);
1501   if (result == 0xffffffff)
1502     {
1503       result = bfd_get_64 (abfd, buf + 4);
1504       *bytes_read_ptr = 12;
1505     }
1506   else
1507     *bytes_read_ptr = 4;
1508
1509   return result;
1510 }
1511 \f
1512
1513 /* Pointer encoding helper functions.  */
1514
1515 /* GCC supports exception handling based on DWARF2 CFI.  However, for
1516    technical reasons, it encodes addresses in its FDE's in a different
1517    way.  Several "pointer encodings" are supported.  The encoding
1518    that's used for a particular FDE is determined by the 'R'
1519    augmentation in the associated CIE.  The argument of this
1520    augmentation is a single byte.
1521
1522    The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1523    LEB128.  This is encoded in bits 0, 1 and 2.  Bit 3 encodes whether
1524    the address is signed or unsigned.  Bits 4, 5 and 6 encode how the
1525    address should be interpreted (absolute, relative to the current
1526    position in the FDE, ...).  Bit 7, indicates that the address
1527    should be dereferenced.  */
1528
1529 static gdb_byte
1530 encoding_for_size (unsigned int size)
1531 {
1532   switch (size)
1533     {
1534     case 2:
1535       return DW_EH_PE_udata2;
1536     case 4:
1537       return DW_EH_PE_udata4;
1538     case 8:
1539       return DW_EH_PE_udata8;
1540     default:
1541       internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1542     }
1543 }
1544
1545 static CORE_ADDR
1546 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1547                     int ptr_len, const gdb_byte *buf,
1548                     unsigned int *bytes_read_ptr,
1549                     CORE_ADDR func_base)
1550 {
1551   ptrdiff_t offset;
1552   CORE_ADDR base;
1553
1554   /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1555      FDE's.  */
1556   if (encoding & DW_EH_PE_indirect)
1557     internal_error (__FILE__, __LINE__,
1558                     _("Unsupported encoding: DW_EH_PE_indirect"));
1559
1560   *bytes_read_ptr = 0;
1561
1562   switch (encoding & 0x70)
1563     {
1564     case DW_EH_PE_absptr:
1565       base = 0;
1566       break;
1567     case DW_EH_PE_pcrel:
1568       base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1569       base += (buf - unit->dwarf_frame_buffer);
1570       break;
1571     case DW_EH_PE_datarel:
1572       base = unit->dbase;
1573       break;
1574     case DW_EH_PE_textrel:
1575       base = unit->tbase;
1576       break;
1577     case DW_EH_PE_funcrel:
1578       base = func_base;
1579       break;
1580     case DW_EH_PE_aligned:
1581       base = 0;
1582       offset = buf - unit->dwarf_frame_buffer;
1583       if ((offset % ptr_len) != 0)
1584         {
1585           *bytes_read_ptr = ptr_len - (offset % ptr_len);
1586           buf += *bytes_read_ptr;
1587         }
1588       break;
1589     default:
1590       internal_error (__FILE__, __LINE__,
1591                       _("Invalid or unsupported encoding"));
1592     }
1593
1594   if ((encoding & 0x07) == 0x00)
1595     {
1596       encoding |= encoding_for_size (ptr_len);
1597       if (bfd_get_sign_extend_vma (unit->abfd))
1598         encoding |= DW_EH_PE_signed;
1599     }
1600
1601   switch (encoding & 0x0f)
1602     {
1603     case DW_EH_PE_uleb128:
1604       {
1605         uint64_t value;
1606         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1607
1608         *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
1609         return base + value;
1610       }
1611     case DW_EH_PE_udata2:
1612       *bytes_read_ptr += 2;
1613       return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1614     case DW_EH_PE_udata4:
1615       *bytes_read_ptr += 4;
1616       return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1617     case DW_EH_PE_udata8:
1618       *bytes_read_ptr += 8;
1619       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1620     case DW_EH_PE_sleb128:
1621       {
1622         int64_t value;
1623         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1624
1625         *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
1626         return base + value;
1627       }
1628     case DW_EH_PE_sdata2:
1629       *bytes_read_ptr += 2;
1630       return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1631     case DW_EH_PE_sdata4:
1632       *bytes_read_ptr += 4;
1633       return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1634     case DW_EH_PE_sdata8:
1635       *bytes_read_ptr += 8;
1636       return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1637     default:
1638       internal_error (__FILE__, __LINE__,
1639                       _("Invalid or unsupported encoding"));
1640     }
1641 }
1642 \f
1643
1644 static int
1645 bsearch_cie_cmp (const void *key, const void *element)
1646 {
1647   ULONGEST cie_pointer = *(ULONGEST *) key;
1648   struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1649
1650   if (cie_pointer == cie->cie_pointer)
1651     return 0;
1652
1653   return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1654 }
1655
1656 /* Find CIE with the given CIE_POINTER in CIE_TABLE.  */
1657 static struct dwarf2_cie *
1658 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1659 {
1660   struct dwarf2_cie **p_cie;
1661
1662   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1663      bsearch be non-NULL.  */
1664   if (cie_table->entries == NULL)
1665     {
1666       gdb_assert (cie_table->num_entries == 0);
1667       return NULL;
1668     }
1669
1670   p_cie = ((struct dwarf2_cie **)
1671            bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1672                     sizeof (cie_table->entries[0]), bsearch_cie_cmp));
1673   if (p_cie != NULL)
1674     return *p_cie;
1675   return NULL;
1676 }
1677
1678 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it.  */
1679 static void
1680 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1681 {
1682   const int n = cie_table->num_entries;
1683
1684   gdb_assert (n < 1
1685               || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1686
1687   cie_table->entries
1688     = XRESIZEVEC (struct dwarf2_cie *, cie_table->entries, n + 1);
1689   cie_table->entries[n] = cie;
1690   cie_table->num_entries = n + 1;
1691 }
1692
1693 static int
1694 bsearch_fde_cmp (const void *key, const void *element)
1695 {
1696   CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1697   struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1698
1699   if (seek_pc < fde->initial_location)
1700     return -1;
1701   if (seek_pc < fde->initial_location + fde->address_range)
1702     return 0;
1703   return 1;
1704 }
1705
1706 /* Find the FDE for *PC.  Return a pointer to the FDE, and store the
1707    inital location associated with it into *PC.  */
1708
1709 static struct dwarf2_fde *
1710 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1711 {
1712   for (objfile *objfile : current_program_space->objfiles ())
1713     {
1714       struct dwarf2_fde_table *fde_table;
1715       struct dwarf2_fde **p_fde;
1716       CORE_ADDR offset;
1717       CORE_ADDR seek_pc;
1718
1719       fde_table = dwarf2_frame_objfile_data.get (objfile);
1720       if (fde_table == NULL)
1721         {
1722           dwarf2_build_frame_info (objfile);
1723           fde_table = dwarf2_frame_objfile_data.get (objfile);
1724         }
1725       gdb_assert (fde_table != NULL);
1726
1727       if (fde_table->num_entries == 0)
1728         continue;
1729
1730       gdb_assert (objfile->section_offsets);
1731       offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1732
1733       gdb_assert (fde_table->num_entries > 0);
1734       if (*pc < offset + fde_table->entries[0]->initial_location)
1735         continue;
1736
1737       seek_pc = *pc - offset;
1738       p_fde = ((struct dwarf2_fde **)
1739                bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1740                         sizeof (fde_table->entries[0]), bsearch_fde_cmp));
1741       if (p_fde != NULL)
1742         {
1743           *pc = (*p_fde)->initial_location + offset;
1744           if (out_offset)
1745             *out_offset = offset;
1746           return *p_fde;
1747         }
1748     }
1749   return NULL;
1750 }
1751
1752 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it.  */
1753 static void
1754 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1755 {
1756   if (fde->address_range == 0)
1757     /* Discard useless FDEs.  */
1758     return;
1759
1760   fde_table->num_entries += 1;
1761   fde_table->entries = XRESIZEVEC (struct dwarf2_fde *, fde_table->entries,
1762                                    fde_table->num_entries);
1763   fde_table->entries[fde_table->num_entries - 1] = fde;
1764 }
1765
1766 #define DW64_CIE_ID 0xffffffffffffffffULL
1767
1768 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1769    or any of them.  */
1770
1771 enum eh_frame_type
1772 {
1773   EH_CIE_TYPE_ID = 1 << 0,
1774   EH_FDE_TYPE_ID = 1 << 1,
1775   EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
1776 };
1777
1778 static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
1779                                            const gdb_byte *start,
1780                                            int eh_frame_p,
1781                                            struct dwarf2_cie_table *cie_table,
1782                                            struct dwarf2_fde_table *fde_table,
1783                                            enum eh_frame_type entry_type);
1784
1785 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1786    Return NULL if invalid input, otherwise the next byte to be processed.  */
1787
1788 static const gdb_byte *
1789 decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
1790                       int eh_frame_p,
1791                       struct dwarf2_cie_table *cie_table,
1792                       struct dwarf2_fde_table *fde_table,
1793                       enum eh_frame_type entry_type)
1794 {
1795   struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1796   const gdb_byte *buf, *end;
1797   ULONGEST length;
1798   unsigned int bytes_read;
1799   int dwarf64_p;
1800   ULONGEST cie_id;
1801   ULONGEST cie_pointer;
1802   int64_t sleb128;
1803   uint64_t uleb128;
1804
1805   buf = start;
1806   length = read_initial_length (unit->abfd, buf, &bytes_read);
1807   buf += bytes_read;
1808   end = buf + (size_t) length;
1809
1810   if (length == 0)
1811     return end;
1812
1813   /* Are we still within the section?  */
1814   if (end <= buf || end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1815     return NULL;
1816
1817   /* Distinguish between 32 and 64-bit encoded frame info.  */
1818   dwarf64_p = (bytes_read == 12);
1819
1820   /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs.  */
1821   if (eh_frame_p)
1822     cie_id = 0;
1823   else if (dwarf64_p)
1824     cie_id = DW64_CIE_ID;
1825   else
1826     cie_id = DW_CIE_ID;
1827
1828   if (dwarf64_p)
1829     {
1830       cie_pointer = read_8_bytes (unit->abfd, buf);
1831       buf += 8;
1832     }
1833   else
1834     {
1835       cie_pointer = read_4_bytes (unit->abfd, buf);
1836       buf += 4;
1837     }
1838
1839   if (cie_pointer == cie_id)
1840     {
1841       /* This is a CIE.  */
1842       struct dwarf2_cie *cie;
1843       char *augmentation;
1844       unsigned int cie_version;
1845
1846       /* Check that a CIE was expected.  */
1847       if ((entry_type & EH_CIE_TYPE_ID) == 0)
1848         error (_("Found a CIE when not expecting it."));
1849
1850       /* Record the offset into the .debug_frame section of this CIE.  */
1851       cie_pointer = start - unit->dwarf_frame_buffer;
1852
1853       /* Check whether we've already read it.  */
1854       if (find_cie (cie_table, cie_pointer))
1855         return end;
1856
1857       cie = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_cie);
1858       cie->initial_instructions = NULL;
1859       cie->cie_pointer = cie_pointer;
1860
1861       /* The encoding for FDE's in a normal .debug_frame section
1862          depends on the target address size.  */
1863       cie->encoding = DW_EH_PE_absptr;
1864
1865       /* We'll determine the final value later, but we need to
1866          initialize it conservatively.  */
1867       cie->signal_frame = 0;
1868
1869       /* Check version number.  */
1870       cie_version = read_1_byte (unit->abfd, buf);
1871       if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1872         return NULL;
1873       cie->version = cie_version;
1874       buf += 1;
1875
1876       /* Interpret the interesting bits of the augmentation.  */
1877       cie->augmentation = augmentation = (char *) buf;
1878       buf += (strlen (augmentation) + 1);
1879
1880       /* Ignore armcc augmentations.  We only use them for quirks,
1881          and that doesn't happen until later.  */
1882       if (startswith (augmentation, "armcc"))
1883         augmentation += strlen (augmentation);
1884
1885       /* The GCC 2.x "eh" augmentation has a pointer immediately
1886          following the augmentation string, so it must be handled
1887          first.  */
1888       if (augmentation[0] == 'e' && augmentation[1] == 'h')
1889         {
1890           /* Skip.  */
1891           buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1892           augmentation += 2;
1893         }
1894
1895       if (cie->version >= 4)
1896         {
1897           /* FIXME: check that this is the same as from the CU header.  */
1898           cie->addr_size = read_1_byte (unit->abfd, buf);
1899           ++buf;
1900           cie->segment_size = read_1_byte (unit->abfd, buf);
1901           ++buf;
1902         }
1903       else
1904         {
1905           cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1906           cie->segment_size = 0;
1907         }
1908       /* Address values in .eh_frame sections are defined to have the
1909          target's pointer size.  Watchout: This breaks frame info for
1910          targets with pointer size < address size, unless a .debug_frame
1911          section exists as well.  */
1912       if (eh_frame_p)
1913         cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1914       else
1915         cie->ptr_size = cie->addr_size;
1916
1917       buf = gdb_read_uleb128 (buf, end, &uleb128);
1918       if (buf == NULL)
1919         return NULL;
1920       cie->code_alignment_factor = uleb128;
1921
1922       buf = gdb_read_sleb128 (buf, end, &sleb128);
1923       if (buf == NULL)
1924         return NULL;
1925       cie->data_alignment_factor = sleb128;
1926
1927       if (cie_version == 1)
1928         {
1929           cie->return_address_register = read_1_byte (unit->abfd, buf);
1930           ++buf;
1931         }
1932       else
1933         {
1934           buf = gdb_read_uleb128 (buf, end, &uleb128);
1935           if (buf == NULL)
1936             return NULL;
1937           cie->return_address_register = uleb128;
1938         }
1939
1940       cie->return_address_register
1941         = dwarf2_frame_adjust_regnum (gdbarch,
1942                                       cie->return_address_register,
1943                                       eh_frame_p);
1944
1945       cie->saw_z_augmentation = (*augmentation == 'z');
1946       if (cie->saw_z_augmentation)
1947         {
1948           uint64_t uleb_length;
1949
1950           buf = gdb_read_uleb128 (buf, end, &uleb_length);
1951           if (buf == NULL)
1952             return NULL;
1953           cie->initial_instructions = buf + uleb_length;
1954           augmentation++;
1955         }
1956
1957       while (*augmentation)
1958         {
1959           /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
1960           if (*augmentation == 'L')
1961             {
1962               /* Skip.  */
1963               buf++;
1964               augmentation++;
1965             }
1966
1967           /* "R" indicates a byte indicating how FDE addresses are encoded.  */
1968           else if (*augmentation == 'R')
1969             {
1970               cie->encoding = *buf++;
1971               augmentation++;
1972             }
1973
1974           /* "P" indicates a personality routine in the CIE augmentation.  */
1975           else if (*augmentation == 'P')
1976             {
1977               /* Skip.  Avoid indirection since we throw away the result.  */
1978               gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1979               read_encoded_value (unit, encoding, cie->ptr_size,
1980                                   buf, &bytes_read, 0);
1981               buf += bytes_read;
1982               augmentation++;
1983             }
1984
1985           /* "S" indicates a signal frame, such that the return
1986              address must not be decremented to locate the call frame
1987              info for the previous frame; it might even be the first
1988              instruction of a function, so decrementing it would take
1989              us to a different function.  */
1990           else if (*augmentation == 'S')
1991             {
1992               cie->signal_frame = 1;
1993               augmentation++;
1994             }
1995
1996           /* Otherwise we have an unknown augmentation.  Assume that either
1997              there is no augmentation data, or we saw a 'z' prefix.  */
1998           else
1999             {
2000               if (cie->initial_instructions)
2001                 buf = cie->initial_instructions;
2002               break;
2003             }
2004         }
2005
2006       cie->initial_instructions = buf;
2007       cie->end = end;
2008       cie->unit = unit;
2009
2010       add_cie (cie_table, cie);
2011     }
2012   else
2013     {
2014       /* This is a FDE.  */
2015       struct dwarf2_fde *fde;
2016       CORE_ADDR addr;
2017
2018       /* Check that an FDE was expected.  */
2019       if ((entry_type & EH_FDE_TYPE_ID) == 0)
2020         error (_("Found an FDE when not expecting it."));
2021
2022       /* In an .eh_frame section, the CIE pointer is the delta between the
2023          address within the FDE where the CIE pointer is stored and the
2024          address of the CIE.  Convert it to an offset into the .eh_frame
2025          section.  */
2026       if (eh_frame_p)
2027         {
2028           cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2029           cie_pointer -= (dwarf64_p ? 8 : 4);
2030         }
2031
2032       /* In either case, validate the result is still within the section.  */
2033       if (cie_pointer >= unit->dwarf_frame_size)
2034         return NULL;
2035
2036       fde = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_fde);
2037       fde->cie = find_cie (cie_table, cie_pointer);
2038       if (fde->cie == NULL)
2039         {
2040           decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2041                               eh_frame_p, cie_table, fde_table,
2042                               EH_CIE_TYPE_ID);
2043           fde->cie = find_cie (cie_table, cie_pointer);
2044         }
2045
2046       gdb_assert (fde->cie != NULL);
2047
2048       addr = read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2049                                  buf, &bytes_read, 0);
2050       fde->initial_location = gdbarch_adjust_dwarf2_addr (gdbarch, addr);
2051       buf += bytes_read;
2052
2053       fde->address_range =
2054         read_encoded_value (unit, fde->cie->encoding & 0x0f,
2055                             fde->cie->ptr_size, buf, &bytes_read, 0);
2056       addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + fde->address_range);
2057       fde->address_range = addr - fde->initial_location;
2058       buf += bytes_read;
2059
2060       /* A 'z' augmentation in the CIE implies the presence of an
2061          augmentation field in the FDE as well.  The only thing known
2062          to be in here at present is the LSDA entry for EH.  So we
2063          can skip the whole thing.  */
2064       if (fde->cie->saw_z_augmentation)
2065         {
2066           uint64_t uleb_length;
2067
2068           buf = gdb_read_uleb128 (buf, end, &uleb_length);
2069           if (buf == NULL)
2070             return NULL;
2071           buf += uleb_length;
2072           if (buf > end)
2073             return NULL;
2074         }
2075
2076       fde->instructions = buf;
2077       fde->end = end;
2078
2079       fde->eh_frame_p = eh_frame_p;
2080
2081       add_fde (fde_table, fde);
2082     }
2083
2084   return end;
2085 }
2086
2087 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2088    expect an FDE or a CIE.  */
2089
2090 static const gdb_byte *
2091 decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
2092                     int eh_frame_p,
2093                     struct dwarf2_cie_table *cie_table,
2094                     struct dwarf2_fde_table *fde_table,
2095                     enum eh_frame_type entry_type)
2096 {
2097   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2098   const gdb_byte *ret;
2099   ptrdiff_t start_offset;
2100
2101   while (1)
2102     {
2103       ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2104                                   cie_table, fde_table, entry_type);
2105       if (ret != NULL)
2106         break;
2107
2108       /* We have corrupt input data of some form.  */
2109
2110       /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2111          and mismatches wrt padding and alignment of debug sections.  */
2112       /* Note that there is no requirement in the standard for any
2113          alignment at all in the frame unwind sections.  Testing for
2114          alignment before trying to interpret data would be incorrect.
2115
2116          However, GCC traditionally arranged for frame sections to be
2117          sized such that the FDE length and CIE fields happen to be
2118          aligned (in theory, for performance).  This, unfortunately,
2119          was done with .align directives, which had the side effect of
2120          forcing the section to be aligned by the linker.
2121
2122          This becomes a problem when you have some other producer that
2123          creates frame sections that are not as strictly aligned.  That
2124          produces a hole in the frame info that gets filled by the
2125          linker with zeros.
2126
2127          The GCC behaviour is arguably a bug, but it's effectively now
2128          part of the ABI, so we're now stuck with it, at least at the
2129          object file level.  A smart linker may decide, in the process
2130          of compressing duplicate CIE information, that it can rewrite
2131          the entire output section without this extra padding.  */
2132
2133       start_offset = start - unit->dwarf_frame_buffer;
2134       if (workaround < ALIGN4 && (start_offset & 3) != 0)
2135         {
2136           start += 4 - (start_offset & 3);
2137           workaround = ALIGN4;
2138           continue;
2139         }
2140       if (workaround < ALIGN8 && (start_offset & 7) != 0)
2141         {
2142           start += 8 - (start_offset & 7);
2143           workaround = ALIGN8;
2144           continue;
2145         }
2146
2147       /* Nothing left to try.  Arrange to return as if we've consumed
2148          the entire input section.  Hopefully we'll get valid info from
2149          the other of .debug_frame/.eh_frame.  */
2150       workaround = FAIL;
2151       ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2152       break;
2153     }
2154
2155   switch (workaround)
2156     {
2157     case NONE:
2158       break;
2159
2160     case ALIGN4:
2161       complaint (_("\
2162 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2163                  unit->dwarf_frame_section->owner->filename,
2164                  unit->dwarf_frame_section->name);
2165       break;
2166
2167     case ALIGN8:
2168       complaint (_("\
2169 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2170                  unit->dwarf_frame_section->owner->filename,
2171                  unit->dwarf_frame_section->name);
2172       break;
2173
2174     default:
2175       complaint (_("Corrupt data in %s:%s"),
2176                  unit->dwarf_frame_section->owner->filename,
2177                  unit->dwarf_frame_section->name);
2178       break;
2179     }
2180
2181   return ret;
2182 }
2183 \f
2184 static int
2185 qsort_fde_cmp (const void *a, const void *b)
2186 {
2187   struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2188   struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2189
2190   if (aa->initial_location == bb->initial_location)
2191     {
2192       if (aa->address_range != bb->address_range
2193           && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2194         /* Linker bug, e.g. gold/10400.
2195            Work around it by keeping stable sort order.  */
2196         return (a < b) ? -1 : 1;
2197       else
2198         /* Put eh_frame entries after debug_frame ones.  */
2199         return aa->eh_frame_p - bb->eh_frame_p;
2200     }
2201
2202   return (aa->initial_location < bb->initial_location) ? -1 : 1;
2203 }
2204
2205 void
2206 dwarf2_build_frame_info (struct objfile *objfile)
2207 {
2208   struct comp_unit *unit;
2209   const gdb_byte *frame_ptr;
2210   struct dwarf2_cie_table cie_table;
2211   struct dwarf2_fde_table fde_table;
2212   struct dwarf2_fde_table *fde_table2;
2213
2214   cie_table.num_entries = 0;
2215   cie_table.entries = NULL;
2216
2217   fde_table.num_entries = 0;
2218   fde_table.entries = NULL;
2219
2220   /* Build a minimal decoding of the DWARF2 compilation unit.  */
2221   unit = XOBNEW (&objfile->objfile_obstack, comp_unit);
2222   unit->abfd = objfile->obfd;
2223   unit->objfile = objfile;
2224   unit->dbase = 0;
2225   unit->tbase = 0;
2226
2227   if (objfile->separate_debug_objfile_backlink == NULL)
2228     {
2229       /* Do not read .eh_frame from separate file as they must be also
2230          present in the main file.  */
2231       dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
2232                                &unit->dwarf_frame_section,
2233                                &unit->dwarf_frame_buffer,
2234                                &unit->dwarf_frame_size);
2235       if (unit->dwarf_frame_size)
2236         {
2237           asection *got, *txt;
2238
2239           /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2240              that is used for the i386/amd64 target, which currently is
2241              the only target in GCC that supports/uses the
2242              DW_EH_PE_datarel encoding.  */
2243           got = bfd_get_section_by_name (unit->abfd, ".got");
2244           if (got)
2245             unit->dbase = got->vma;
2246
2247           /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2248              so far.  */
2249           txt = bfd_get_section_by_name (unit->abfd, ".text");
2250           if (txt)
2251             unit->tbase = txt->vma;
2252
2253           try
2254             {
2255               frame_ptr = unit->dwarf_frame_buffer;
2256               while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2257                 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2258                                                 &cie_table, &fde_table,
2259                                                 EH_CIE_OR_FDE_TYPE_ID);
2260             }
2261
2262           catch (const gdb_exception_error &e)
2263             {
2264               warning (_("skipping .eh_frame info of %s: %s"),
2265                        objfile_name (objfile), e.what ());
2266
2267               if (fde_table.num_entries != 0)
2268                 {
2269                   xfree (fde_table.entries);
2270                   fde_table.entries = NULL;
2271                   fde_table.num_entries = 0;
2272                 }
2273               /* The cie_table is discarded by the next if.  */
2274             }
2275
2276           if (cie_table.num_entries != 0)
2277             {
2278               /* Reinit cie_table: debug_frame has different CIEs.  */
2279               xfree (cie_table.entries);
2280               cie_table.num_entries = 0;
2281               cie_table.entries = NULL;
2282             }
2283         }
2284     }
2285
2286   dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
2287                            &unit->dwarf_frame_section,
2288                            &unit->dwarf_frame_buffer,
2289                            &unit->dwarf_frame_size);
2290   if (unit->dwarf_frame_size)
2291     {
2292       int num_old_fde_entries = fde_table.num_entries;
2293
2294       try
2295         {
2296           frame_ptr = unit->dwarf_frame_buffer;
2297           while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2298             frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2299                                             &cie_table, &fde_table,
2300                                             EH_CIE_OR_FDE_TYPE_ID);
2301         }
2302       catch (const gdb_exception_error &e)
2303         {
2304           warning (_("skipping .debug_frame info of %s: %s"),
2305                    objfile_name (objfile), e.what ());
2306
2307           if (fde_table.num_entries != 0)
2308             {
2309               fde_table.num_entries = num_old_fde_entries;
2310               if (num_old_fde_entries == 0)
2311                 {
2312                   xfree (fde_table.entries);
2313                   fde_table.entries = NULL;
2314                 }
2315               else
2316                 {
2317                   fde_table.entries
2318                     = XRESIZEVEC (struct dwarf2_fde *, fde_table.entries,
2319                                   fde_table.num_entries);
2320                 }
2321             }
2322           fde_table.num_entries = num_old_fde_entries;
2323           /* The cie_table is discarded by the next if.  */
2324         }
2325     }
2326
2327   /* Discard the cie_table, it is no longer needed.  */
2328   if (cie_table.num_entries != 0)
2329     {
2330       xfree (cie_table.entries);
2331       cie_table.entries = NULL;   /* Paranoia.  */
2332       cie_table.num_entries = 0;  /* Paranoia.  */
2333     }
2334
2335   /* Copy fde_table to obstack: it is needed at runtime.  */
2336   fde_table2 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_fde_table);
2337
2338   if (fde_table.num_entries == 0)
2339     {
2340       fde_table2->entries = NULL;
2341       fde_table2->num_entries = 0;
2342     }
2343   else
2344     {
2345       struct dwarf2_fde *fde_prev = NULL;
2346       struct dwarf2_fde *first_non_zero_fde = NULL;
2347       int i;
2348
2349       /* Prepare FDE table for lookups.  */
2350       qsort (fde_table.entries, fde_table.num_entries,
2351              sizeof (fde_table.entries[0]), qsort_fde_cmp);
2352
2353       /* Check for leftovers from --gc-sections.  The GNU linker sets
2354          the relevant symbols to zero, but doesn't zero the FDE *end*
2355          ranges because there's no relocation there.  It's (offset,
2356          length), not (start, end).  On targets where address zero is
2357          just another valid address this can be a problem, since the
2358          FDEs appear to be non-empty in the output --- we could pick
2359          out the wrong FDE.  To work around this, when overlaps are
2360          detected, we prefer FDEs that do not start at zero.
2361
2362          Start by finding the first FDE with non-zero start.  Below
2363          we'll discard all FDEs that start at zero and overlap this
2364          one.  */
2365       for (i = 0; i < fde_table.num_entries; i++)
2366         {
2367           struct dwarf2_fde *fde = fde_table.entries[i];
2368
2369           if (fde->initial_location != 0)
2370             {
2371               first_non_zero_fde = fde;
2372               break;
2373             }
2374         }
2375
2376       /* Since we'll be doing bsearch, squeeze out identical (except
2377          for eh_frame_p) fde entries so bsearch result is predictable.
2378          Also discard leftovers from --gc-sections.  */
2379       fde_table2->num_entries = 0;
2380       for (i = 0; i < fde_table.num_entries; i++)
2381         {
2382           struct dwarf2_fde *fde = fde_table.entries[i];
2383
2384           if (fde->initial_location == 0
2385               && first_non_zero_fde != NULL
2386               && (first_non_zero_fde->initial_location
2387                   < fde->initial_location + fde->address_range))
2388             continue;
2389
2390           if (fde_prev != NULL
2391               && fde_prev->initial_location == fde->initial_location)
2392             continue;
2393
2394           obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2395                         sizeof (fde_table.entries[0]));
2396           ++fde_table2->num_entries;
2397           fde_prev = fde;
2398         }
2399       fde_table2->entries
2400         = (struct dwarf2_fde **) obstack_finish (&objfile->objfile_obstack);
2401
2402       /* Discard the original fde_table.  */
2403       xfree (fde_table.entries);
2404     }
2405
2406   dwarf2_frame_objfile_data.set (objfile, fde_table2);
2407 }
2408
2409 /* Handle 'maintenance show dwarf unwinders'.  */
2410
2411 static void
2412 show_dwarf_unwinders_enabled_p (struct ui_file *file, int from_tty,
2413                                 struct cmd_list_element *c,
2414                                 const char *value)
2415 {
2416   fprintf_filtered (file,
2417                     _("The DWARF stack unwinders are currently %s.\n"),
2418                     value);
2419 }
2420
2421 void
2422 _initialize_dwarf2_frame (void)
2423 {
2424   dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2425
2426   add_setshow_boolean_cmd ("unwinders", class_obscure,
2427                            &dwarf2_frame_unwinders_enabled_p , _("\
2428 Set whether the DWARF stack frame unwinders are used."), _("\
2429 Show whether the DWARF stack frame unwinders are used."), _("\
2430 When enabled the DWARF stack frame unwinders can be used for architectures\n\
2431 that support the DWARF unwinders.  Enabling the DWARF unwinders for an\n\
2432 architecture that doesn't support them will have no effect."),
2433                            NULL,
2434                            show_dwarf_unwinders_enabled_p,
2435                            &set_dwarf_cmdlist,
2436                            &show_dwarf_cmdlist);
2437
2438 #if GDB_SELF_TEST
2439   selftests::register_test_foreach_arch ("execute_cfa_program",
2440                                          selftests::execute_cfa_program_test);
2441 #endif
2442 }