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