gdb/dwarf2-frame.c

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