gdb/dwarf2-frame.c

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