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