1/* DWARF 2 support. 2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 3 2004, 2005, 2006 Free Software Foundation, Inc. 4 5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions 6 (gavin@cygnus.com). 7 8 From the dwarf2read.c header: 9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, 10 Inc. with support from Florida State University (under contract 11 with the Ada Joint Program Office), and Silicon Graphics, Inc. 12 Initial contribution by Brent Benson, Harris Computer Systems, Inc., 13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1 14 support in dwarfread.c 15 16 This file is part of BFD. 17 18 This program is free software; you can redistribute it and/or modify 19 it under the terms of the GNU General Public License as published by 20 the Free Software Foundation; either version 2 of the License, or (at 21 your option) any later version. 22 23 This program is distributed in the hope that it will be useful, but 24 WITHOUT ANY WARRANTY; without even the implied warranty of 25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 26 General Public License for more details. 27 28 You should have received a copy of the GNU General Public License 29 along with this program; if not, write to the Free Software 30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 31 32#include "bfd.h" 33#include "sysdep.h" 34#include "libiberty.h" 35#include "libbfd.h" 36#include "elf-bfd.h" 37#include "elf/dwarf2.h" 38 39/* The data in the .debug_line statement prologue looks like this. */ 40 41struct line_head 42{ 43 bfd_vma total_length; 44 unsigned short version; 45 bfd_vma prologue_length; 46 unsigned char minimum_instruction_length; 47 unsigned char default_is_stmt; 48 int line_base; 49 unsigned char line_range; 50 unsigned char opcode_base; 51 unsigned char *standard_opcode_lengths; 52}; 53 54/* Attributes have a name and a value. */ 55 56struct attribute 57{ 58 enum dwarf_attribute name; 59 enum dwarf_form form; 60 union 61 { 62 char *str; 63 struct dwarf_block *blk; 64 bfd_uint64_t val; 65 bfd_int64_t sval; 66 } 67 u; 68}; 69 70/* Blocks are a bunch of untyped bytes. */ 71struct dwarf_block 72{ 73 unsigned int size; 74 bfd_byte *data; 75}; 76 77struct loadable_section 78{ 79 asection *section; 80 bfd_vma adj_vma; 81}; 82 83struct dwarf2_debug 84{ 85 /* A list of all previously read comp_units. */ 86 struct comp_unit *all_comp_units; 87 88 /* The next unread compilation unit within the .debug_info section. 89 Zero indicates that the .debug_info section has not been loaded 90 into a buffer yet. */ 91 bfd_byte *info_ptr; 92 93 /* Pointer to the end of the .debug_info section memory buffer. */ 94 bfd_byte *info_ptr_end; 95 96 /* Pointer to the section and address of the beginning of the 97 section. */ 98 asection *sec; 99 bfd_byte *sec_info_ptr; 100 101 /* Pointer to the symbol table. */ 102 asymbol **syms; 103 104 /* Pointer to the .debug_abbrev section loaded into memory. */ 105 bfd_byte *dwarf_abbrev_buffer; 106 107 /* Length of the loaded .debug_abbrev section. */ 108 unsigned long dwarf_abbrev_size; 109 110 /* Buffer for decode_line_info. */ 111 bfd_byte *dwarf_line_buffer; 112 113 /* Length of the loaded .debug_line section. */ 114 unsigned long dwarf_line_size; 115 116 /* Pointer to the .debug_str section loaded into memory. */ 117 bfd_byte *dwarf_str_buffer; 118 119 /* Length of the loaded .debug_str section. */ 120 unsigned long dwarf_str_size; 121 122 /* Pointer to the .debug_ranges section loaded into memory. */ 123 bfd_byte *dwarf_ranges_buffer; 124 125 /* Length of the loaded .debug_ranges section. */ 126 unsigned long dwarf_ranges_size; 127 128 /* If the most recent call to bfd_find_nearest_line was given an 129 address in an inlined function, preserve a pointer into the 130 calling chain for subsequent calls to bfd_find_inliner_info to 131 use. */ 132 struct funcinfo *inliner_chain; 133 134 /* Number of loadable sections. */ 135 unsigned int loadable_section_count; 136 137 /* Array of loadable sections. */ 138 struct loadable_section *loadable_sections; 139}; 140 141struct arange 142{ 143 struct arange *next; 144 bfd_vma low; 145 bfd_vma high; 146}; 147 148/* A minimal decoding of DWARF2 compilation units. We only decode 149 what's needed to get to the line number information. */ 150 151struct comp_unit 152{ 153 /* Chain the previously read compilation units. */ 154 struct comp_unit *next_unit; 155 156 /* Keep the bfd convenient (for memory allocation). */ 157 bfd *abfd; 158 159 /* The lowest and highest addresses contained in this compilation 160 unit as specified in the compilation unit header. */ 161 struct arange arange; 162 163 /* The DW_AT_name attribute (for error messages). */ 164 char *name; 165 166 /* The abbrev hash table. */ 167 struct abbrev_info **abbrevs; 168 169 /* Note that an error was found by comp_unit_find_nearest_line. */ 170 int error; 171 172 /* The DW_AT_comp_dir attribute. */ 173 char *comp_dir; 174 175 /* TRUE if there is a line number table associated with this comp. unit. */ 176 int stmtlist; 177 178 /* Pointer to the current comp_unit so that we can find a given entry 179 by its reference. */ 180 bfd_byte *info_ptr_unit; 181 182 /* The offset into .debug_line of the line number table. */ 183 unsigned long line_offset; 184 185 /* Pointer to the first child die for the comp unit. */ 186 bfd_byte *first_child_die_ptr; 187 188 /* The end of the comp unit. */ 189 bfd_byte *end_ptr; 190 191 /* The decoded line number, NULL if not yet decoded. */ 192 struct line_info_table *line_table; 193 194 /* A list of the functions found in this comp. unit. */ 195 struct funcinfo *function_table; 196 197 /* A list of the variables found in this comp. unit. */ 198 struct varinfo *variable_table; 199 200 /* Pointer to dwarf2_debug structure. */ 201 struct dwarf2_debug *stash; 202 203 /* Address size for this unit - from unit header. */ 204 unsigned char addr_size; 205 206 /* Offset size for this unit - from unit header. */ 207 unsigned char offset_size; 208 209 /* Base address for this unit - from DW_AT_low_pc attribute of 210 DW_TAG_compile_unit DIE */ 211 bfd_vma base_address; 212}; 213 214/* This data structure holds the information of an abbrev. */ 215struct abbrev_info 216{ 217 unsigned int number; /* Number identifying abbrev. */ 218 enum dwarf_tag tag; /* DWARF tag. */ 219 int has_children; /* Boolean. */ 220 unsigned int num_attrs; /* Number of attributes. */ 221 struct attr_abbrev *attrs; /* An array of attribute descriptions. */ 222 struct abbrev_info *next; /* Next in chain. */ 223}; 224 225struct attr_abbrev 226{ 227 enum dwarf_attribute name; 228 enum dwarf_form form; 229}; 230 231#ifndef ABBREV_HASH_SIZE 232#define ABBREV_HASH_SIZE 121 233#endif 234#ifndef ATTR_ALLOC_CHUNK 235#define ATTR_ALLOC_CHUNK 4 236#endif 237 238/* VERBATIM 239 The following function up to the END VERBATIM mark are 240 copied directly from dwarf2read.c. */ 241 242/* Read dwarf information from a buffer. */ 243 244static unsigned int 245read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf) 246{ 247 return bfd_get_8 (abfd, buf); 248} 249 250static int 251read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf) 252{ 253 return bfd_get_signed_8 (abfd, buf); 254} 255 256static unsigned int 257read_2_bytes (bfd *abfd, bfd_byte *buf) 258{ 259 return bfd_get_16 (abfd, buf); 260} 261 262static unsigned int 263read_4_bytes (bfd *abfd, bfd_byte *buf) 264{ 265 return bfd_get_32 (abfd, buf); 266} 267 268static bfd_uint64_t 269read_8_bytes (bfd *abfd, bfd_byte *buf) 270{ 271 return bfd_get_64 (abfd, buf); 272} 273 274static bfd_byte * 275read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED, 276 bfd_byte *buf, 277 unsigned int size ATTRIBUTE_UNUSED) 278{ 279 /* If the size of a host char is 8 bits, we can return a pointer 280 to the buffer, otherwise we have to copy the data to a buffer 281 allocated on the temporary obstack. */ 282 return buf; 283} 284 285static char * 286read_string (bfd *abfd ATTRIBUTE_UNUSED, 287 bfd_byte *buf, 288 unsigned int *bytes_read_ptr) 289{ 290 /* Return a pointer to the embedded string. */ 291 char *str = (char *) buf; 292 if (*str == '\0') 293 { 294 *bytes_read_ptr = 1; 295 return NULL; 296 } 297 298 *bytes_read_ptr = strlen (str) + 1; 299 return str; 300} 301 302static char * 303read_indirect_string (struct comp_unit* unit, 304 bfd_byte *buf, 305 unsigned int *bytes_read_ptr) 306{ 307 bfd_uint64_t offset; 308 struct dwarf2_debug *stash = unit->stash; 309 char *str; 310 311 if (unit->offset_size == 4) 312 offset = read_4_bytes (unit->abfd, buf); 313 else 314 offset = read_8_bytes (unit->abfd, buf); 315 *bytes_read_ptr = unit->offset_size; 316 317 if (! stash->dwarf_str_buffer) 318 { 319 asection *msec; 320 bfd *abfd = unit->abfd; 321 bfd_size_type sz; 322 323 msec = bfd_get_section_by_name (abfd, ".debug_str"); 324 if (! msec) 325 { 326 (*_bfd_error_handler) 327 (_("Dwarf Error: Can't find .debug_str section.")); 328 bfd_set_error (bfd_error_bad_value); 329 return NULL; 330 } 331 332 sz = msec->rawsize ? msec->rawsize : msec->size; 333 stash->dwarf_str_size = sz; 334 stash->dwarf_str_buffer = bfd_alloc (abfd, sz); 335 if (! stash->dwarf_str_buffer) 336 return NULL; 337 338 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer, 339 0, sz)) 340 return NULL; 341 } 342 343 if (offset >= stash->dwarf_str_size) 344 { 345 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."), 346 (unsigned long) offset, stash->dwarf_str_size); 347 bfd_set_error (bfd_error_bad_value); 348 return NULL; 349 } 350 351 str = (char *) stash->dwarf_str_buffer + offset; 352 if (*str == '\0') 353 return NULL; 354 return str; 355} 356 357/* END VERBATIM */ 358 359static bfd_uint64_t 360read_address (struct comp_unit *unit, bfd_byte *buf) 361{ 362 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma; 363 364 if (signed_vma) 365 { 366 switch (unit->addr_size) 367 { 368 case 8: 369 return bfd_get_signed_64 (unit->abfd, buf); 370 case 4: 371 return bfd_get_signed_32 (unit->abfd, buf); 372 case 2: 373 return bfd_get_signed_16 (unit->abfd, buf); 374 default: 375 abort (); 376 } 377 } 378 else 379 { 380 switch (unit->addr_size) 381 { 382 case 8: 383 return bfd_get_64 (unit->abfd, buf); 384 case 4: 385 return bfd_get_32 (unit->abfd, buf); 386 case 2: 387 return bfd_get_16 (unit->abfd, buf); 388 default: 389 abort (); 390 } 391 } 392} 393 394/* Lookup an abbrev_info structure in the abbrev hash table. */ 395 396static struct abbrev_info * 397lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs) 398{ 399 unsigned int hash_number; 400 struct abbrev_info *abbrev; 401 402 hash_number = number % ABBREV_HASH_SIZE; 403 abbrev = abbrevs[hash_number]; 404 405 while (abbrev) 406 { 407 if (abbrev->number == number) 408 return abbrev; 409 else 410 abbrev = abbrev->next; 411 } 412 413 return NULL; 414} 415 416/* In DWARF version 2, the description of the debugging information is 417 stored in a separate .debug_abbrev section. Before we read any 418 dies from a section we read in all abbreviations and install them 419 in a hash table. */ 420 421static struct abbrev_info** 422read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash) 423{ 424 struct abbrev_info **abbrevs; 425 bfd_byte *abbrev_ptr; 426 struct abbrev_info *cur_abbrev; 427 unsigned int abbrev_number, bytes_read, abbrev_name; 428 unsigned int abbrev_form, hash_number; 429 bfd_size_type amt; 430 431 if (! stash->dwarf_abbrev_buffer) 432 { 433 asection *msec; 434 435 msec = bfd_get_section_by_name (abfd, ".debug_abbrev"); 436 if (! msec) 437 { 438 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section.")); 439 bfd_set_error (bfd_error_bad_value); 440 return 0; 441 } 442 443 stash->dwarf_abbrev_size = msec->size; 444 stash->dwarf_abbrev_buffer 445 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, 446 stash->syms); 447 if (! stash->dwarf_abbrev_buffer) 448 return 0; 449 } 450 451 if (offset >= stash->dwarf_abbrev_size) 452 { 453 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."), 454 (unsigned long) offset, stash->dwarf_abbrev_size); 455 bfd_set_error (bfd_error_bad_value); 456 return 0; 457 } 458 459 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE; 460 abbrevs = bfd_zalloc (abfd, amt); 461 462 abbrev_ptr = stash->dwarf_abbrev_buffer + offset; 463 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 464 abbrev_ptr += bytes_read; 465 466 /* Loop until we reach an abbrev number of 0. */ 467 while (abbrev_number) 468 { 469 amt = sizeof (struct abbrev_info); 470 cur_abbrev = bfd_zalloc (abfd, amt); 471 472 /* Read in abbrev header. */ 473 cur_abbrev->number = abbrev_number; 474 cur_abbrev->tag = (enum dwarf_tag) 475 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 476 abbrev_ptr += bytes_read; 477 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr); 478 abbrev_ptr += 1; 479 480 /* Now read in declarations. */ 481 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 482 abbrev_ptr += bytes_read; 483 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 484 abbrev_ptr += bytes_read; 485 486 while (abbrev_name) 487 { 488 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0) 489 { 490 struct attr_abbrev *tmp; 491 492 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK; 493 amt *= sizeof (struct attr_abbrev); 494 tmp = bfd_realloc (cur_abbrev->attrs, amt); 495 if (tmp == NULL) 496 { 497 size_t i; 498 499 for (i = 0; i < ABBREV_HASH_SIZE; i++) 500 { 501 struct abbrev_info *abbrev = abbrevs[i]; 502 503 while (abbrev) 504 { 505 free (abbrev->attrs); 506 abbrev = abbrev->next; 507 } 508 } 509 return NULL; 510 } 511 cur_abbrev->attrs = tmp; 512 } 513 514 cur_abbrev->attrs[cur_abbrev->num_attrs].name 515 = (enum dwarf_attribute) abbrev_name; 516 cur_abbrev->attrs[cur_abbrev->num_attrs++].form 517 = (enum dwarf_form) abbrev_form; 518 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 519 abbrev_ptr += bytes_read; 520 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 521 abbrev_ptr += bytes_read; 522 } 523 524 hash_number = abbrev_number % ABBREV_HASH_SIZE; 525 cur_abbrev->next = abbrevs[hash_number]; 526 abbrevs[hash_number] = cur_abbrev; 527 528 /* Get next abbreviation. 529 Under Irix6 the abbreviations for a compilation unit are not 530 always properly terminated with an abbrev number of 0. 531 Exit loop if we encounter an abbreviation which we have 532 already read (which means we are about to read the abbreviations 533 for the next compile unit) or if the end of the abbreviation 534 table is reached. */ 535 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer) 536 >= stash->dwarf_abbrev_size) 537 break; 538 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 539 abbrev_ptr += bytes_read; 540 if (lookup_abbrev (abbrev_number,abbrevs) != NULL) 541 break; 542 } 543 544 return abbrevs; 545} 546 547/* Read an attribute value described by an attribute form. */ 548 549static bfd_byte * 550read_attribute_value (struct attribute *attr, 551 unsigned form, 552 struct comp_unit *unit, 553 bfd_byte *info_ptr) 554{ 555 bfd *abfd = unit->abfd; 556 unsigned int bytes_read; 557 struct dwarf_block *blk; 558 bfd_size_type amt; 559 560 attr->form = (enum dwarf_form) form; 561 562 switch (form) 563 { 564 case DW_FORM_addr: 565 /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */ 566 case DW_FORM_ref_addr: 567 attr->u.val = read_address (unit, info_ptr); 568 info_ptr += unit->addr_size; 569 break; 570 case DW_FORM_block2: 571 amt = sizeof (struct dwarf_block); 572 blk = bfd_alloc (abfd, amt); 573 blk->size = read_2_bytes (abfd, info_ptr); 574 info_ptr += 2; 575 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 576 info_ptr += blk->size; 577 attr->u.blk = blk; 578 break; 579 case DW_FORM_block4: 580 amt = sizeof (struct dwarf_block); 581 blk = bfd_alloc (abfd, amt); 582 blk->size = read_4_bytes (abfd, info_ptr); 583 info_ptr += 4; 584 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 585 info_ptr += blk->size; 586 attr->u.blk = blk; 587 break; 588 case DW_FORM_data2: 589 attr->u.val = read_2_bytes (abfd, info_ptr); 590 info_ptr += 2; 591 break; 592 case DW_FORM_data4: 593 attr->u.val = read_4_bytes (abfd, info_ptr); 594 info_ptr += 4; 595 break; 596 case DW_FORM_data8: 597 attr->u.val = read_8_bytes (abfd, info_ptr); 598 info_ptr += 8; 599 break; 600 case DW_FORM_string: 601 attr->u.str = read_string (abfd, info_ptr, &bytes_read); 602 info_ptr += bytes_read; 603 break; 604 case DW_FORM_strp: 605 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read); 606 info_ptr += bytes_read; 607 break; 608 case DW_FORM_block: 609 amt = sizeof (struct dwarf_block); 610 blk = bfd_alloc (abfd, amt); 611 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 612 info_ptr += bytes_read; 613 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 614 info_ptr += blk->size; 615 attr->u.blk = blk; 616 break; 617 case DW_FORM_block1: 618 amt = sizeof (struct dwarf_block); 619 blk = bfd_alloc (abfd, amt); 620 blk->size = read_1_byte (abfd, info_ptr); 621 info_ptr += 1; 622 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 623 info_ptr += blk->size; 624 attr->u.blk = blk; 625 break; 626 case DW_FORM_data1: 627 attr->u.val = read_1_byte (abfd, info_ptr); 628 info_ptr += 1; 629 break; 630 case DW_FORM_flag: 631 attr->u.val = read_1_byte (abfd, info_ptr); 632 info_ptr += 1; 633 break; 634 case DW_FORM_sdata: 635 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read); 636 info_ptr += bytes_read; 637 break; 638 case DW_FORM_udata: 639 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 640 info_ptr += bytes_read; 641 break; 642 case DW_FORM_ref1: 643 attr->u.val = read_1_byte (abfd, info_ptr); 644 info_ptr += 1; 645 break; 646 case DW_FORM_ref2: 647 attr->u.val = read_2_bytes (abfd, info_ptr); 648 info_ptr += 2; 649 break; 650 case DW_FORM_ref4: 651 attr->u.val = read_4_bytes (abfd, info_ptr); 652 info_ptr += 4; 653 break; 654 case DW_FORM_ref8: 655 attr->u.val = read_8_bytes (abfd, info_ptr); 656 info_ptr += 8; 657 break; 658 case DW_FORM_ref_udata: 659 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 660 info_ptr += bytes_read; 661 break; 662 case DW_FORM_indirect: 663 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 664 info_ptr += bytes_read; 665 info_ptr = read_attribute_value (attr, form, unit, info_ptr); 666 break; 667 default: 668 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."), 669 form); 670 bfd_set_error (bfd_error_bad_value); 671 } 672 return info_ptr; 673} 674 675/* Read an attribute described by an abbreviated attribute. */ 676 677static bfd_byte * 678read_attribute (struct attribute *attr, 679 struct attr_abbrev *abbrev, 680 struct comp_unit *unit, 681 bfd_byte *info_ptr) 682{ 683 attr->name = abbrev->name; 684 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr); 685 return info_ptr; 686} 687 688/* Source line information table routines. */ 689 690#define FILE_ALLOC_CHUNK 5 691#define DIR_ALLOC_CHUNK 5 692 693struct line_info 694{ 695 struct line_info* prev_line; 696 bfd_vma address; 697 char *filename; 698 unsigned int line; 699 unsigned int column; 700 int end_sequence; /* End of (sequential) code sequence. */ 701}; 702 703struct fileinfo 704{ 705 char *name; 706 unsigned int dir; 707 unsigned int time; 708 unsigned int size; 709}; 710 711struct line_info_table 712{ 713 bfd* abfd; 714 unsigned int num_files; 715 unsigned int num_dirs; 716 char *comp_dir; 717 char **dirs; 718 struct fileinfo* files; 719 struct line_info* last_line; /* largest VMA */ 720 struct line_info* lcl_head; /* local head; used in 'add_line_info' */ 721}; 722 723/* Remember some information about each function. If the function is 724 inlined (DW_TAG_inlined_subroutine) it may have two additional 725 attributes, DW_AT_call_file and DW_AT_call_line, which specify the 726 source code location where this function was inlined. */ 727 728struct funcinfo 729{ 730 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */ 731 struct funcinfo *caller_func; /* Pointer to function one scope higher */ 732 char *caller_file; /* Source location file name where caller_func inlines this func */ 733 int caller_line; /* Source location line number where caller_func inlines this func */ 734 char *file; /* Source location file name */ 735 int line; /* Source location line number */ 736 int tag; 737 char *name; 738 struct arange arange; 739 asection *sec; /* Where the symbol is defined */ 740}; 741 742struct varinfo 743{ 744 /* Pointer to previous variable in list of all variables */ 745 struct varinfo *prev_var; 746 /* Source location file name */ 747 char *file; 748 /* Source location line number */ 749 int line; 750 int tag; 751 char *name; 752 bfd_vma addr; 753 /* Where the symbol is defined */ 754 asection *sec; 755 /* Is this a stack variable? */ 756 unsigned int stack: 1; 757}; 758 759/* Return TRUE if NEW_LINE should sort after LINE. */ 760 761static inline bfd_boolean 762new_line_sorts_after (struct line_info *new_line, struct line_info *line) 763{ 764 return (new_line->address > line->address 765 || (new_line->address == line->address 766 && new_line->end_sequence < line->end_sequence)); 767} 768 769 770/* Adds a new entry to the line_info list in the line_info_table, ensuring 771 that the list is sorted. Note that the line_info list is sorted from 772 highest to lowest VMA (with possible duplicates); that is, 773 line_info->prev_line always accesses an equal or smaller VMA. */ 774 775static void 776add_line_info (struct line_info_table *table, 777 bfd_vma address, 778 char *filename, 779 unsigned int line, 780 unsigned int column, 781 int end_sequence) 782{ 783 bfd_size_type amt = sizeof (struct line_info); 784 struct line_info* info = bfd_alloc (table->abfd, amt); 785 786 /* Set member data of 'info'. */ 787 info->address = address; 788 info->line = line; 789 info->column = column; 790 info->end_sequence = end_sequence; 791 792 if (filename && filename[0]) 793 { 794 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1); 795 if (info->filename) 796 strcpy (info->filename, filename); 797 } 798 else 799 info->filename = NULL; 800 801 /* Find the correct location for 'info'. Normally we will receive 802 new line_info data 1) in order and 2) with increasing VMAs. 803 However some compilers break the rules (cf. decode_line_info) and 804 so we include some heuristics for quickly finding the correct 805 location for 'info'. In particular, these heuristics optimize for 806 the common case in which the VMA sequence that we receive is a 807 list of locally sorted VMAs such as 808 p...z a...j (where a < j < p < z) 809 810 Note: table->lcl_head is used to head an *actual* or *possible* 811 sequence within the list (such as a...j) that is not directly 812 headed by table->last_line 813 814 Note: we may receive duplicate entries from 'decode_line_info'. */ 815 816 if (!table->last_line 817 || new_line_sorts_after (info, table->last_line)) 818 { 819 /* Normal case: add 'info' to the beginning of the list */ 820 info->prev_line = table->last_line; 821 table->last_line = info; 822 823 /* lcl_head: initialize to head a *possible* sequence at the end. */ 824 if (!table->lcl_head) 825 table->lcl_head = info; 826 } 827 else if (!new_line_sorts_after (info, table->lcl_head) 828 && (!table->lcl_head->prev_line 829 || new_line_sorts_after (info, table->lcl_head->prev_line))) 830 { 831 /* Abnormal but easy: lcl_head is the head of 'info'. */ 832 info->prev_line = table->lcl_head->prev_line; 833 table->lcl_head->prev_line = info; 834 } 835 else 836 { 837 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid 838 heads for 'info'. Reset 'lcl_head'. */ 839 struct line_info* li2 = table->last_line; /* always non-NULL */ 840 struct line_info* li1 = li2->prev_line; 841 842 while (li1) 843 { 844 if (!new_line_sorts_after (info, li2) 845 && new_line_sorts_after (info, li1)) 846 break; 847 848 li2 = li1; /* always non-NULL */ 849 li1 = li1->prev_line; 850 } 851 table->lcl_head = li2; 852 info->prev_line = table->lcl_head->prev_line; 853 table->lcl_head->prev_line = info; 854 } 855} 856 857/* Extract a fully qualified filename from a line info table. 858 The returned string has been malloc'ed and it is the caller's 859 responsibility to free it. */ 860 861static char * 862concat_filename (struct line_info_table *table, unsigned int file) 863{ 864 char *filename; 865 866 if (file - 1 >= table->num_files) 867 { 868 /* FILE == 0 means unknown. */ 869 if (file) 870 (*_bfd_error_handler) 871 (_("Dwarf Error: mangled line number section (bad file number).")); 872 return strdup ("<unknown>"); 873 } 874 875 filename = table->files[file - 1].name; 876 877 if (!IS_ABSOLUTE_PATH (filename)) 878 { 879 char *dirname = NULL; 880 char *subdirname = NULL; 881 char *name; 882 size_t len; 883 884 if (table->files[file - 1].dir) 885 subdirname = table->dirs[table->files[file - 1].dir - 1]; 886 887 if (!subdirname || !IS_ABSOLUTE_PATH (subdirname)) 888 dirname = table->comp_dir; 889 890 if (!dirname) 891 { 892 dirname = subdirname; 893 subdirname = NULL; 894 } 895 896 if (!dirname) 897 return strdup (filename); 898 899 len = strlen (dirname) + strlen (filename) + 2; 900 901 if (subdirname) 902 { 903 len += strlen (subdirname) + 1; 904 name = bfd_malloc (len); 905 if (name) 906 sprintf (name, "%s/%s/%s", dirname, subdirname, filename); 907 } 908 else 909 { 910 name = bfd_malloc (len); 911 if (name) 912 sprintf (name, "%s/%s", dirname, filename); 913 } 914 915 return name; 916 } 917 918 return strdup (filename); 919} 920 921static void 922arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc) 923{ 924 struct arange *arange; 925 926 /* If the first arange is empty, use it. */ 927 if (first_arange->high == 0) 928 { 929 first_arange->low = low_pc; 930 first_arange->high = high_pc; 931 return; 932 } 933 934 /* Next see if we can cheaply extend an existing range. */ 935 arange = first_arange; 936 do 937 { 938 if (low_pc == arange->high) 939 { 940 arange->high = high_pc; 941 return; 942 } 943 if (high_pc == arange->low) 944 { 945 arange->low = low_pc; 946 return; 947 } 948 arange = arange->next; 949 } 950 while (arange); 951 952 /* Need to allocate a new arange and insert it into the arange list. 953 Order isn't significant, so just insert after the first arange. */ 954 arange = bfd_zalloc (abfd, sizeof (*arange)); 955 arange->low = low_pc; 956 arange->high = high_pc; 957 arange->next = first_arange->next; 958 first_arange->next = arange; 959} 960 961/* Decode the line number information for UNIT. */ 962 963static struct line_info_table* 964decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) 965{ 966 bfd *abfd = unit->abfd; 967 struct line_info_table* table; 968 bfd_byte *line_ptr; 969 bfd_byte *line_end; 970 struct line_head lh; 971 unsigned int i, bytes_read, offset_size; 972 char *cur_file, *cur_dir; 973 unsigned char op_code, extended_op, adj_opcode; 974 bfd_size_type amt; 975 976 if (! stash->dwarf_line_buffer) 977 { 978 asection *msec; 979 980 msec = bfd_get_section_by_name (abfd, ".debug_line"); 981 if (! msec) 982 { 983 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section.")); 984 bfd_set_error (bfd_error_bad_value); 985 return 0; 986 } 987 988 stash->dwarf_line_size = msec->size; 989 stash->dwarf_line_buffer 990 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, 991 stash->syms); 992 if (! stash->dwarf_line_buffer) 993 return 0; 994 } 995 996 /* It is possible to get a bad value for the line_offset. Validate 997 it here so that we won't get a segfault below. */ 998 if (unit->line_offset >= stash->dwarf_line_size) 999 { 1000 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."), 1001 unit->line_offset, stash->dwarf_line_size); 1002 bfd_set_error (bfd_error_bad_value); 1003 return 0; 1004 } 1005 1006 amt = sizeof (struct line_info_table); 1007 table = bfd_alloc (abfd, amt); 1008 table->abfd = abfd; 1009 table->comp_dir = unit->comp_dir; 1010 1011 table->num_files = 0; 1012 table->files = NULL; 1013 1014 table->num_dirs = 0; 1015 table->dirs = NULL; 1016 1017 table->files = NULL; 1018 table->last_line = NULL; 1019 table->lcl_head = NULL; 1020 1021 line_ptr = stash->dwarf_line_buffer + unit->line_offset; 1022 1023 /* Read in the prologue. */ 1024 lh.total_length = read_4_bytes (abfd, line_ptr); 1025 line_ptr += 4; 1026 offset_size = 4; 1027 if (lh.total_length == 0xffffffff) 1028 { 1029 lh.total_length = read_8_bytes (abfd, line_ptr); 1030 line_ptr += 8; 1031 offset_size = 8; 1032 } 1033 else if (lh.total_length == 0 && unit->addr_size == 8) 1034 { 1035 /* Handle (non-standard) 64-bit DWARF2 formats. */ 1036 lh.total_length = read_4_bytes (abfd, line_ptr); 1037 line_ptr += 4; 1038 offset_size = 8; 1039 } 1040 line_end = line_ptr + lh.total_length; 1041 lh.version = read_2_bytes (abfd, line_ptr); 1042 line_ptr += 2; 1043 if (offset_size == 4) 1044 lh.prologue_length = read_4_bytes (abfd, line_ptr); 1045 else 1046 lh.prologue_length = read_8_bytes (abfd, line_ptr); 1047 line_ptr += offset_size; 1048 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr); 1049 line_ptr += 1; 1050 lh.default_is_stmt = read_1_byte (abfd, line_ptr); 1051 line_ptr += 1; 1052 lh.line_base = read_1_signed_byte (abfd, line_ptr); 1053 line_ptr += 1; 1054 lh.line_range = read_1_byte (abfd, line_ptr); 1055 line_ptr += 1; 1056 lh.opcode_base = read_1_byte (abfd, line_ptr); 1057 line_ptr += 1; 1058 amt = lh.opcode_base * sizeof (unsigned char); 1059 lh.standard_opcode_lengths = bfd_alloc (abfd, amt); 1060 1061 lh.standard_opcode_lengths[0] = 1; 1062 1063 for (i = 1; i < lh.opcode_base; ++i) 1064 { 1065 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr); 1066 line_ptr += 1; 1067 } 1068 1069 /* Read directory table. */ 1070 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL) 1071 { 1072 line_ptr += bytes_read; 1073 1074 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0) 1075 { 1076 char **tmp; 1077 1078 amt = table->num_dirs + DIR_ALLOC_CHUNK; 1079 amt *= sizeof (char *); 1080 1081 tmp = bfd_realloc (table->dirs, amt); 1082 if (tmp == NULL) 1083 { 1084 free (table->dirs); 1085 return NULL; 1086 } 1087 table->dirs = tmp; 1088 } 1089 1090 table->dirs[table->num_dirs++] = cur_dir; 1091 } 1092 1093 line_ptr += bytes_read; 1094 1095 /* Read file name table. */ 1096 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL) 1097 { 1098 line_ptr += bytes_read; 1099 1100 if ((table->num_files % FILE_ALLOC_CHUNK) == 0) 1101 { 1102 struct fileinfo *tmp; 1103 1104 amt = table->num_files + FILE_ALLOC_CHUNK; 1105 amt *= sizeof (struct fileinfo); 1106 1107 tmp = bfd_realloc (table->files, amt); 1108 if (tmp == NULL) 1109 { 1110 free (table->files); 1111 free (table->dirs); 1112 return NULL; 1113 } 1114 table->files = tmp; 1115 } 1116 1117 table->files[table->num_files].name = cur_file; 1118 table->files[table->num_files].dir = 1119 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1120 line_ptr += bytes_read; 1121 table->files[table->num_files].time = 1122 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1123 line_ptr += bytes_read; 1124 table->files[table->num_files].size = 1125 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1126 line_ptr += bytes_read; 1127 table->num_files++; 1128 } 1129 1130 line_ptr += bytes_read; 1131 1132 /* Read the statement sequences until there's nothing left. */ 1133 while (line_ptr < line_end) 1134 { 1135 /* State machine registers. */ 1136 bfd_vma address = 0; 1137 char * filename = table->num_files ? concat_filename (table, 1) : NULL; 1138 unsigned int line = 1; 1139 unsigned int column = 0; 1140 int is_stmt = lh.default_is_stmt; 1141 int end_sequence = 0; 1142 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some 1143 compilers generate address sequences that are wildly out of 1144 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler 1145 for ia64-Linux). Thus, to determine the low and high 1146 address, we must compare on every DW_LNS_copy, etc. */ 1147 bfd_vma low_pc = (bfd_vma) -1; 1148 bfd_vma high_pc = 0; 1149 1150 /* Decode the table. */ 1151 while (! end_sequence) 1152 { 1153 op_code = read_1_byte (abfd, line_ptr); 1154 line_ptr += 1; 1155 1156 if (op_code >= lh.opcode_base) 1157 { 1158 /* Special operand. */ 1159 adj_opcode = op_code - lh.opcode_base; 1160 address += (adj_opcode / lh.line_range) 1161 * lh.minimum_instruction_length; 1162 line += lh.line_base + (adj_opcode % lh.line_range); 1163 /* Append row to matrix using current values. */ 1164 add_line_info (table, address, filename, line, column, 0); 1165 if (address < low_pc) 1166 low_pc = address; 1167 if (address > high_pc) 1168 high_pc = address; 1169 } 1170 else switch (op_code) 1171 { 1172 case DW_LNS_extended_op: 1173 /* Ignore length. */ 1174 line_ptr += 1; 1175 extended_op = read_1_byte (abfd, line_ptr); 1176 line_ptr += 1; 1177 1178 switch (extended_op) 1179 { 1180 case DW_LNE_end_sequence: 1181 end_sequence = 1; 1182 add_line_info (table, address, filename, line, column, 1183 end_sequence); 1184 if (address < low_pc) 1185 low_pc = address; 1186 if (address > high_pc) 1187 high_pc = address; 1188 arange_add (unit->abfd, &unit->arange, low_pc, high_pc); 1189 break; 1190 case DW_LNE_set_address: 1191 address = read_address (unit, line_ptr); 1192 line_ptr += unit->addr_size; 1193 break; 1194 case DW_LNE_define_file: 1195 cur_file = read_string (abfd, line_ptr, &bytes_read); 1196 line_ptr += bytes_read; 1197 if ((table->num_files % FILE_ALLOC_CHUNK) == 0) 1198 { 1199 struct fileinfo *tmp; 1200 1201 amt = table->num_files + FILE_ALLOC_CHUNK; 1202 amt *= sizeof (struct fileinfo); 1203 tmp = bfd_realloc (table->files, amt); 1204 if (tmp == NULL) 1205 { 1206 free (table->files); 1207 free (table->dirs); 1208 free (filename); 1209 return NULL; 1210 } 1211 table->files = tmp; 1212 } 1213 table->files[table->num_files].name = cur_file; 1214 table->files[table->num_files].dir = 1215 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1216 line_ptr += bytes_read; 1217 table->files[table->num_files].time = 1218 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1219 line_ptr += bytes_read; 1220 table->files[table->num_files].size = 1221 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1222 line_ptr += bytes_read; 1223 table->num_files++; 1224 break; 1225 default: 1226 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section.")); 1227 bfd_set_error (bfd_error_bad_value); 1228 free (filename); 1229 free (table->files); 1230 free (table->dirs); 1231 return NULL; 1232 } 1233 break; 1234 case DW_LNS_copy: 1235 add_line_info (table, address, filename, line, column, 0); 1236 if (address < low_pc) 1237 low_pc = address; 1238 if (address > high_pc) 1239 high_pc = address; 1240 break; 1241 case DW_LNS_advance_pc: 1242 address += lh.minimum_instruction_length 1243 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1244 line_ptr += bytes_read; 1245 break; 1246 case DW_LNS_advance_line: 1247 line += read_signed_leb128 (abfd, line_ptr, &bytes_read); 1248 line_ptr += bytes_read; 1249 break; 1250 case DW_LNS_set_file: 1251 { 1252 unsigned int file; 1253 1254 /* The file and directory tables are 0 1255 based, the references are 1 based. */ 1256 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1257 line_ptr += bytes_read; 1258 if (filename) 1259 free (filename); 1260 filename = concat_filename (table, file); 1261 break; 1262 } 1263 case DW_LNS_set_column: 1264 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1265 line_ptr += bytes_read; 1266 break; 1267 case DW_LNS_negate_stmt: 1268 is_stmt = (!is_stmt); 1269 break; 1270 case DW_LNS_set_basic_block: 1271 break; 1272 case DW_LNS_const_add_pc: 1273 address += lh.minimum_instruction_length 1274 * ((255 - lh.opcode_base) / lh.line_range); 1275 break; 1276 case DW_LNS_fixed_advance_pc: 1277 address += read_2_bytes (abfd, line_ptr); 1278 line_ptr += 2; 1279 break; 1280 default: 1281 { 1282 int i; 1283 1284 /* Unknown standard opcode, ignore it. */ 1285 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++) 1286 { 1287 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1288 line_ptr += bytes_read; 1289 } 1290 } 1291 } 1292 } 1293 1294 if (filename) 1295 free (filename); 1296 } 1297 1298 return table; 1299} 1300 1301/* If ADDR is within TABLE set the output parameters and return TRUE, 1302 otherwise return FALSE. The output parameters, FILENAME_PTR and 1303 LINENUMBER_PTR, are pointers to the objects to be filled in. */ 1304 1305static bfd_boolean 1306lookup_address_in_line_info_table (struct line_info_table *table, 1307 bfd_vma addr, 1308 struct funcinfo *function, 1309 const char **filename_ptr, 1310 unsigned int *linenumber_ptr) 1311{ 1312 /* Note: table->last_line should be a descendingly sorted list. */ 1313 struct line_info* next_line = table->last_line; 1314 struct line_info* each_line = NULL; 1315 *filename_ptr = NULL; 1316 1317 if (!next_line) 1318 return FALSE; 1319 1320 each_line = next_line->prev_line; 1321 1322 /* Check for large addresses */ 1323 if (addr > next_line->address) 1324 each_line = NULL; /* ensure we skip over the normal case */ 1325 1326 /* Normal case: search the list; save */ 1327 while (each_line && next_line) 1328 { 1329 /* If we have an address match, save this info. This allows us 1330 to return as good as results as possible for strange debugging 1331 info. */ 1332 bfd_boolean addr_match = FALSE; 1333 if (each_line->address <= addr && addr < next_line->address) 1334 { 1335 addr_match = TRUE; 1336 1337 /* If this line appears to span functions, and addr is in the 1338 later function, return the first line of that function instead 1339 of the last line of the earlier one. This check is for GCC 1340 2.95, which emits the first line number for a function late. */ 1341 1342 if (function != NULL) 1343 { 1344 bfd_vma lowest_pc; 1345 struct arange *arange; 1346 1347 /* Find the lowest address in the function's range list */ 1348 lowest_pc = function->arange.low; 1349 for (arange = &function->arange; 1350 arange; 1351 arange = arange->next) 1352 { 1353 if (function->arange.low < lowest_pc) 1354 lowest_pc = function->arange.low; 1355 } 1356 /* Check for spanning function and set outgoing line info */ 1357 if (addr >= lowest_pc 1358 && each_line->address < lowest_pc 1359 && next_line->address > lowest_pc) 1360 { 1361 *filename_ptr = next_line->filename; 1362 *linenumber_ptr = next_line->line; 1363 } 1364 else 1365 { 1366 *filename_ptr = each_line->filename; 1367 *linenumber_ptr = each_line->line; 1368 } 1369 } 1370 else 1371 { 1372 *filename_ptr = each_line->filename; 1373 *linenumber_ptr = each_line->line; 1374 } 1375 } 1376 1377 if (addr_match && !each_line->end_sequence) 1378 return TRUE; /* we have definitely found what we want */ 1379 1380 next_line = each_line; 1381 each_line = each_line->prev_line; 1382 } 1383 1384 /* At this point each_line is NULL but next_line is not. If we found 1385 a candidate end-of-sequence point in the loop above, we can return 1386 that (compatibility with a bug in the Intel compiler); otherwise, 1387 assuming that we found the containing function for this address in 1388 this compilation unit, return the first line we have a number for 1389 (compatibility with GCC 2.95). */ 1390 if (*filename_ptr == NULL && function != NULL) 1391 { 1392 *filename_ptr = next_line->filename; 1393 *linenumber_ptr = next_line->line; 1394 return TRUE; 1395 } 1396 1397 return FALSE; 1398} 1399 1400/* Read in the .debug_ranges section for future reference */ 1401 1402static bfd_boolean 1403read_debug_ranges (struct comp_unit *unit) 1404{ 1405 struct dwarf2_debug *stash = unit->stash; 1406 if (! stash->dwarf_ranges_buffer) 1407 { 1408 bfd *abfd = unit->abfd; 1409 asection *msec; 1410 1411 msec = bfd_get_section_by_name (abfd, ".debug_ranges"); 1412 if (! msec) 1413 { 1414 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section.")); 1415 bfd_set_error (bfd_error_bad_value); 1416 return FALSE; 1417 } 1418 1419 stash->dwarf_ranges_size = msec->size; 1420 stash->dwarf_ranges_buffer 1421 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, 1422 stash->syms); 1423 if (! stash->dwarf_ranges_buffer) 1424 return FALSE; 1425 } 1426 return TRUE; 1427} 1428 1429/* Function table functions. */ 1430 1431/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE. 1432 Note that we need to find the function that has the smallest 1433 range that contains ADDR, to handle inlined functions without 1434 depending upon them being ordered in TABLE by increasing range. */ 1435 1436static bfd_boolean 1437lookup_address_in_function_table (struct comp_unit *unit, 1438 bfd_vma addr, 1439 struct funcinfo **function_ptr, 1440 const char **functionname_ptr) 1441{ 1442 struct funcinfo* each_func; 1443 struct funcinfo* best_fit = NULL; 1444 struct arange *arange; 1445 1446 for (each_func = unit->function_table; 1447 each_func; 1448 each_func = each_func->prev_func) 1449 { 1450 for (arange = &each_func->arange; 1451 arange; 1452 arange = arange->next) 1453 { 1454 if (addr >= arange->low && addr < arange->high) 1455 { 1456 if (!best_fit || 1457 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low))) 1458 best_fit = each_func; 1459 } 1460 } 1461 } 1462 1463 if (best_fit) 1464 { 1465 *functionname_ptr = best_fit->name; 1466 *function_ptr = best_fit; 1467 return TRUE; 1468 } 1469 else 1470 { 1471 return FALSE; 1472 } 1473} 1474 1475/* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR 1476 and LINENUMBER_PTR, and return TRUE. */ 1477 1478static bfd_boolean 1479lookup_symbol_in_function_table (struct comp_unit *unit, 1480 asymbol *sym, 1481 bfd_vma addr, 1482 const char **filename_ptr, 1483 unsigned int *linenumber_ptr) 1484{ 1485 struct funcinfo* each_func; 1486 struct funcinfo* best_fit = NULL; 1487 struct arange *arange; 1488 const char *name = bfd_asymbol_name (sym); 1489 asection *sec = bfd_get_section (sym); 1490 1491 for (each_func = unit->function_table; 1492 each_func; 1493 each_func = each_func->prev_func) 1494 { 1495 for (arange = &each_func->arange; 1496 arange; 1497 arange = arange->next) 1498 { 1499 if ((!each_func->sec || each_func->sec == sec) 1500 && addr >= arange->low 1501 && addr < arange->high 1502 && each_func->name 1503 && strcmp (name, each_func->name) == 0 1504 && (!best_fit 1505 || ((arange->high - arange->low) 1506 < (best_fit->arange.high - best_fit->arange.low)))) 1507 best_fit = each_func; 1508 } 1509 } 1510 1511 if (best_fit) 1512 { 1513 best_fit->sec = sec; 1514 *filename_ptr = best_fit->file; 1515 *linenumber_ptr = best_fit->line; 1516 return TRUE; 1517 } 1518 else 1519 return FALSE; 1520} 1521 1522/* Variable table functions. */ 1523 1524/* If SYM is within variable table of UNIT, set FILENAME_PTR and 1525 LINENUMBER_PTR, and return TRUE. */ 1526 1527static bfd_boolean 1528lookup_symbol_in_variable_table (struct comp_unit *unit, 1529 asymbol *sym, 1530 bfd_vma addr, 1531 const char **filename_ptr, 1532 unsigned int *linenumber_ptr) 1533{ 1534 const char *name = bfd_asymbol_name (sym); 1535 asection *sec = bfd_get_section (sym); 1536 struct varinfo* each; 1537 1538 for (each = unit->variable_table; each; each = each->prev_var) 1539 if (each->stack == 0 1540 && each->file != NULL 1541 && each->name != NULL 1542 && each->addr == addr 1543 && (!each->sec || each->sec == sec) 1544 && strcmp (name, each->name) == 0) 1545 break; 1546 1547 if (each) 1548 { 1549 each->sec = sec; 1550 *filename_ptr = each->file; 1551 *linenumber_ptr = each->line; 1552 return TRUE; 1553 } 1554 else 1555 return FALSE; 1556} 1557 1558static char * 1559find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref) 1560{ 1561 bfd *abfd = unit->abfd; 1562 bfd_byte *info_ptr; 1563 unsigned int abbrev_number, bytes_read, i; 1564 struct abbrev_info *abbrev; 1565 struct attribute attr; 1566 char *name = 0; 1567 1568 info_ptr = unit->info_ptr_unit + die_ref; 1569 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1570 info_ptr += bytes_read; 1571 1572 if (abbrev_number) 1573 { 1574 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs); 1575 if (! abbrev) 1576 { 1577 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."), 1578 abbrev_number); 1579 bfd_set_error (bfd_error_bad_value); 1580 } 1581 else 1582 { 1583 for (i = 0; i < abbrev->num_attrs; ++i) 1584 { 1585 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); 1586 switch (attr.name) 1587 { 1588 case DW_AT_name: 1589 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ 1590 if (name == NULL) 1591 name = attr.u.str; 1592 break; 1593 case DW_AT_specification: 1594 name = find_abstract_instance_name (unit, attr.u.val); 1595 break; 1596 case DW_AT_MIPS_linkage_name: 1597 name = attr.u.str; 1598 break; 1599 default: 1600 break; 1601 } 1602 } 1603 } 1604 } 1605 return (name); 1606} 1607 1608static void 1609read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset) 1610{ 1611 bfd_byte *ranges_ptr; 1612 bfd_vma base_address = unit->base_address; 1613 1614 if (! unit->stash->dwarf_ranges_buffer) 1615 { 1616 if (! read_debug_ranges (unit)) 1617 return; 1618 } 1619 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset; 1620 1621 for (;;) 1622 { 1623 bfd_vma low_pc; 1624 bfd_vma high_pc; 1625 1626 if (unit->addr_size == 4) 1627 { 1628 low_pc = read_4_bytes (unit->abfd, ranges_ptr); 1629 ranges_ptr += 4; 1630 high_pc = read_4_bytes (unit->abfd, ranges_ptr); 1631 ranges_ptr += 4; 1632 } 1633 else 1634 { 1635 low_pc = read_8_bytes (unit->abfd, ranges_ptr); 1636 ranges_ptr += 8; 1637 high_pc = read_8_bytes (unit->abfd, ranges_ptr); 1638 ranges_ptr += 8; 1639 } 1640 if (low_pc == 0 && high_pc == 0) 1641 break; 1642 if (low_pc == -1UL && high_pc != -1UL) 1643 base_address = high_pc; 1644 else 1645 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc); 1646 } 1647} 1648 1649/* DWARF2 Compilation unit functions. */ 1650 1651/* Scan over each die in a comp. unit looking for functions to add 1652 to the function table and variables to the variable table. */ 1653 1654static bfd_boolean 1655scan_unit_for_symbols (struct comp_unit *unit) 1656{ 1657 bfd *abfd = unit->abfd; 1658 bfd_byte *info_ptr = unit->first_child_die_ptr; 1659 int nesting_level = 1; 1660 struct funcinfo **nested_funcs; 1661 int nested_funcs_size; 1662 1663 /* Maintain a stack of in-scope functions and inlined functions, which we 1664 can use to set the caller_func field. */ 1665 nested_funcs_size = 32; 1666 nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *)); 1667 if (nested_funcs == NULL) 1668 return FALSE; 1669 nested_funcs[nesting_level] = 0; 1670 1671 while (nesting_level) 1672 { 1673 unsigned int abbrev_number, bytes_read, i; 1674 struct abbrev_info *abbrev; 1675 struct attribute attr; 1676 struct funcinfo *func; 1677 struct varinfo *var; 1678 bfd_vma low_pc = 0; 1679 bfd_vma high_pc = 0; 1680 1681 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1682 info_ptr += bytes_read; 1683 1684 if (! abbrev_number) 1685 { 1686 nesting_level--; 1687 continue; 1688 } 1689 1690 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs); 1691 if (! abbrev) 1692 { 1693 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."), 1694 abbrev_number); 1695 bfd_set_error (bfd_error_bad_value); 1696 free (nested_funcs); 1697 return FALSE; 1698 } 1699 1700 var = NULL; 1701 if (abbrev->tag == DW_TAG_subprogram 1702 || abbrev->tag == DW_TAG_entry_point 1703 || abbrev->tag == DW_TAG_inlined_subroutine) 1704 { 1705 bfd_size_type amt = sizeof (struct funcinfo); 1706 func = bfd_zalloc (abfd, amt); 1707 func->tag = abbrev->tag; 1708 func->prev_func = unit->function_table; 1709 unit->function_table = func; 1710 1711 if (func->tag == DW_TAG_inlined_subroutine) 1712 for (i = nesting_level - 1; i >= 1; i--) 1713 if (nested_funcs[i]) 1714 { 1715 func->caller_func = nested_funcs[i]; 1716 break; 1717 } 1718 nested_funcs[nesting_level] = func; 1719 } 1720 else 1721 { 1722 func = NULL; 1723 if (abbrev->tag == DW_TAG_variable) 1724 { 1725 bfd_size_type amt = sizeof (struct varinfo); 1726 var = bfd_zalloc (abfd, amt); 1727 var->tag = abbrev->tag; 1728 var->stack = 1; 1729 var->prev_var = unit->variable_table; 1730 unit->variable_table = var; 1731 } 1732 1733 /* No inline function in scope at this nesting level. */ 1734 nested_funcs[nesting_level] = 0; 1735 } 1736 1737 for (i = 0; i < abbrev->num_attrs; ++i) 1738 { 1739 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); 1740 1741 if (func) 1742 { 1743 switch (attr.name) 1744 { 1745 case DW_AT_call_file: 1746 func->caller_file = concat_filename (unit->line_table, attr.u.val); 1747 break; 1748 1749 case DW_AT_call_line: 1750 func->caller_line = attr.u.val; 1751 break; 1752 1753 case DW_AT_abstract_origin: 1754 func->name = find_abstract_instance_name (unit, attr.u.val); 1755 break; 1756 1757 case DW_AT_name: 1758 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ 1759 if (func->name == NULL) 1760 func->name = attr.u.str; 1761 break; 1762 1763 case DW_AT_MIPS_linkage_name: 1764 func->name = attr.u.str; 1765 break; 1766 1767 case DW_AT_low_pc: 1768 low_pc = attr.u.val; 1769 break; 1770 1771 case DW_AT_high_pc: 1772 high_pc = attr.u.val; 1773 break; 1774 1775 case DW_AT_ranges: 1776 read_rangelist (unit, &func->arange, attr.u.val); 1777 break; 1778 1779 case DW_AT_decl_file: 1780 func->file = concat_filename (unit->line_table, 1781 attr.u.val); 1782 break; 1783 1784 case DW_AT_decl_line: 1785 func->line = attr.u.val; 1786 break; 1787 1788 default: 1789 break; 1790 } 1791 } 1792 else if (var) 1793 { 1794 switch (attr.name) 1795 { 1796 case DW_AT_name: 1797 var->name = attr.u.str; 1798 break; 1799 1800 case DW_AT_decl_file: 1801 var->file = concat_filename (unit->line_table, 1802 attr.u.val); 1803 break; 1804 1805 case DW_AT_decl_line: 1806 var->line = attr.u.val; 1807 break; 1808 1809 case DW_AT_external: 1810 if (attr.u.val != 0) 1811 var->stack = 0; 1812 break; 1813 1814 case DW_AT_location: 1815 switch (attr.form) 1816 { 1817 case DW_FORM_block: 1818 case DW_FORM_block1: 1819 case DW_FORM_block2: 1820 case DW_FORM_block4: 1821 if (*attr.u.blk->data == DW_OP_addr) 1822 { 1823 var->stack = 0; 1824 1825 /* Verify that DW_OP_addr is the only opcode in the 1826 location, in which case the block size will be 1 1827 plus the address size. */ 1828 /* ??? For TLS variables, gcc can emit 1829 DW_OP_addr <addr> DW_OP_GNU_push_tls_address 1830 which we don't handle here yet. */ 1831 if (attr.u.blk->size == unit->addr_size + 1U) 1832 var->addr = bfd_get (unit->addr_size * 8, 1833 unit->abfd, 1834 attr.u.blk->data + 1); 1835 } 1836 break; 1837 1838 default: 1839 break; 1840 } 1841 break; 1842 1843 default: 1844 break; 1845 } 1846 } 1847 } 1848 1849 if (func && high_pc != 0) 1850 { 1851 arange_add (unit->abfd, &func->arange, low_pc, high_pc); 1852 } 1853 1854 if (abbrev->has_children) 1855 { 1856 nesting_level++; 1857 1858 if (nesting_level >= nested_funcs_size) 1859 { 1860 struct funcinfo **tmp; 1861 1862 nested_funcs_size *= 2; 1863 tmp = bfd_realloc (nested_funcs, 1864 (nested_funcs_size 1865 * sizeof (struct funcinfo *))); 1866 if (tmp == NULL) 1867 { 1868 free (nested_funcs); 1869 return FALSE; 1870 } 1871 nested_funcs = tmp; 1872 } 1873 nested_funcs[nesting_level] = 0; 1874 } 1875 } 1876 1877 free (nested_funcs); 1878 return TRUE; 1879} 1880 1881/* Parse a DWARF2 compilation unit starting at INFO_PTR. This 1882 includes the compilation unit header that proceeds the DIE's, but 1883 does not include the length field that precedes each compilation 1884 unit header. END_PTR points one past the end of this comp unit. 1885 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes). 1886 1887 This routine does not read the whole compilation unit; only enough 1888 to get to the line number information for the compilation unit. */ 1889 1890static struct comp_unit * 1891parse_comp_unit (bfd *abfd, 1892 struct dwarf2_debug *stash, 1893 bfd_vma unit_length, 1894 bfd_byte *info_ptr_unit, 1895 unsigned int offset_size) 1896{ 1897 struct comp_unit* unit; 1898 unsigned int version; 1899 bfd_uint64_t abbrev_offset = 0; 1900 unsigned int addr_size; 1901 struct abbrev_info** abbrevs; 1902 unsigned int abbrev_number, bytes_read, i; 1903 struct abbrev_info *abbrev; 1904 struct attribute attr; 1905 bfd_byte *info_ptr = stash->info_ptr; 1906 bfd_byte *end_ptr = info_ptr + unit_length; 1907 bfd_size_type amt; 1908 bfd_vma low_pc = 0; 1909 bfd_vma high_pc = 0; 1910 1911 version = read_2_bytes (abfd, info_ptr); 1912 info_ptr += 2; 1913 BFD_ASSERT (offset_size == 4 || offset_size == 8); 1914 if (offset_size == 4) 1915 abbrev_offset = read_4_bytes (abfd, info_ptr); 1916 else 1917 abbrev_offset = read_8_bytes (abfd, info_ptr); 1918 info_ptr += offset_size; 1919 addr_size = read_1_byte (abfd, info_ptr); 1920 info_ptr += 1; 1921 1922 if (version != 2) 1923 { 1924 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version); 1925 bfd_set_error (bfd_error_bad_value); 1926 return 0; 1927 } 1928 1929 if (addr_size > sizeof (bfd_vma)) 1930 { 1931 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."), 1932 addr_size, 1933 (unsigned int) sizeof (bfd_vma)); 1934 bfd_set_error (bfd_error_bad_value); 1935 return 0; 1936 } 1937 1938 if (addr_size != 2 && addr_size != 4 && addr_size != 8) 1939 { 1940 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size); 1941 bfd_set_error (bfd_error_bad_value); 1942 return 0; 1943 } 1944 1945 /* Read the abbrevs for this compilation unit into a table. */ 1946 abbrevs = read_abbrevs (abfd, abbrev_offset, stash); 1947 if (! abbrevs) 1948 return 0; 1949 1950 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1951 info_ptr += bytes_read; 1952 if (! abbrev_number) 1953 { 1954 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."), 1955 abbrev_number); 1956 bfd_set_error (bfd_error_bad_value); 1957 return 0; 1958 } 1959 1960 abbrev = lookup_abbrev (abbrev_number, abbrevs); 1961 if (! abbrev) 1962 { 1963 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."), 1964 abbrev_number); 1965 bfd_set_error (bfd_error_bad_value); 1966 return 0; 1967 } 1968 1969 amt = sizeof (struct comp_unit); 1970 unit = bfd_zalloc (abfd, amt); 1971 unit->abfd = abfd; 1972 unit->addr_size = addr_size; 1973 unit->offset_size = offset_size; 1974 unit->abbrevs = abbrevs; 1975 unit->end_ptr = end_ptr; 1976 unit->stash = stash; 1977 unit->info_ptr_unit = info_ptr_unit; 1978 1979 for (i = 0; i < abbrev->num_attrs; ++i) 1980 { 1981 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); 1982 1983 /* Store the data if it is of an attribute we want to keep in a 1984 partial symbol table. */ 1985 switch (attr.name) 1986 { 1987 case DW_AT_stmt_list: 1988 unit->stmtlist = 1; 1989 unit->line_offset = attr.u.val; 1990 break; 1991 1992 case DW_AT_name: 1993 unit->name = attr.u.str; 1994 break; 1995 1996 case DW_AT_low_pc: 1997 low_pc = attr.u.val; 1998 /* If the compilation unit DIE has a DW_AT_low_pc attribute, 1999 this is the base address to use when reading location 2000 lists or range lists. */ 2001 unit->base_address = low_pc; 2002 break; 2003 2004 case DW_AT_high_pc: 2005 high_pc = attr.u.val; 2006 break; 2007 2008 case DW_AT_ranges: 2009 read_rangelist (unit, &unit->arange, attr.u.val); 2010 break; 2011 2012 case DW_AT_comp_dir: 2013 { 2014 char *comp_dir = attr.u.str; 2015 if (comp_dir) 2016 { 2017 /* Irix 6.2 native cc prepends <machine>.: to the compilation 2018 directory, get rid of it. */ 2019 char *cp = strchr (comp_dir, ':'); 2020 2021 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/') 2022 comp_dir = cp + 1; 2023 } 2024 unit->comp_dir = comp_dir; 2025 break; 2026 } 2027 2028 default: 2029 break; 2030 } 2031 } 2032 if (high_pc != 0) 2033 { 2034 arange_add (unit->abfd, &unit->arange, low_pc, high_pc); 2035 } 2036 2037 unit->first_child_die_ptr = info_ptr; 2038 return unit; 2039} 2040 2041/* Return TRUE if UNIT may contain the address given by ADDR. When 2042 there are functions written entirely with inline asm statements, the 2043 range info in the compilation unit header may not be correct. We 2044 need to consult the line info table to see if a compilation unit 2045 really contains the given address. */ 2046 2047static bfd_boolean 2048comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr) 2049{ 2050 struct arange *arange; 2051 2052 if (unit->error) 2053 return FALSE; 2054 2055 arange = &unit->arange; 2056 do 2057 { 2058 if (addr >= arange->low && addr < arange->high) 2059 return TRUE; 2060 arange = arange->next; 2061 } 2062 while (arange); 2063 2064 return FALSE; 2065} 2066 2067/* If UNIT contains ADDR, set the output parameters to the values for 2068 the line containing ADDR. The output parameters, FILENAME_PTR, 2069 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects 2070 to be filled in. 2071 2072 Return TRUE if UNIT contains ADDR, and no errors were encountered; 2073 FALSE otherwise. */ 2074 2075static bfd_boolean 2076comp_unit_find_nearest_line (struct comp_unit *unit, 2077 bfd_vma addr, 2078 const char **filename_ptr, 2079 const char **functionname_ptr, 2080 unsigned int *linenumber_ptr, 2081 struct dwarf2_debug *stash) 2082{ 2083 bfd_boolean line_p; 2084 bfd_boolean func_p; 2085 struct funcinfo *function; 2086 2087 if (unit->error) 2088 return FALSE; 2089 2090 if (! unit->line_table) 2091 { 2092 if (! unit->stmtlist) 2093 { 2094 unit->error = 1; 2095 return FALSE; 2096 } 2097 2098 unit->line_table = decode_line_info (unit, stash); 2099 2100 if (! unit->line_table) 2101 { 2102 unit->error = 1; 2103 return FALSE; 2104 } 2105 2106 if (unit->first_child_die_ptr < unit->end_ptr 2107 && ! scan_unit_for_symbols (unit)) 2108 { 2109 unit->error = 1; 2110 return FALSE; 2111 } 2112 } 2113 2114 function = NULL; 2115 func_p = lookup_address_in_function_table (unit, addr, 2116 &function, functionname_ptr); 2117 if (func_p && (function->tag == DW_TAG_inlined_subroutine)) 2118 stash->inliner_chain = function; 2119 line_p = lookup_address_in_line_info_table (unit->line_table, addr, 2120 function, filename_ptr, 2121 linenumber_ptr); 2122 return line_p || func_p; 2123} 2124 2125/* If UNIT contains SYM at ADDR, set the output parameters to the 2126 values for the line containing SYM. The output parameters, 2127 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be 2128 filled in. 2129 2130 Return TRUE if UNIT contains SYM, and no errors were encountered; 2131 FALSE otherwise. */ 2132 2133static bfd_boolean 2134comp_unit_find_line (struct comp_unit *unit, 2135 asymbol *sym, 2136 bfd_vma addr, 2137 const char **filename_ptr, 2138 unsigned int *linenumber_ptr, 2139 struct dwarf2_debug *stash) 2140{ 2141 if (unit->error) 2142 return FALSE; 2143 2144 if (! unit->line_table) 2145 { 2146 if (! unit->stmtlist) 2147 { 2148 unit->error = 1; 2149 return FALSE; 2150 } 2151 2152 unit->line_table = decode_line_info (unit, stash); 2153 2154 if (! unit->line_table) 2155 { 2156 unit->error = 1; 2157 return FALSE; 2158 } 2159 2160 if (unit->first_child_die_ptr < unit->end_ptr 2161 && ! scan_unit_for_symbols (unit)) 2162 { 2163 unit->error = 1; 2164 return FALSE; 2165 } 2166 } 2167 2168 if (sym->flags & BSF_FUNCTION) 2169 return lookup_symbol_in_function_table (unit, sym, addr, 2170 filename_ptr, 2171 linenumber_ptr); 2172 else 2173 return lookup_symbol_in_variable_table (unit, sym, addr, 2174 filename_ptr, 2175 linenumber_ptr); 2176} 2177 2178/* Locate a section in a BFD containing debugging info. The search starts 2179 from the section after AFTER_SEC, or from the first section in the BFD if 2180 AFTER_SEC is NULL. The search works by examining the names of the 2181 sections. There are two permissiable names. The first is .debug_info. 2182 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi. 2183 This is a variation on the .debug_info section which has a checksum 2184 describing the contents appended onto the name. This allows the linker to 2185 identify and discard duplicate debugging sections for different 2186 compilation units. */ 2187#define DWARF2_DEBUG_INFO ".debug_info" 2188#define GNU_LINKONCE_INFO ".gnu.linkonce.wi." 2189 2190static asection * 2191find_debug_info (bfd *abfd, asection *after_sec) 2192{ 2193 asection * msec; 2194 2195 if (after_sec) 2196 msec = after_sec->next; 2197 else 2198 msec = abfd->sections; 2199 2200 while (msec) 2201 { 2202 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0) 2203 return msec; 2204 2205 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO)) 2206 return msec; 2207 2208 msec = msec->next; 2209 } 2210 2211 return NULL; 2212} 2213 2214/* Unset vmas for loadable sections in STASH. */ 2215 2216static void 2217unset_sections (struct dwarf2_debug *stash) 2218{ 2219 unsigned int i; 2220 struct loadable_section *p; 2221 2222 i = stash->loadable_section_count; 2223 p = stash->loadable_sections; 2224 for (; i > 0; i--, p++) 2225 p->section->vma = 0; 2226} 2227 2228/* Set unique vmas for loadable sections in ABFD and save vmas in 2229 STASH for unset_sections. */ 2230 2231static bfd_boolean 2232place_sections (bfd *abfd, struct dwarf2_debug *stash) 2233{ 2234 struct loadable_section *p; 2235 unsigned int i; 2236 2237 if (stash->loadable_section_count != 0) 2238 { 2239 i = stash->loadable_section_count; 2240 p = stash->loadable_sections; 2241 for (; i > 0; i--, p++) 2242 p->section->vma = p->adj_vma; 2243 } 2244 else 2245 { 2246 asection *sect; 2247 bfd_vma last_vma = 0; 2248 bfd_size_type amt; 2249 struct loadable_section *p; 2250 2251 i = 0; 2252 for (sect = abfd->sections; sect != NULL; sect = sect->next) 2253 { 2254 bfd_size_type sz; 2255 2256 if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0) 2257 continue; 2258 2259 sz = sect->rawsize ? sect->rawsize : sect->size; 2260 if (sz == 0) 2261 continue; 2262 2263 i++; 2264 } 2265 2266 amt = i * sizeof (struct loadable_section); 2267 p = (struct loadable_section *) bfd_zalloc (abfd, amt); 2268 if (! p) 2269 return FALSE; 2270 2271 stash->loadable_sections = p; 2272 stash->loadable_section_count = i; 2273 2274 for (sect = abfd->sections; sect != NULL; sect = sect->next) 2275 { 2276 bfd_size_type sz; 2277 2278 if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0) 2279 continue; 2280 2281 sz = sect->rawsize ? sect->rawsize : sect->size; 2282 if (sz == 0) 2283 continue; 2284 2285 p->section = sect; 2286 if (last_vma != 0) 2287 { 2288 /* Align the new address to the current section 2289 alignment. */ 2290 last_vma = ((last_vma 2291 + ~((bfd_vma) -1 << sect->alignment_power)) 2292 & ((bfd_vma) -1 << sect->alignment_power)); 2293 sect->vma = last_vma; 2294 } 2295 p->adj_vma = sect->vma; 2296 last_vma += sect->vma + sz; 2297 2298 p++; 2299 } 2300 } 2301 2302 return TRUE; 2303} 2304 2305/* The DWARF2 version of find_nearest_line. Return TRUE if the line 2306 is found without error. ADDR_SIZE is the number of bytes in the 2307 initial .debug_info length field and in the abbreviation offset. 2308 You may use zero to indicate that the default value should be 2309 used. */ 2310 2311bfd_boolean 2312_bfd_dwarf2_find_nearest_line (bfd *abfd, 2313 asection *section, 2314 asymbol **symbols, 2315 bfd_vma offset, 2316 const char **filename_ptr, 2317 const char **functionname_ptr, 2318 unsigned int *linenumber_ptr, 2319 unsigned int addr_size, 2320 void **pinfo) 2321{ 2322 /* Read each compilation unit from the section .debug_info, and check 2323 to see if it contains the address we are searching for. If yes, 2324 lookup the address, and return the line number info. If no, go 2325 on to the next compilation unit. 2326 2327 We keep a list of all the previously read compilation units, and 2328 a pointer to the next un-read compilation unit. Check the 2329 previously read units before reading more. */ 2330 struct dwarf2_debug *stash; 2331 2332 /* What address are we looking for? */ 2333 bfd_vma addr; 2334 2335 struct comp_unit* each; 2336 2337 bfd_vma found = FALSE; 2338 2339 stash = *pinfo; 2340 2341 if (! stash) 2342 { 2343 bfd_size_type amt = sizeof (struct dwarf2_debug); 2344 2345 stash = bfd_zalloc (abfd, amt); 2346 if (! stash) 2347 return FALSE; 2348 } 2349 2350 /* In a relocatable file, 2 functions may have the same address. 2351 We change the section vma so that they won't overlap. */ 2352 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 2353 { 2354 if (! place_sections (abfd, stash)) 2355 return FALSE; 2356 } 2357 2358 addr = offset; 2359 if (section->output_section) 2360 addr += section->output_section->vma + section->output_offset; 2361 else 2362 addr += section->vma; 2363 *filename_ptr = NULL; 2364 *functionname_ptr = NULL; 2365 *linenumber_ptr = 0; 2366 2367 /* The DWARF2 spec says that the initial length field, and the 2368 offset of the abbreviation table, should both be 4-byte values. 2369 However, some compilers do things differently. */ 2370 if (addr_size == 0) 2371 addr_size = 4; 2372 BFD_ASSERT (addr_size == 4 || addr_size == 8); 2373 2374 if (! *pinfo) 2375 { 2376 bfd_size_type total_size; 2377 asection *msec; 2378 2379 *pinfo = stash; 2380 2381 msec = find_debug_info (abfd, NULL); 2382 if (! msec) 2383 /* No dwarf2 info. Note that at this point the stash 2384 has been allocated, but contains zeros, this lets 2385 future calls to this function fail quicker. */ 2386 goto done; 2387 2388 /* There can be more than one DWARF2 info section in a BFD these days. 2389 Read them all in and produce one large stash. We do this in two 2390 passes - in the first pass we just accumulate the section sizes. 2391 In the second pass we read in the section's contents. The allows 2392 us to avoid reallocing the data as we add sections to the stash. */ 2393 for (total_size = 0; msec; msec = find_debug_info (abfd, msec)) 2394 total_size += msec->size; 2395 2396 stash->info_ptr = bfd_alloc (abfd, total_size); 2397 if (stash->info_ptr == NULL) 2398 goto done; 2399 2400 stash->info_ptr_end = stash->info_ptr; 2401 2402 for (msec = find_debug_info (abfd, NULL); 2403 msec; 2404 msec = find_debug_info (abfd, msec)) 2405 { 2406 bfd_size_type size; 2407 bfd_size_type start; 2408 2409 size = msec->size; 2410 if (size == 0) 2411 continue; 2412 2413 start = stash->info_ptr_end - stash->info_ptr; 2414 2415 if ((bfd_simple_get_relocated_section_contents 2416 (abfd, msec, stash->info_ptr + start, symbols)) == NULL) 2417 continue; 2418 2419 stash->info_ptr_end = stash->info_ptr + start + size; 2420 } 2421 2422 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size); 2423 2424 stash->sec = find_debug_info (abfd, NULL); 2425 stash->sec_info_ptr = stash->info_ptr; 2426 stash->syms = symbols; 2427 } 2428 2429 /* A null info_ptr indicates that there is no dwarf2 info 2430 (or that an error occured while setting up the stash). */ 2431 if (! stash->info_ptr) 2432 goto done; 2433 2434 stash->inliner_chain = NULL; 2435 2436 /* Check the previously read comp. units first. */ 2437 for (each = stash->all_comp_units; each; each = each->next_unit) 2438 if (comp_unit_contains_address (each, addr) 2439 && comp_unit_find_nearest_line (each, addr, filename_ptr, 2440 functionname_ptr, 2441 linenumber_ptr, stash)) 2442 { 2443 found = TRUE; 2444 goto done; 2445 } 2446 2447 /* Read each remaining comp. units checking each as they are read. */ 2448 while (stash->info_ptr < stash->info_ptr_end) 2449 { 2450 bfd_vma length; 2451 unsigned int offset_size = addr_size; 2452 bfd_byte *info_ptr_unit = stash->info_ptr; 2453 2454 length = read_4_bytes (abfd, stash->info_ptr); 2455 /* A 0xffffff length is the DWARF3 way of indicating we use 2456 64-bit offsets, instead of 32-bit offsets. */ 2457 if (length == 0xffffffff) 2458 { 2459 offset_size = 8; 2460 length = read_8_bytes (abfd, stash->info_ptr + 4); 2461 stash->info_ptr += 12; 2462 } 2463 /* A zero length is the IRIX way of indicating 64-bit offsets, 2464 mostly because the 64-bit length will generally fit in 32 2465 bits, and the endianness helps. */ 2466 else if (length == 0) 2467 { 2468 offset_size = 8; 2469 length = read_4_bytes (abfd, stash->info_ptr + 4); 2470 stash->info_ptr += 8; 2471 } 2472 /* In the absence of the hints above, we assume addr_size-sized 2473 offsets, for backward-compatibility with pre-DWARF3 64-bit 2474 platforms. */ 2475 else if (addr_size == 8) 2476 { 2477 length = read_8_bytes (abfd, stash->info_ptr); 2478 stash->info_ptr += 8; 2479 } 2480 else 2481 stash->info_ptr += 4; 2482 2483 if (length > 0) 2484 { 2485 each = parse_comp_unit (abfd, stash, length, info_ptr_unit, 2486 offset_size); 2487 stash->info_ptr += length; 2488 2489 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr) 2490 == stash->sec->size) 2491 { 2492 stash->sec = find_debug_info (abfd, stash->sec); 2493 stash->sec_info_ptr = stash->info_ptr; 2494 } 2495 2496 if (each) 2497 { 2498 each->next_unit = stash->all_comp_units; 2499 stash->all_comp_units = each; 2500 2501 /* DW_AT_low_pc and DW_AT_high_pc are optional for 2502 compilation units. If we don't have them (i.e., 2503 unit->high == 0), we need to consult the line info 2504 table to see if a compilation unit contains the given 2505 address. */ 2506 if ((each->arange.high == 0 2507 || comp_unit_contains_address (each, addr)) 2508 && comp_unit_find_nearest_line (each, addr, 2509 filename_ptr, 2510 functionname_ptr, 2511 linenumber_ptr, 2512 stash)) 2513 { 2514 found = TRUE; 2515 goto done; 2516 } 2517 } 2518 } 2519 } 2520 2521done: 2522 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 2523 unset_sections (stash); 2524 2525 return found; 2526} 2527 2528/* The DWARF2 version of find_line. Return TRUE if the line is found 2529 without error. */ 2530 2531bfd_boolean 2532_bfd_dwarf2_find_line (bfd *abfd, 2533 asymbol **symbols, 2534 asymbol *symbol, 2535 const char **filename_ptr, 2536 unsigned int *linenumber_ptr, 2537 unsigned int addr_size, 2538 void **pinfo) 2539{ 2540 /* Read each compilation unit from the section .debug_info, and check 2541 to see if it contains the address we are searching for. If yes, 2542 lookup the address, and return the line number info. If no, go 2543 on to the next compilation unit. 2544 2545 We keep a list of all the previously read compilation units, and 2546 a pointer to the next un-read compilation unit. Check the 2547 previously read units before reading more. */ 2548 struct dwarf2_debug *stash; 2549 2550 /* What address are we looking for? */ 2551 bfd_vma addr; 2552 2553 struct comp_unit* each; 2554 2555 asection *section; 2556 2557 bfd_boolean found = FALSE; 2558 2559 section = bfd_get_section (symbol); 2560 2561 stash = *pinfo; 2562 2563 if (! stash) 2564 { 2565 bfd_size_type amt = sizeof (struct dwarf2_debug); 2566 2567 stash = bfd_zalloc (abfd, amt); 2568 if (! stash) 2569 return FALSE; 2570 } 2571 2572 /* In a relocatable file, 2 functions may have the same address. 2573 We change the section vma so that they won't overlap. */ 2574 if (!stash && (abfd->flags & (EXEC_P | DYNAMIC)) == 0) 2575 { 2576 if (! place_sections (abfd, stash)) 2577 return FALSE; 2578 } 2579 2580 addr = symbol->value; 2581 if (section->output_section) 2582 addr += section->output_section->vma + section->output_offset; 2583 else 2584 addr += section->vma; 2585 2586 *filename_ptr = NULL; 2587 *filename_ptr = NULL; 2588 *linenumber_ptr = 0; 2589 2590 if (! *pinfo) 2591 { 2592 bfd_size_type total_size; 2593 asection *msec; 2594 2595 *pinfo = stash; 2596 2597 msec = find_debug_info (abfd, NULL); 2598 if (! msec) 2599 /* No dwarf2 info. Note that at this point the stash 2600 has been allocated, but contains zeros, this lets 2601 future calls to this function fail quicker. */ 2602 goto done; 2603 2604 /* There can be more than one DWARF2 info section in a BFD these days. 2605 Read them all in and produce one large stash. We do this in two 2606 passes - in the first pass we just accumulate the section sizes. 2607 In the second pass we read in the section's contents. The allows 2608 us to avoid reallocing the data as we add sections to the stash. */ 2609 for (total_size = 0; msec; msec = find_debug_info (abfd, msec)) 2610 total_size += msec->size; 2611 2612 stash->info_ptr = bfd_alloc (abfd, total_size); 2613 if (stash->info_ptr == NULL) 2614 goto done; 2615 2616 stash->info_ptr_end = stash->info_ptr; 2617 2618 for (msec = find_debug_info (abfd, NULL); 2619 msec; 2620 msec = find_debug_info (abfd, msec)) 2621 { 2622 bfd_size_type size; 2623 bfd_size_type start; 2624 2625 size = msec->size; 2626 if (size == 0) 2627 continue; 2628 2629 start = stash->info_ptr_end - stash->info_ptr; 2630 2631 if ((bfd_simple_get_relocated_section_contents 2632 (abfd, msec, stash->info_ptr + start, symbols)) == NULL) 2633 continue; 2634 2635 stash->info_ptr_end = stash->info_ptr + start + size; 2636 } 2637 2638 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size); 2639 2640 stash->sec = find_debug_info (abfd, NULL); 2641 stash->sec_info_ptr = stash->info_ptr; 2642 stash->syms = symbols; 2643 } 2644 2645 /* A null info_ptr indicates that there is no dwarf2 info 2646 (or that an error occured while setting up the stash). */ 2647 if (! stash->info_ptr) 2648 goto done; 2649 2650 stash->inliner_chain = NULL; 2651 2652 /* Check the previously read comp. units first. */ 2653 for (each = stash->all_comp_units; each; each = each->next_unit) 2654 if ((symbol->flags & BSF_FUNCTION) == 0 2655 || comp_unit_contains_address (each, addr)) 2656 { 2657 found = comp_unit_find_line (each, symbol, addr, filename_ptr, 2658 linenumber_ptr, stash); 2659 if (found) 2660 goto done; 2661 } 2662 2663 /* The DWARF2 spec says that the initial length field, and the 2664 offset of the abbreviation table, should both be 4-byte values. 2665 However, some compilers do things differently. */ 2666 if (addr_size == 0) 2667 addr_size = 4; 2668 BFD_ASSERT (addr_size == 4 || addr_size == 8); 2669 2670 /* Read each remaining comp. units checking each as they are read. */ 2671 while (stash->info_ptr < stash->info_ptr_end) 2672 { 2673 bfd_vma length; 2674 unsigned int offset_size = addr_size; 2675 bfd_byte *info_ptr_unit = stash->info_ptr; 2676 2677 length = read_4_bytes (abfd, stash->info_ptr); 2678 /* A 0xffffff length is the DWARF3 way of indicating we use 2679 64-bit offsets, instead of 32-bit offsets. */ 2680 if (length == 0xffffffff) 2681 { 2682 offset_size = 8; 2683 length = read_8_bytes (abfd, stash->info_ptr + 4); 2684 stash->info_ptr += 12; 2685 } 2686 /* A zero length is the IRIX way of indicating 64-bit offsets, 2687 mostly because the 64-bit length will generally fit in 32 2688 bits, and the endianness helps. */ 2689 else if (length == 0) 2690 { 2691 offset_size = 8; 2692 length = read_4_bytes (abfd, stash->info_ptr + 4); 2693 stash->info_ptr += 8; 2694 } 2695 /* In the absence of the hints above, we assume addr_size-sized 2696 offsets, for backward-compatibility with pre-DWARF3 64-bit 2697 platforms. */ 2698 else if (addr_size == 8) 2699 { 2700 length = read_8_bytes (abfd, stash->info_ptr); 2701 stash->info_ptr += 8; 2702 } 2703 else 2704 stash->info_ptr += 4; 2705 2706 if (length > 0) 2707 { 2708 each = parse_comp_unit (abfd, stash, length, info_ptr_unit, 2709 offset_size); 2710 stash->info_ptr += length; 2711 2712 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr) 2713 == stash->sec->size) 2714 { 2715 stash->sec = find_debug_info (abfd, stash->sec); 2716 stash->sec_info_ptr = stash->info_ptr; 2717 } 2718 2719 if (each) 2720 { 2721 each->next_unit = stash->all_comp_units; 2722 stash->all_comp_units = each; 2723 2724 /* DW_AT_low_pc and DW_AT_high_pc are optional for 2725 compilation units. If we don't have them (i.e., 2726 unit->high == 0), we need to consult the line info 2727 table to see if a compilation unit contains the given 2728 address. */ 2729 found = (((symbol->flags & BSF_FUNCTION) == 0 2730 || each->arange.high <= 0 2731 || comp_unit_contains_address (each, addr)) 2732 && comp_unit_find_line (each, symbol, addr, 2733 filename_ptr, 2734 linenumber_ptr, 2735 stash)); 2736 if (found) 2737 goto done; 2738 } 2739 } 2740 } 2741 2742done: 2743 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 2744 unset_sections (stash); 2745 2746 return found; 2747} 2748 2749bfd_boolean 2750_bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED, 2751 const char **filename_ptr, 2752 const char **functionname_ptr, 2753 unsigned int *linenumber_ptr, 2754 void **pinfo) 2755{ 2756 struct dwarf2_debug *stash; 2757 2758 stash = *pinfo; 2759 if (stash) 2760 { 2761 struct funcinfo *func = stash->inliner_chain; 2762 if (func && func->caller_func) 2763 { 2764 *filename_ptr = func->caller_file; 2765 *functionname_ptr = func->caller_func->name; 2766 *linenumber_ptr = func->caller_line; 2767 stash->inliner_chain = func->caller_func; 2768 return (TRUE); 2769 } 2770 } 2771 2772 return (FALSE); 2773} 2774 2775void 2776_bfd_dwarf2_cleanup_debug_info (bfd *abfd) 2777{ 2778 struct comp_unit *each; 2779 struct dwarf2_debug *stash; 2780 2781 if (abfd == NULL || elf_tdata (abfd) == NULL) 2782 return; 2783 2784 stash = elf_tdata (abfd)->dwarf2_find_line_info; 2785 2786 if (stash == NULL) 2787 return; 2788 2789 for (each = stash->all_comp_units; each; each = each->next_unit) 2790 { 2791 struct abbrev_info **abbrevs = each->abbrevs; 2792 size_t i; 2793 2794 for (i = 0; i < ABBREV_HASH_SIZE; i++) 2795 { 2796 struct abbrev_info *abbrev = abbrevs[i]; 2797 2798 while (abbrev) 2799 { 2800 free (abbrev->attrs); 2801 abbrev = abbrev->next; 2802 } 2803 } 2804 2805 if (each->line_table) 2806 { 2807 free (each->line_table->dirs); 2808 free (each->line_table->files); 2809 } 2810 } 2811 2812 free (stash->dwarf_abbrev_buffer); 2813 free (stash->dwarf_line_buffer); 2814 free (stash->dwarf_ranges_buffer); 2815} 2816