1/* Frame unwinder for frames with DWARF Call Frame Information. 2 3 Copyright 2003, 2004 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 2 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, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include "dwarf2expr.h" 26#include "elf/dwarf2.h" 27#include "frame.h" 28#include "frame-base.h" 29#include "frame-unwind.h" 30#include "gdbcore.h" 31#include "gdbtypes.h" 32#include "symtab.h" 33#include "objfiles.h" 34#include "regcache.h" 35 36#include "gdb_assert.h" 37#include "gdb_string.h" 38 39#include "complaints.h" 40#include "dwarf2-frame.h" 41 42/* Call Frame Information (CFI). */ 43 44/* Common Information Entry (CIE). */ 45 46struct dwarf2_cie 47{ 48 /* Offset into the .debug_frame section where this CIE was found. 49 Used to identify this CIE. */ 50 ULONGEST cie_pointer; 51 52 /* Constant that is factored out of all advance location 53 instructions. */ 54 ULONGEST code_alignment_factor; 55 56 /* Constants that is factored out of all offset instructions. */ 57 LONGEST data_alignment_factor; 58 59 /* Return address column. */ 60 ULONGEST return_address_register; 61 62 /* Instruction sequence to initialize a register set. */ 63 unsigned char *initial_instructions; 64 unsigned char *end; 65 66 /* Encoding of addresses. */ 67 unsigned char encoding; 68 69 /* True if a 'z' augmentation existed. */ 70 unsigned char saw_z_augmentation; 71 72 struct dwarf2_cie *next; 73}; 74 75/* Frame Description Entry (FDE). */ 76 77struct dwarf2_fde 78{ 79 /* CIE for this FDE. */ 80 struct dwarf2_cie *cie; 81 82 /* First location associated with this FDE. */ 83 CORE_ADDR initial_location; 84 85 /* Number of bytes of program instructions described by this FDE. */ 86 CORE_ADDR address_range; 87 88 /* Instruction sequence. */ 89 unsigned char *instructions; 90 unsigned char *end; 91 92 struct dwarf2_fde *next; 93}; 94 95static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc); 96 97 98/* Structure describing a frame state. */ 99 100struct dwarf2_frame_state 101{ 102 /* Each register save state can be described in terms of a CFA slot, 103 another register, or a location expression. */ 104 struct dwarf2_frame_state_reg_info 105 { 106 struct dwarf2_frame_state_reg *reg; 107 int num_regs; 108 109 /* Used to implement DW_CFA_remember_state. */ 110 struct dwarf2_frame_state_reg_info *prev; 111 } regs; 112 113 LONGEST cfa_offset; 114 ULONGEST cfa_reg; 115 unsigned char *cfa_exp; 116 enum { 117 CFA_UNSET, 118 CFA_REG_OFFSET, 119 CFA_EXP 120 } cfa_how; 121 122 /* The PC described by the current frame state. */ 123 CORE_ADDR pc; 124 125 /* Initial register set from the CIE. 126 Used to implement DW_CFA_restore. */ 127 struct dwarf2_frame_state_reg_info initial; 128 129 /* The information we care about from the CIE. */ 130 LONGEST data_align; 131 ULONGEST code_align; 132 ULONGEST retaddr_column; 133}; 134 135/* Store the length the expression for the CFA in the `cfa_reg' field, 136 which is unused in that case. */ 137#define cfa_exp_len cfa_reg 138 139/* Assert that the register set RS is large enough to store NUM_REGS 140 columns. If necessary, enlarge the register set. */ 141 142static void 143dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs, 144 int num_regs) 145{ 146 size_t size = sizeof (struct dwarf2_frame_state_reg); 147 148 if (num_regs <= rs->num_regs) 149 return; 150 151 rs->reg = (struct dwarf2_frame_state_reg *) 152 xrealloc (rs->reg, num_regs * size); 153 154 /* Initialize newly allocated registers. */ 155 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size); 156 rs->num_regs = num_regs; 157} 158 159/* Copy the register columns in register set RS into newly allocated 160 memory and return a pointer to this newly created copy. */ 161 162static struct dwarf2_frame_state_reg * 163dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs) 164{ 165 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg_info); 166 struct dwarf2_frame_state_reg *reg; 167 168 reg = (struct dwarf2_frame_state_reg *) xmalloc (size); 169 memcpy (reg, rs->reg, size); 170 171 return reg; 172} 173 174/* Release the memory allocated to register set RS. */ 175 176static void 177dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs) 178{ 179 if (rs) 180 { 181 dwarf2_frame_state_free_regs (rs->prev); 182 183 xfree (rs->reg); 184 xfree (rs); 185 } 186} 187 188/* Release the memory allocated to the frame state FS. */ 189 190static void 191dwarf2_frame_state_free (void *p) 192{ 193 struct dwarf2_frame_state *fs = p; 194 195 dwarf2_frame_state_free_regs (fs->initial.prev); 196 dwarf2_frame_state_free_regs (fs->regs.prev); 197 xfree (fs->initial.reg); 198 xfree (fs->regs.reg); 199 xfree (fs); 200} 201 202 203/* Helper functions for execute_stack_op. */ 204 205static CORE_ADDR 206read_reg (void *baton, int reg) 207{ 208 struct frame_info *next_frame = (struct frame_info *) baton; 209 struct gdbarch *gdbarch = get_frame_arch (next_frame); 210 int regnum; 211 char *buf; 212 213 regnum = DWARF2_REG_TO_REGNUM (reg); 214 215 buf = (char *) alloca (register_size (gdbarch, regnum)); 216 frame_unwind_register (next_frame, regnum, buf); 217 return extract_typed_address (buf, builtin_type_void_data_ptr); 218} 219 220static void 221read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len) 222{ 223 read_memory (addr, buf, len); 224} 225 226static void 227no_get_frame_base (void *baton, unsigned char **start, size_t *length) 228{ 229 internal_error (__FILE__, __LINE__, 230 "Support for DW_OP_fbreg is unimplemented"); 231} 232 233static CORE_ADDR 234no_get_tls_address (void *baton, CORE_ADDR offset) 235{ 236 internal_error (__FILE__, __LINE__, 237 "Support for DW_OP_GNU_push_tls_address is unimplemented"); 238} 239 240static CORE_ADDR 241execute_stack_op (unsigned char *exp, ULONGEST len, 242 struct frame_info *next_frame, CORE_ADDR initial) 243{ 244 struct dwarf_expr_context *ctx; 245 CORE_ADDR result; 246 247 ctx = new_dwarf_expr_context (); 248 ctx->baton = next_frame; 249 ctx->read_reg = read_reg; 250 ctx->read_mem = read_mem; 251 ctx->get_frame_base = no_get_frame_base; 252 ctx->get_tls_address = no_get_tls_address; 253 254 dwarf_expr_push (ctx, initial); 255 dwarf_expr_eval (ctx, exp, len); 256 result = dwarf_expr_fetch (ctx, 0); 257 258 if (ctx->in_reg) 259 result = read_reg (next_frame, result); 260 261 free_dwarf_expr_context (ctx); 262 263 return result; 264} 265 266 267static void 268execute_cfa_program (unsigned char *insn_ptr, unsigned char *insn_end, 269 struct frame_info *next_frame, 270 struct dwarf2_frame_state *fs) 271{ 272 CORE_ADDR pc = frame_pc_unwind (next_frame); 273 int bytes_read; 274 275 while (insn_ptr < insn_end && fs->pc <= pc) 276 { 277 unsigned char insn = *insn_ptr++; 278 ULONGEST utmp, reg; 279 LONGEST offset; 280 281 if ((insn & 0xc0) == DW_CFA_advance_loc) 282 fs->pc += (insn & 0x3f) * fs->code_align; 283 else if ((insn & 0xc0) == DW_CFA_offset) 284 { 285 reg = insn & 0x3f; 286 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 287 offset = utmp * fs->data_align; 288 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 289 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; 290 fs->regs.reg[reg].loc.offset = offset; 291 } 292 else if ((insn & 0xc0) == DW_CFA_restore) 293 { 294 gdb_assert (fs->initial.reg); 295 reg = insn & 0x3f; 296 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 297 fs->regs.reg[reg] = fs->initial.reg[reg]; 298 } 299 else 300 { 301 switch (insn) 302 { 303 case DW_CFA_set_loc: 304 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read); 305 insn_ptr += bytes_read; 306 break; 307 308 case DW_CFA_advance_loc1: 309 utmp = extract_unsigned_integer (insn_ptr, 1); 310 fs->pc += utmp * fs->code_align; 311 insn_ptr++; 312 break; 313 case DW_CFA_advance_loc2: 314 utmp = extract_unsigned_integer (insn_ptr, 2); 315 fs->pc += utmp * fs->code_align; 316 insn_ptr += 2; 317 break; 318 case DW_CFA_advance_loc4: 319 utmp = extract_unsigned_integer (insn_ptr, 4); 320 fs->pc += utmp * fs->code_align; 321 insn_ptr += 4; 322 break; 323 324 case DW_CFA_offset_extended: 325 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 326 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 327 offset = utmp * fs->data_align; 328 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 329 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; 330 fs->regs.reg[reg].loc.offset = offset; 331 break; 332 333 case DW_CFA_restore_extended: 334 gdb_assert (fs->initial.reg); 335 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 336 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 337 fs->regs.reg[reg] = fs->initial.reg[reg]; 338 break; 339 340 case DW_CFA_undefined: 341 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 342 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 343 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED; 344 break; 345 346 case DW_CFA_same_value: 347 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 348 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 349 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE; 350 break; 351 352 case DW_CFA_register: 353 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 354 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 355 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 356 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG; 357 fs->regs.reg[reg].loc.reg = utmp; 358 break; 359 360 case DW_CFA_remember_state: 361 { 362 struct dwarf2_frame_state_reg_info *new_rs; 363 364 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info); 365 *new_rs = fs->regs; 366 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs); 367 fs->regs.prev = new_rs; 368 } 369 break; 370 371 case DW_CFA_restore_state: 372 { 373 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev; 374 375 gdb_assert (old_rs); 376 377 xfree (fs->regs.reg); 378 fs->regs = *old_rs; 379 xfree (old_rs); 380 } 381 break; 382 383 case DW_CFA_def_cfa: 384 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); 385 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 386 fs->cfa_offset = utmp; 387 fs->cfa_how = CFA_REG_OFFSET; 388 break; 389 390 case DW_CFA_def_cfa_register: 391 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); 392 fs->cfa_how = CFA_REG_OFFSET; 393 break; 394 395 case DW_CFA_def_cfa_offset: 396 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_offset); 397 /* cfa_how deliberately not set. */ 398 break; 399 400 case DW_CFA_nop: 401 break; 402 403 case DW_CFA_def_cfa_expression: 404 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len); 405 fs->cfa_exp = insn_ptr; 406 fs->cfa_how = CFA_EXP; 407 insn_ptr += fs->cfa_exp_len; 408 break; 409 410 case DW_CFA_expression: 411 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 412 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); 413 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 414 fs->regs.reg[reg].loc.exp = insn_ptr; 415 fs->regs.reg[reg].exp_len = utmp; 416 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP; 417 insn_ptr += utmp; 418 break; 419 420 case DW_CFA_offset_extended_sf: 421 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); 422 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); 423 offset += 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 break; 428 429 case DW_CFA_def_cfa_sf: 430 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); 431 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); 432 fs->cfa_offset = offset * fs->data_align; 433 fs->cfa_how = CFA_REG_OFFSET; 434 break; 435 436 case DW_CFA_def_cfa_offset_sf: 437 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); 438 fs->cfa_offset = offset * fs->data_align; 439 /* cfa_how deliberately not set. */ 440 break; 441 442 case DW_CFA_GNU_args_size: 443 /* Ignored. */ 444 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); 445 break; 446 447 default: 448 internal_error (__FILE__, __LINE__, "Unknown CFI encountered."); 449 } 450 } 451 } 452 453 /* Don't allow remember/restore between CIE and FDE programs. */ 454 dwarf2_frame_state_free_regs (fs->regs.prev); 455 fs->regs.prev = NULL; 456} 457 458 459/* Architecture-specific operations. */ 460 461/* Per-architecture data key. */ 462static struct gdbarch_data *dwarf2_frame_data; 463 464struct dwarf2_frame_ops 465{ 466 /* Pre-initialize the register state REG for register REGNUM. */ 467 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *); 468}; 469 470/* Default architecture-specific register state initialization 471 function. */ 472 473static void 474dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum, 475 struct dwarf2_frame_state_reg *reg) 476{ 477 /* If we have a register that acts as a program counter, mark it as 478 a destination for the return address. If we have a register that 479 serves as the stack pointer, arrange for it to be filled with the 480 call frame address (CFA). The other registers are marked as 481 unspecified. 482 483 We copy the return address to the program counter, since many 484 parts in GDB assume that it is possible to get the return address 485 by unwinding the program counter register. However, on ISA's 486 with a dedicated return address register, the CFI usually only 487 contains information to unwind that return address register. 488 489 The reason we're treating the stack pointer special here is 490 because in many cases GCC doesn't emit CFI for the stack pointer 491 and implicitly assumes that it is equal to the CFA. This makes 492 some sense since the DWARF specification (version 3, draft 8, 493 p. 102) says that: 494 495 "Typically, the CFA is defined to be the value of the stack 496 pointer at the call site in the previous frame (which may be 497 different from its value on entry to the current frame)." 498 499 However, this isn't true for all platforms supported by GCC 500 (e.g. IBM S/390 and zSeries). Those architectures should provide 501 their own architecture-specific initialization function. */ 502 503 if (regnum == PC_REGNUM) 504 reg->how = DWARF2_FRAME_REG_RA; 505 else if (regnum == SP_REGNUM) 506 reg->how = DWARF2_FRAME_REG_CFA; 507} 508 509/* Return a default for the architecture-specific operations. */ 510 511static void * 512dwarf2_frame_init (struct gdbarch *gdbarch) 513{ 514 struct dwarf2_frame_ops *ops; 515 516 ops = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf2_frame_ops); 517 ops->init_reg = dwarf2_frame_default_init_reg; 518 return ops; 519} 520 521static struct dwarf2_frame_ops * 522dwarf2_frame_ops (struct gdbarch *gdbarch) 523{ 524 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); 525 if (ops == NULL) 526 { 527 /* ULGH, called during architecture initialization. Patch 528 things up. */ 529 ops = dwarf2_frame_init (gdbarch); 530 set_gdbarch_data (gdbarch, dwarf2_frame_data, ops); 531 } 532 return ops; 533} 534 535/* Set the architecture-specific register state initialization 536 function for GDBARCH to INIT_REG. */ 537 538void 539dwarf2_frame_set_init_reg (struct gdbarch *gdbarch, 540 void (*init_reg) (struct gdbarch *, int, 541 struct dwarf2_frame_state_reg *)) 542{ 543 struct dwarf2_frame_ops *ops; 544 545 ops = dwarf2_frame_ops (gdbarch); 546 ops->init_reg = init_reg; 547} 548 549/* Pre-initialize the register state REG for register REGNUM. */ 550 551static void 552dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, 553 struct dwarf2_frame_state_reg *reg) 554{ 555 struct dwarf2_frame_ops *ops; 556 557 ops = dwarf2_frame_ops (gdbarch); 558 ops->init_reg (gdbarch, regnum, reg); 559} 560 561 562struct dwarf2_frame_cache 563{ 564 /* DWARF Call Frame Address. */ 565 CORE_ADDR cfa; 566 567 /* Saved registers, indexed by GDB register number, not by DWARF 568 register number. */ 569 struct dwarf2_frame_state_reg *reg; 570}; 571 572static struct dwarf2_frame_cache * 573dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache) 574{ 575 struct cleanup *old_chain; 576 struct gdbarch *gdbarch = get_frame_arch (next_frame); 577 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS; 578 struct dwarf2_frame_cache *cache; 579 struct dwarf2_frame_state *fs; 580 struct dwarf2_fde *fde; 581 582 if (*this_cache) 583 return *this_cache; 584 585 /* Allocate a new cache. */ 586 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache); 587 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg); 588 589 /* Allocate and initialize the frame state. */ 590 fs = XMALLOC (struct dwarf2_frame_state); 591 memset (fs, 0, sizeof (struct dwarf2_frame_state)); 592 old_chain = make_cleanup (dwarf2_frame_state_free, fs); 593 594 /* Unwind the PC. 595 596 Note that if NEXT_FRAME is never supposed to return (i.e. a call 597 to abort), the compiler might optimize away the instruction at 598 NEXT_FRAME's return address. As a result the return address will 599 point at some random instruction, and the CFI for that 600 instruction is probably worthless to us. GCC's unwinder solves 601 this problem by substracting 1 from the return address to get an 602 address in the middle of a presumed call instruction (or the 603 instruction in the associated delay slot). This should only be 604 done for "normal" frames and not for resume-type frames (signal 605 handlers, sentinel frames, dummy frames). The function 606 frame_unwind_address_in_block does just this. It's not clear how 607 reliable the method is though; there is the potential for the 608 register state pre-call being different to that on return. */ 609 fs->pc = frame_unwind_address_in_block (next_frame); 610 611 /* Find the correct FDE. */ 612 fde = dwarf2_frame_find_fde (&fs->pc); 613 gdb_assert (fde != NULL); 614 615 /* Extract any interesting information from the CIE. */ 616 fs->data_align = fde->cie->data_alignment_factor; 617 fs->code_align = fde->cie->code_alignment_factor; 618 fs->retaddr_column = fde->cie->return_address_register; 619 620 /* First decode all the insns in the CIE. */ 621 execute_cfa_program (fde->cie->initial_instructions, 622 fde->cie->end, next_frame, fs); 623 624 /* Save the initialized register set. */ 625 fs->initial = fs->regs; 626 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs); 627 628 /* Then decode the insns in the FDE up to our target PC. */ 629 execute_cfa_program (fde->instructions, fde->end, next_frame, fs); 630 631 /* Caclulate the CFA. */ 632 switch (fs->cfa_how) 633 { 634 case CFA_REG_OFFSET: 635 cache->cfa = read_reg (next_frame, fs->cfa_reg); 636 cache->cfa += fs->cfa_offset; 637 break; 638 639 case CFA_EXP: 640 cache->cfa = 641 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0); 642 break; 643 644 default: 645 internal_error (__FILE__, __LINE__, "Unknown CFA rule."); 646 } 647 648 /* Initialize the register state. */ 649 { 650 int regnum; 651 652 for (regnum = 0; regnum < num_regs; regnum++) 653 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]); 654 } 655 656 /* Go through the DWARF2 CFI generated table and save its register 657 location information in the cache. Note that we don't skip the 658 return address column; it's perfectly all right for it to 659 correspond to a real register. If it doesn't correspond to a 660 real register, or if we shouldn't treat it as such, 661 DWARF2_REG_TO_REGNUM should be defined to return a number outside 662 the range [0, NUM_REGS). */ 663 { 664 int column; /* CFI speak for "register number". */ 665 666 for (column = 0; column < fs->regs.num_regs; column++) 667 { 668 /* Use the GDB register number as the destination index. */ 669 int regnum = DWARF2_REG_TO_REGNUM (column); 670 671 /* If there's no corresponding GDB register, ignore it. */ 672 if (regnum < 0 || regnum >= num_regs) 673 continue; 674 675 /* NOTE: cagney/2003-09-05: CFI should specify the disposition 676 of all debug info registers. If it doesn't, complain (but 677 not too loudly). It turns out that GCC assumes that an 678 unspecified register implies "same value" when CFI (draft 679 7) specifies nothing at all. Such a register could equally 680 be interpreted as "undefined". Also note that this check 681 isn't sufficient; it only checks that all registers in the 682 range [0 .. max column] are specified, and won't detect 683 problems when a debug info register falls outside of the 684 table. We need a way of iterating through all the valid 685 DWARF2 register numbers. */ 686 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED) 687 complaint (&symfile_complaints, 688 "Incomplete CFI data; unspecified registers at 0x%s", 689 paddr (fs->pc)); 690 else 691 cache->reg[regnum] = fs->regs.reg[column]; 692 } 693 } 694 695 /* Eliminate any DWARF2_FRAME_REG_RA rules. */ 696 { 697 int regnum; 698 699 for (regnum = 0; regnum < num_regs; regnum++) 700 { 701 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA) 702 { 703 struct dwarf2_frame_state_reg *retaddr_reg = 704 &fs->regs.reg[fs->retaddr_column]; 705 706 /* It seems rather bizarre to specify an "empty" column as 707 the return adress column. However, this is exactly 708 what GCC does on some targets. It turns out that GCC 709 assumes that the return address can be found in the 710 register corresponding to the return address column. 711 Incidentally, that's how should treat a return address 712 column specifying "same value" too. */ 713 if (fs->retaddr_column < fs->regs.num_regs 714 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED 715 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE) 716 cache->reg[regnum] = *retaddr_reg; 717 else 718 { 719 cache->reg[regnum].loc.reg = fs->retaddr_column; 720 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG; 721 } 722 } 723 } 724 } 725 726 do_cleanups (old_chain); 727 728 *this_cache = cache; 729 return cache; 730} 731 732static void 733dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache, 734 struct frame_id *this_id) 735{ 736 struct dwarf2_frame_cache *cache = 737 dwarf2_frame_cache (next_frame, this_cache); 738 739 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame)); 740} 741 742static void 743dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache, 744 int regnum, int *optimizedp, 745 enum lval_type *lvalp, CORE_ADDR *addrp, 746 int *realnump, void *valuep) 747{ 748 struct gdbarch *gdbarch = get_frame_arch (next_frame); 749 struct dwarf2_frame_cache *cache = 750 dwarf2_frame_cache (next_frame, this_cache); 751 752 switch (cache->reg[regnum].how) 753 { 754 case DWARF2_FRAME_REG_UNDEFINED: 755 /* If CFI explicitly specified that the value isn't defined, 756 mark it as optimized away; the value isn't available. */ 757 *optimizedp = 1; 758 *lvalp = not_lval; 759 *addrp = 0; 760 *realnump = -1; 761 if (valuep) 762 { 763 /* In some cases, for example %eflags on the i386, we have 764 to provide a sane value, even though this register wasn't 765 saved. Assume we can get it from NEXT_FRAME. */ 766 frame_unwind_register (next_frame, regnum, valuep); 767 } 768 break; 769 770 case DWARF2_FRAME_REG_SAVED_OFFSET: 771 *optimizedp = 0; 772 *lvalp = lval_memory; 773 *addrp = cache->cfa + cache->reg[regnum].loc.offset; 774 *realnump = -1; 775 if (valuep) 776 { 777 /* Read the value in from memory. */ 778 read_memory (*addrp, valuep, register_size (gdbarch, regnum)); 779 } 780 break; 781 782 case DWARF2_FRAME_REG_SAVED_REG: 783 regnum = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg); 784 frame_register_unwind (next_frame, regnum, 785 optimizedp, lvalp, addrp, realnump, valuep); 786 break; 787 788 case DWARF2_FRAME_REG_SAVED_EXP: 789 *optimizedp = 0; 790 *lvalp = lval_memory; 791 *addrp = execute_stack_op (cache->reg[regnum].loc.exp, 792 cache->reg[regnum].exp_len, 793 next_frame, cache->cfa); 794 *realnump = -1; 795 if (valuep) 796 { 797 /* Read the value in from memory. */ 798 read_memory (*addrp, valuep, register_size (gdbarch, regnum)); 799 } 800 break; 801 802 case DWARF2_FRAME_REG_UNSPECIFIED: 803 /* GCC, in its infinite wisdom decided to not provide unwind 804 information for registers that are "same value". Since 805 DWARF2 (3 draft 7) doesn't define such behavior, said 806 registers are actually undefined (which is different to CFI 807 "undefined"). Code above issues a complaint about this. 808 Here just fudge the books, assume GCC, and that the value is 809 more inner on the stack. */ 810 frame_register_unwind (next_frame, regnum, 811 optimizedp, lvalp, addrp, realnump, valuep); 812 break; 813 814 case DWARF2_FRAME_REG_SAME_VALUE: 815 frame_register_unwind (next_frame, regnum, 816 optimizedp, lvalp, addrp, realnump, valuep); 817 break; 818 819 case DWARF2_FRAME_REG_CFA: 820 *optimizedp = 0; 821 *lvalp = not_lval; 822 *addrp = 0; 823 *realnump = -1; 824 if (valuep) 825 { 826 /* Store the value. */ 827 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa); 828 } 829 break; 830 831 default: 832 internal_error (__FILE__, __LINE__, "Unknown register rule."); 833 } 834} 835 836static const struct frame_unwind dwarf2_frame_unwind = 837{ 838 NORMAL_FRAME, 839 dwarf2_frame_this_id, 840 dwarf2_frame_prev_register 841}; 842 843const struct frame_unwind * 844dwarf2_frame_sniffer (struct frame_info *next_frame) 845{ 846 /* Grab an address that is guarenteed to reside somewhere within the 847 function. frame_pc_unwind(), for a no-return next function, can 848 end up returning something past the end of this function's body. */ 849 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame); 850 if (dwarf2_frame_find_fde (&block_addr)) 851 return &dwarf2_frame_unwind; 852 853 return NULL; 854} 855 856 857/* There is no explicitly defined relationship between the CFA and the 858 location of frame's local variables and arguments/parameters. 859 Therefore, frame base methods on this page should probably only be 860 used as a last resort, just to avoid printing total garbage as a 861 response to the "info frame" command. */ 862 863static CORE_ADDR 864dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache) 865{ 866 struct dwarf2_frame_cache *cache = 867 dwarf2_frame_cache (next_frame, this_cache); 868 869 return cache->cfa; 870} 871 872static const struct frame_base dwarf2_frame_base = 873{ 874 &dwarf2_frame_unwind, 875 dwarf2_frame_base_address, 876 dwarf2_frame_base_address, 877 dwarf2_frame_base_address 878}; 879 880const struct frame_base * 881dwarf2_frame_base_sniffer (struct frame_info *next_frame) 882{ 883 CORE_ADDR pc = frame_pc_unwind (next_frame); 884 if (dwarf2_frame_find_fde (&pc)) 885 return &dwarf2_frame_base; 886 887 return NULL; 888} 889 890/* A minimal decoding of DWARF2 compilation units. We only decode 891 what's needed to get to the call frame information. */ 892 893struct comp_unit 894{ 895 /* Keep the bfd convenient. */ 896 bfd *abfd; 897 898 struct objfile *objfile; 899 900 /* Linked list of CIEs for this object. */ 901 struct dwarf2_cie *cie; 902 903 /* Address size for this unit - from unit header. */ 904 unsigned char addr_size; 905 906 /* Pointer to the .debug_frame section loaded into memory. */ 907 char *dwarf_frame_buffer; 908 909 /* Length of the loaded .debug_frame section. */ 910 unsigned long dwarf_frame_size; 911 912 /* Pointer to the .debug_frame section. */ 913 asection *dwarf_frame_section; 914 915 /* Base for DW_EH_PE_datarel encodings. */ 916 bfd_vma dbase; 917 918 /* Base for DW_EH_PE_textrel encodings. */ 919 bfd_vma tbase; 920}; 921 922const struct objfile_data *dwarf2_frame_objfile_data; 923 924static unsigned int 925read_1_byte (bfd *bfd, char *buf) 926{ 927 return bfd_get_8 (abfd, (bfd_byte *) buf); 928} 929 930static unsigned int 931read_4_bytes (bfd *abfd, char *buf) 932{ 933 return bfd_get_32 (abfd, (bfd_byte *) buf); 934} 935 936static ULONGEST 937read_8_bytes (bfd *abfd, char *buf) 938{ 939 return bfd_get_64 (abfd, (bfd_byte *) buf); 940} 941 942static ULONGEST 943read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 944{ 945 ULONGEST result; 946 unsigned int num_read; 947 int shift; 948 unsigned char byte; 949 950 result = 0; 951 shift = 0; 952 num_read = 0; 953 954 do 955 { 956 byte = bfd_get_8 (abfd, (bfd_byte *) buf); 957 buf++; 958 num_read++; 959 result |= ((byte & 0x7f) << shift); 960 shift += 7; 961 } 962 while (byte & 0x80); 963 964 *bytes_read_ptr = num_read; 965 966 return result; 967} 968 969static LONGEST 970read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 971{ 972 LONGEST result; 973 int shift; 974 unsigned int num_read; 975 unsigned char byte; 976 977 result = 0; 978 shift = 0; 979 num_read = 0; 980 981 do 982 { 983 byte = bfd_get_8 (abfd, (bfd_byte *) buf); 984 buf++; 985 num_read++; 986 result |= ((byte & 0x7f) << shift); 987 shift += 7; 988 } 989 while (byte & 0x80); 990 991 if ((shift < 32) && (byte & 0x40)) 992 result |= -(1 << shift); 993 994 *bytes_read_ptr = num_read; 995 996 return result; 997} 998 999static ULONGEST 1000read_initial_length (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 1001{ 1002 LONGEST result; 1003 1004 result = bfd_get_32 (abfd, (bfd_byte *) buf); 1005 if (result == 0xffffffff) 1006 { 1007 result = bfd_get_64 (abfd, (bfd_byte *) buf + 4); 1008 *bytes_read_ptr = 12; 1009 } 1010 else 1011 *bytes_read_ptr = 4; 1012 1013 return result; 1014} 1015 1016 1017/* Pointer encoding helper functions. */ 1018 1019/* GCC supports exception handling based on DWARF2 CFI. However, for 1020 technical reasons, it encodes addresses in its FDE's in a different 1021 way. Several "pointer encodings" are supported. The encoding 1022 that's used for a particular FDE is determined by the 'R' 1023 augmentation in the associated CIE. The argument of this 1024 augmentation is a single byte. 1025 1026 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a 1027 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether 1028 the address is signed or unsigned. Bits 4, 5 and 6 encode how the 1029 address should be interpreted (absolute, relative to the current 1030 position in the FDE, ...). Bit 7, indicates that the address 1031 should be dereferenced. */ 1032 1033static unsigned char 1034encoding_for_size (unsigned int size) 1035{ 1036 switch (size) 1037 { 1038 case 2: 1039 return DW_EH_PE_udata2; 1040 case 4: 1041 return DW_EH_PE_udata4; 1042 case 8: 1043 return DW_EH_PE_udata8; 1044 default: 1045 internal_error (__FILE__, __LINE__, "Unsupported address size"); 1046 } 1047} 1048 1049static unsigned int 1050size_of_encoded_value (unsigned char encoding) 1051{ 1052 if (encoding == DW_EH_PE_omit) 1053 return 0; 1054 1055 switch (encoding & 0x07) 1056 { 1057 case DW_EH_PE_absptr: 1058 return TYPE_LENGTH (builtin_type_void_data_ptr); 1059 case DW_EH_PE_udata2: 1060 return 2; 1061 case DW_EH_PE_udata4: 1062 return 4; 1063 case DW_EH_PE_udata8: 1064 return 8; 1065 default: 1066 internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding"); 1067 } 1068} 1069 1070static CORE_ADDR 1071read_encoded_value (struct comp_unit *unit, unsigned char encoding, 1072 char *buf, unsigned int *bytes_read_ptr) 1073{ 1074 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr); 1075 ptrdiff_t offset; 1076 CORE_ADDR base; 1077 1078 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for 1079 FDE's. */ 1080 if (encoding & DW_EH_PE_indirect) 1081 internal_error (__FILE__, __LINE__, 1082 "Unsupported encoding: DW_EH_PE_indirect"); 1083 1084 *bytes_read_ptr = 0; 1085 1086 switch (encoding & 0x70) 1087 { 1088 case DW_EH_PE_absptr: 1089 base = 0; 1090 break; 1091 case DW_EH_PE_pcrel: 1092 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section); 1093 base += (buf - unit->dwarf_frame_buffer); 1094 break; 1095 case DW_EH_PE_datarel: 1096 base = unit->dbase; 1097 break; 1098 case DW_EH_PE_textrel: 1099 base = unit->tbase; 1100 break; 1101 case DW_EH_PE_funcrel: 1102 /* FIXME: kettenis/20040501: For now just pretend 1103 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For 1104 reading the initial location of an FDE it should be treated 1105 as such, and currently that's the only place where this code 1106 is used. */ 1107 base = 0; 1108 break; 1109 case DW_EH_PE_aligned: 1110 base = 0; 1111 offset = buf - unit->dwarf_frame_buffer; 1112 if ((offset % ptr_len) != 0) 1113 { 1114 *bytes_read_ptr = ptr_len - (offset % ptr_len); 1115 buf += *bytes_read_ptr; 1116 } 1117 break; 1118 default: 1119 internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding"); 1120 } 1121 1122 if ((encoding & 0x0f) == 0x00) 1123 encoding |= encoding_for_size (ptr_len); 1124 1125 switch (encoding & 0x0f) 1126 { 1127 case DW_EH_PE_udata2: 1128 *bytes_read_ptr += 2; 1129 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf)); 1130 case DW_EH_PE_udata4: 1131 *bytes_read_ptr += 4; 1132 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf)); 1133 case DW_EH_PE_udata8: 1134 *bytes_read_ptr += 8; 1135 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf)); 1136 case DW_EH_PE_sdata2: 1137 *bytes_read_ptr += 2; 1138 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf)); 1139 case DW_EH_PE_sdata4: 1140 *bytes_read_ptr += 4; 1141 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf)); 1142 case DW_EH_PE_sdata8: 1143 *bytes_read_ptr += 8; 1144 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf)); 1145 default: 1146 internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding"); 1147 } 1148} 1149 1150 1151/* GCC uses a single CIE for all FDEs in a .debug_frame section. 1152 That's why we use a simple linked list here. */ 1153 1154static struct dwarf2_cie * 1155find_cie (struct comp_unit *unit, ULONGEST cie_pointer) 1156{ 1157 struct dwarf2_cie *cie = unit->cie; 1158 1159 while (cie) 1160 { 1161 if (cie->cie_pointer == cie_pointer) 1162 return cie; 1163 1164 cie = cie->next; 1165 } 1166 1167 return NULL; 1168} 1169 1170static void 1171add_cie (struct comp_unit *unit, struct dwarf2_cie *cie) 1172{ 1173 cie->next = unit->cie; 1174 unit->cie = cie; 1175} 1176 1177/* Find the FDE for *PC. Return a pointer to the FDE, and store the 1178 inital location associated with it into *PC. */ 1179 1180static struct dwarf2_fde * 1181dwarf2_frame_find_fde (CORE_ADDR *pc) 1182{ 1183 struct objfile *objfile; 1184 1185 ALL_OBJFILES (objfile) 1186 { 1187 struct dwarf2_fde *fde; 1188 CORE_ADDR offset; 1189 1190 fde = objfile_data (objfile, dwarf2_frame_objfile_data); 1191 if (fde == NULL) 1192 continue; 1193 1194 gdb_assert (objfile->section_offsets); 1195 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1196 1197 while (fde) 1198 { 1199 if (*pc >= fde->initial_location + offset 1200 && *pc < fde->initial_location + offset + fde->address_range) 1201 { 1202 *pc = fde->initial_location + offset; 1203 return fde; 1204 } 1205 1206 fde = fde->next; 1207 } 1208 } 1209 1210 return NULL; 1211} 1212 1213static void 1214add_fde (struct comp_unit *unit, struct dwarf2_fde *fde) 1215{ 1216 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data); 1217 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde); 1218} 1219 1220#ifdef CC_HAS_LONG_LONG 1221#define DW64_CIE_ID 0xffffffffffffffffULL 1222#else 1223#define DW64_CIE_ID ~0 1224#endif 1225 1226static char *decode_frame_entry (struct comp_unit *unit, char *start, 1227 int eh_frame_p); 1228 1229/* Decode the next CIE or FDE. Return NULL if invalid input, otherwise 1230 the next byte to be processed. */ 1231static char * 1232decode_frame_entry_1 (struct comp_unit *unit, char *start, int eh_frame_p) 1233{ 1234 char *buf; 1235 LONGEST length; 1236 unsigned int bytes_read; 1237 int dwarf64_p; 1238 ULONGEST cie_id; 1239 ULONGEST cie_pointer; 1240 char *end; 1241 1242 buf = start; 1243 length = read_initial_length (unit->abfd, buf, &bytes_read); 1244 buf += bytes_read; 1245 end = buf + length; 1246 1247 /* Are we still within the section? */ 1248 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size) 1249 return NULL; 1250 1251 if (length == 0) 1252 return end; 1253 1254 /* Distinguish between 32 and 64-bit encoded frame info. */ 1255 dwarf64_p = (bytes_read == 12); 1256 1257 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */ 1258 if (eh_frame_p) 1259 cie_id = 0; 1260 else if (dwarf64_p) 1261 cie_id = DW64_CIE_ID; 1262 else 1263 cie_id = DW_CIE_ID; 1264 1265 if (dwarf64_p) 1266 { 1267 cie_pointer = read_8_bytes (unit->abfd, buf); 1268 buf += 8; 1269 } 1270 else 1271 { 1272 cie_pointer = read_4_bytes (unit->abfd, buf); 1273 buf += 4; 1274 } 1275 1276 if (cie_pointer == cie_id) 1277 { 1278 /* This is a CIE. */ 1279 struct dwarf2_cie *cie; 1280 char *augmentation; 1281 1282 /* Record the offset into the .debug_frame section of this CIE. */ 1283 cie_pointer = start - unit->dwarf_frame_buffer; 1284 1285 /* Check whether we've already read it. */ 1286 if (find_cie (unit, cie_pointer)) 1287 return end; 1288 1289 cie = (struct dwarf2_cie *) 1290 obstack_alloc (&unit->objfile->objfile_obstack, 1291 sizeof (struct dwarf2_cie)); 1292 cie->initial_instructions = NULL; 1293 cie->cie_pointer = cie_pointer; 1294 1295 /* The encoding for FDE's in a normal .debug_frame section 1296 depends on the target address size as specified in the 1297 Compilation Unit Header. */ 1298 cie->encoding = encoding_for_size (unit->addr_size); 1299 1300 /* Check version number. */ 1301 if (read_1_byte (unit->abfd, buf) != DW_CIE_VERSION) 1302 return NULL; 1303 buf += 1; 1304 1305 /* Interpret the interesting bits of the augmentation. */ 1306 augmentation = buf; 1307 buf = augmentation + strlen (augmentation) + 1; 1308 1309 /* The GCC 2.x "eh" augmentation has a pointer immediately 1310 following the augmentation string, so it must be handled 1311 first. */ 1312 if (augmentation[0] == 'e' && augmentation[1] == 'h') 1313 { 1314 /* Skip. */ 1315 buf += TYPE_LENGTH (builtin_type_void_data_ptr); 1316 augmentation += 2; 1317 } 1318 1319 cie->code_alignment_factor = 1320 read_unsigned_leb128 (unit->abfd, buf, &bytes_read); 1321 buf += bytes_read; 1322 1323 cie->data_alignment_factor = 1324 read_signed_leb128 (unit->abfd, buf, &bytes_read); 1325 buf += bytes_read; 1326 1327 cie->return_address_register = read_1_byte (unit->abfd, buf); 1328 buf += 1; 1329 1330 cie->saw_z_augmentation = (*augmentation == 'z'); 1331 if (cie->saw_z_augmentation) 1332 { 1333 ULONGEST length; 1334 1335 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read); 1336 buf += bytes_read; 1337 if (buf > end) 1338 return NULL; 1339 cie->initial_instructions = buf + length; 1340 augmentation++; 1341 } 1342 1343 while (*augmentation) 1344 { 1345 /* "L" indicates a byte showing how the LSDA pointer is encoded. */ 1346 if (*augmentation == 'L') 1347 { 1348 /* Skip. */ 1349 buf++; 1350 augmentation++; 1351 } 1352 1353 /* "R" indicates a byte indicating how FDE addresses are encoded. */ 1354 else if (*augmentation == 'R') 1355 { 1356 cie->encoding = *buf++; 1357 augmentation++; 1358 } 1359 1360 /* "P" indicates a personality routine in the CIE augmentation. */ 1361 else if (*augmentation == 'P') 1362 { 1363 /* Skip. */ 1364 buf += size_of_encoded_value (*buf++); 1365 augmentation++; 1366 } 1367 1368 /* Otherwise we have an unknown augmentation. 1369 Bail out unless we saw a 'z' prefix. */ 1370 else 1371 { 1372 if (cie->initial_instructions == NULL) 1373 return end; 1374 1375 /* Skip unknown augmentations. */ 1376 buf = cie->initial_instructions; 1377 break; 1378 } 1379 } 1380 1381 cie->initial_instructions = buf; 1382 cie->end = end; 1383 1384 add_cie (unit, cie); 1385 } 1386 else 1387 { 1388 /* This is a FDE. */ 1389 struct dwarf2_fde *fde; 1390 1391 /* In an .eh_frame section, the CIE pointer is the delta between the 1392 address within the FDE where the CIE pointer is stored and the 1393 address of the CIE. Convert it to an offset into the .eh_frame 1394 section. */ 1395 if (eh_frame_p) 1396 { 1397 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer; 1398 cie_pointer -= (dwarf64_p ? 8 : 4); 1399 } 1400 1401 /* In either case, validate the result is still within the section. */ 1402 if (cie_pointer >= unit->dwarf_frame_size) 1403 return NULL; 1404 1405 fde = (struct dwarf2_fde *) 1406 obstack_alloc (&unit->objfile->objfile_obstack, 1407 sizeof (struct dwarf2_fde)); 1408 fde->cie = find_cie (unit, cie_pointer); 1409 if (fde->cie == NULL) 1410 { 1411 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer, 1412 eh_frame_p); 1413 fde->cie = find_cie (unit, cie_pointer); 1414 } 1415 1416 gdb_assert (fde->cie != NULL); 1417 1418 fde->initial_location = 1419 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read); 1420 buf += bytes_read; 1421 1422 fde->address_range = 1423 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read); 1424 buf += bytes_read; 1425 1426 /* A 'z' augmentation in the CIE implies the presence of an 1427 augmentation field in the FDE as well. The only thing known 1428 to be in here at present is the LSDA entry for EH. So we 1429 can skip the whole thing. */ 1430 if (fde->cie->saw_z_augmentation) 1431 { 1432 ULONGEST length; 1433 1434 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read); 1435 buf += bytes_read + length; 1436 if (buf > end) 1437 return NULL; 1438 } 1439 1440 fde->instructions = buf; 1441 fde->end = end; 1442 1443 add_fde (unit, fde); 1444 } 1445 1446 return end; 1447} 1448 1449/* Read a CIE or FDE in BUF and decode it. */ 1450static char * 1451decode_frame_entry (struct comp_unit *unit, char *start, int eh_frame_p) 1452{ 1453 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE; 1454 char *ret; 1455 const char *msg; 1456 ptrdiff_t start_offset; 1457 1458 while (1) 1459 { 1460 ret = decode_frame_entry_1 (unit, start, eh_frame_p); 1461 if (ret != NULL) 1462 break; 1463 1464 /* We have corrupt input data of some form. */ 1465 1466 /* ??? Try, weakly, to work around compiler/assembler/linker bugs 1467 and mismatches wrt padding and alignment of debug sections. */ 1468 /* Note that there is no requirement in the standard for any 1469 alignment at all in the frame unwind sections. Testing for 1470 alignment before trying to interpret data would be incorrect. 1471 1472 However, GCC traditionally arranged for frame sections to be 1473 sized such that the FDE length and CIE fields happen to be 1474 aligned (in theory, for performance). This, unfortunately, 1475 was done with .align directives, which had the side effect of 1476 forcing the section to be aligned by the linker. 1477 1478 This becomes a problem when you have some other producer that 1479 creates frame sections that are not as strictly aligned. That 1480 produces a hole in the frame info that gets filled by the 1481 linker with zeros. 1482 1483 The GCC behaviour is arguably a bug, but it's effectively now 1484 part of the ABI, so we're now stuck with it, at least at the 1485 object file level. A smart linker may decide, in the process 1486 of compressing duplicate CIE information, that it can rewrite 1487 the entire output section without this extra padding. */ 1488 1489 start_offset = start - unit->dwarf_frame_buffer; 1490 if (workaround < ALIGN4 && (start_offset & 3) != 0) 1491 { 1492 start += 4 - (start_offset & 3); 1493 workaround = ALIGN4; 1494 continue; 1495 } 1496 if (workaround < ALIGN8 && (start_offset & 7) != 0) 1497 { 1498 start += 8 - (start_offset & 7); 1499 workaround = ALIGN8; 1500 continue; 1501 } 1502 1503 /* Nothing left to try. Arrange to return as if we've consumed 1504 the entire input section. Hopefully we'll get valid info from 1505 the other of .debug_frame/.eh_frame. */ 1506 workaround = FAIL; 1507 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size; 1508 break; 1509 } 1510 1511 switch (workaround) 1512 { 1513 case NONE: 1514 break; 1515 1516 case ALIGN4: 1517 complaint (&symfile_complaints, 1518 "Corrupt data in %s:%s; align 4 workaround apparently succeeded", 1519 unit->dwarf_frame_section->owner->filename, 1520 unit->dwarf_frame_section->name); 1521 break; 1522 1523 case ALIGN8: 1524 complaint (&symfile_complaints, 1525 "Corrupt data in %s:%s; align 8 workaround apparently succeeded", 1526 unit->dwarf_frame_section->owner->filename, 1527 unit->dwarf_frame_section->name); 1528 break; 1529 1530 default: 1531 complaint (&symfile_complaints, 1532 "Corrupt data in %s:%s", 1533 unit->dwarf_frame_section->owner->filename, 1534 unit->dwarf_frame_section->name); 1535 break; 1536 } 1537 1538 return ret; 1539} 1540 1541 1542/* FIXME: kettenis/20030504: This still needs to be integrated with 1543 dwarf2read.c in a better way. */ 1544 1545/* Imported from dwarf2read.c. */ 1546extern asection *dwarf_frame_section; 1547extern asection *dwarf_eh_frame_section; 1548 1549/* Imported from dwarf2read.c. */ 1550extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp); 1551 1552void 1553dwarf2_build_frame_info (struct objfile *objfile) 1554{ 1555 struct comp_unit unit; 1556 char *frame_ptr; 1557 1558 /* Build a minimal decoding of the DWARF2 compilation unit. */ 1559 unit.abfd = objfile->obfd; 1560 unit.objfile = objfile; 1561 unit.addr_size = objfile->obfd->arch_info->bits_per_address / 8; 1562 unit.dbase = 0; 1563 unit.tbase = 0; 1564 1565 /* First add the information from the .eh_frame section. That way, 1566 the FDEs from that section are searched last. */ 1567 if (dwarf_eh_frame_section) 1568 { 1569 asection *got, *txt; 1570 1571 unit.cie = NULL; 1572 unit.dwarf_frame_buffer = dwarf2_read_section (objfile, 1573 dwarf_eh_frame_section); 1574 1575 unit.dwarf_frame_size 1576 = bfd_get_section_size (dwarf_eh_frame_section); 1577 unit.dwarf_frame_section = dwarf_eh_frame_section; 1578 1579 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base 1580 that is used for the i386/amd64 target, which currently is 1581 the only target in GCC that supports/uses the 1582 DW_EH_PE_datarel encoding. */ 1583 got = bfd_get_section_by_name (unit.abfd, ".got"); 1584 if (got) 1585 unit.dbase = got->vma; 1586 1587 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64 1588 so far. */ 1589 txt = bfd_get_section_by_name (unit.abfd, ".text"); 1590 if (txt) 1591 unit.tbase = txt->vma; 1592 1593 frame_ptr = unit.dwarf_frame_buffer; 1594 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size) 1595 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1); 1596 } 1597 1598 if (dwarf_frame_section) 1599 { 1600 unit.cie = NULL; 1601 unit.dwarf_frame_buffer = dwarf2_read_section (objfile, 1602 dwarf_frame_section); 1603 unit.dwarf_frame_size 1604 = bfd_get_section_size (dwarf_frame_section); 1605 unit.dwarf_frame_section = dwarf_frame_section; 1606 1607 frame_ptr = unit.dwarf_frame_buffer; 1608 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size) 1609 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0); 1610 } 1611} 1612 1613/* Provide a prototype to silence -Wmissing-prototypes. */ 1614void _initialize_dwarf2_frame (void); 1615 1616void 1617_initialize_dwarf2_frame (void) 1618{ 1619 dwarf2_frame_data = register_gdbarch_data (dwarf2_frame_init); 1620 dwarf2_frame_objfile_data = register_objfile_data (); 1621} 1622