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