1 /* DWARF 2 support. 2 Copyright 1994-2013 Free Software Foundation, Inc. 3 4 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions 5 (gavin@cygnus.com). 6 7 From the dwarf2read.c header: 8 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, 9 Inc. with support from Florida State University (under contract 10 with the Ada Joint Program Office), and Silicon Graphics, Inc. 11 Initial contribution by Brent Benson, Harris Computer Systems, Inc., 12 based on Fred Fish's (Cygnus Support) implementation of DWARF 1 13 support in dwarfread.c 14 15 This file is part of BFD. 16 17 This program is free software; you can redistribute it and/or modify 18 it under the terms of the GNU General Public License as published by 19 the Free Software Foundation; either version 3 of the License, or (at 20 your option) any later version. 21 22 This program is distributed in the hope that it will be useful, but 23 WITHOUT ANY WARRANTY; without even the implied warranty of 24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 25 General Public License for more details. 26 27 You should have received a copy of the GNU General Public License 28 along with this program; if not, write to the Free Software 29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 30 MA 02110-1301, USA. */ 31 32 #include "sysdep.h" 33 #include "bfd.h" 34 #include "libiberty.h" 35 #include "libbfd.h" 36 #include "elf-bfd.h" 37 #include "dwarf2.h" 38 39 /* The data in the .debug_line statement prologue looks like this. */ 40 41 struct 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 maximum_ops_per_insn; 48 unsigned char default_is_stmt; 49 int line_base; 50 unsigned char line_range; 51 unsigned char opcode_base; 52 unsigned char *standard_opcode_lengths; 53 }; 54 55 /* Attributes have a name and a value. */ 56 57 struct attribute 58 { 59 enum dwarf_attribute name; 60 enum dwarf_form form; 61 union 62 { 63 char *str; 64 struct dwarf_block *blk; 65 bfd_uint64_t val; 66 bfd_int64_t sval; 67 } 68 u; 69 }; 70 71 /* Blocks are a bunch of untyped bytes. */ 72 struct dwarf_block 73 { 74 unsigned int size; 75 bfd_byte *data; 76 }; 77 78 struct adjusted_section 79 { 80 asection *section; 81 bfd_vma adj_vma; 82 }; 83 84 struct dwarf2_debug 85 { 86 /* A list of all previously read comp_units. */ 87 struct comp_unit *all_comp_units; 88 89 /* Last comp unit in list above. */ 90 struct comp_unit *last_comp_unit; 91 92 /* Names of the debug sections. */ 93 const struct dwarf_debug_section *debug_sections; 94 95 /* The next unread compilation unit within the .debug_info section. 96 Zero indicates that the .debug_info section has not been loaded 97 into a buffer yet. */ 98 bfd_byte *info_ptr; 99 100 /* Pointer to the end of the .debug_info section memory buffer. */ 101 bfd_byte *info_ptr_end; 102 103 /* Pointer to the bfd, section and address of the beginning of the 104 section. The bfd might be different than expected because of 105 gnu_debuglink sections. */ 106 bfd *bfd_ptr; 107 asection *sec; 108 bfd_byte *sec_info_ptr; 109 110 /* Support for alternate debug info sections created by the DWZ utility: 111 This includes a pointer to an alternate bfd which contains *extra*, 112 possibly duplicate debug sections, and pointers to the loaded 113 .debug_str and .debug_info sections from this bfd. */ 114 bfd * alt_bfd_ptr; 115 bfd_byte * alt_dwarf_str_buffer; 116 bfd_size_type alt_dwarf_str_size; 117 bfd_byte * alt_dwarf_info_buffer; 118 bfd_size_type alt_dwarf_info_size; 119 120 /* A pointer to the memory block allocated for info_ptr. Neither 121 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the 122 beginning of the malloc block. This is used only to free the 123 memory later. */ 124 bfd_byte *info_ptr_memory; 125 126 /* Pointer to the symbol table. */ 127 asymbol **syms; 128 129 /* Pointer to the .debug_abbrev section loaded into memory. */ 130 bfd_byte *dwarf_abbrev_buffer; 131 132 /* Length of the loaded .debug_abbrev section. */ 133 bfd_size_type dwarf_abbrev_size; 134 135 /* Buffer for decode_line_info. */ 136 bfd_byte *dwarf_line_buffer; 137 138 /* Length of the loaded .debug_line section. */ 139 bfd_size_type dwarf_line_size; 140 141 /* Pointer to the .debug_str section loaded into memory. */ 142 bfd_byte *dwarf_str_buffer; 143 144 /* Length of the loaded .debug_str section. */ 145 bfd_size_type dwarf_str_size; 146 147 /* Pointer to the .debug_ranges section loaded into memory. */ 148 bfd_byte *dwarf_ranges_buffer; 149 150 /* Length of the loaded .debug_ranges section. */ 151 bfd_size_type dwarf_ranges_size; 152 153 /* If the most recent call to bfd_find_nearest_line was given an 154 address in an inlined function, preserve a pointer into the 155 calling chain for subsequent calls to bfd_find_inliner_info to 156 use. */ 157 struct funcinfo *inliner_chain; 158 159 /* Number of sections whose VMA we must adjust. */ 160 unsigned int adjusted_section_count; 161 162 /* Array of sections with adjusted VMA. */ 163 struct adjusted_section *adjusted_sections; 164 165 /* Number of times find_line is called. This is used in 166 the heuristic for enabling the info hash tables. */ 167 int info_hash_count; 168 169 #define STASH_INFO_HASH_TRIGGER 100 170 171 /* Hash table mapping symbol names to function infos. */ 172 struct info_hash_table *funcinfo_hash_table; 173 174 /* Hash table mapping symbol names to variable infos. */ 175 struct info_hash_table *varinfo_hash_table; 176 177 /* Head of comp_unit list in the last hash table update. */ 178 struct comp_unit *hash_units_head; 179 180 /* Status of info hash. */ 181 int info_hash_status; 182 #define STASH_INFO_HASH_OFF 0 183 #define STASH_INFO_HASH_ON 1 184 #define STASH_INFO_HASH_DISABLED 2 185 186 /* True if we opened bfd_ptr. */ 187 bfd_boolean close_on_cleanup; 188 }; 189 190 struct arange 191 { 192 struct arange *next; 193 bfd_vma low; 194 bfd_vma high; 195 }; 196 197 /* A minimal decoding of DWARF2 compilation units. We only decode 198 what's needed to get to the line number information. */ 199 200 struct comp_unit 201 { 202 /* Chain the previously read compilation units. */ 203 struct comp_unit *next_unit; 204 205 /* Likewise, chain the compilation unit read after this one. 206 The comp units are stored in reversed reading order. */ 207 struct comp_unit *prev_unit; 208 209 /* Keep the bfd convenient (for memory allocation). */ 210 bfd *abfd; 211 212 /* The lowest and highest addresses contained in this compilation 213 unit as specified in the compilation unit header. */ 214 struct arange arange; 215 216 /* The DW_AT_name attribute (for error messages). */ 217 char *name; 218 219 /* The abbrev hash table. */ 220 struct abbrev_info **abbrevs; 221 222 /* Note that an error was found by comp_unit_find_nearest_line. */ 223 int error; 224 225 /* The DW_AT_comp_dir attribute. */ 226 char *comp_dir; 227 228 /* TRUE if there is a line number table associated with this comp. unit. */ 229 int stmtlist; 230 231 /* Pointer to the current comp_unit so that we can find a given entry 232 by its reference. */ 233 bfd_byte *info_ptr_unit; 234 235 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */ 236 bfd_byte *sec_info_ptr; 237 238 /* The offset into .debug_line of the line number table. */ 239 unsigned long line_offset; 240 241 /* Pointer to the first child die for the comp unit. */ 242 bfd_byte *first_child_die_ptr; 243 244 /* The end of the comp unit. */ 245 bfd_byte *end_ptr; 246 247 /* The decoded line number, NULL if not yet decoded. */ 248 struct line_info_table *line_table; 249 250 /* A list of the functions found in this comp. unit. */ 251 struct funcinfo *function_table; 252 253 /* A list of the variables found in this comp. unit. */ 254 struct varinfo *variable_table; 255 256 /* Pointer to dwarf2_debug structure. */ 257 struct dwarf2_debug *stash; 258 259 /* DWARF format version for this unit - from unit header. */ 260 int version; 261 262 /* Address size for this unit - from unit header. */ 263 unsigned char addr_size; 264 265 /* Offset size for this unit - from unit header. */ 266 unsigned char offset_size; 267 268 /* Base address for this unit - from DW_AT_low_pc attribute of 269 DW_TAG_compile_unit DIE */ 270 bfd_vma base_address; 271 272 /* TRUE if symbols are cached in hash table for faster lookup by name. */ 273 bfd_boolean cached; 274 }; 275 276 /* This data structure holds the information of an abbrev. */ 277 struct abbrev_info 278 { 279 unsigned int number; /* Number identifying abbrev. */ 280 enum dwarf_tag tag; /* DWARF tag. */ 281 int has_children; /* Boolean. */ 282 unsigned int num_attrs; /* Number of attributes. */ 283 struct attr_abbrev *attrs; /* An array of attribute descriptions. */ 284 struct abbrev_info *next; /* Next in chain. */ 285 }; 286 287 struct attr_abbrev 288 { 289 enum dwarf_attribute name; 290 enum dwarf_form form; 291 }; 292 293 /* Map of uncompressed DWARF debug section name to compressed one. It 294 is terminated by NULL uncompressed_name. */ 295 296 const struct dwarf_debug_section dwarf_debug_sections[] = 297 { 298 { ".debug_abbrev", ".zdebug_abbrev" }, 299 { ".debug_aranges", ".zdebug_aranges" }, 300 { ".debug_frame", ".zdebug_frame" }, 301 { ".debug_info", ".zdebug_info" }, 302 { ".debug_info", ".zdebug_info" }, 303 { ".debug_line", ".zdebug_line" }, 304 { ".debug_loc", ".zdebug_loc" }, 305 { ".debug_macinfo", ".zdebug_macinfo" }, 306 { ".debug_macro", ".zdebug_macro" }, 307 { ".debug_pubnames", ".zdebug_pubnames" }, 308 { ".debug_pubtypes", ".zdebug_pubtypes" }, 309 { ".debug_ranges", ".zdebug_ranges" }, 310 { ".debug_static_func", ".zdebug_static_func" }, 311 { ".debug_static_vars", ".zdebug_static_vars" }, 312 { ".debug_str", ".zdebug_str", }, 313 { ".debug_str", ".zdebug_str", }, 314 { ".debug_types", ".zdebug_types" }, 315 /* GNU DWARF 1 extensions */ 316 { ".debug_sfnames", ".zdebug_sfnames" }, 317 { ".debug_srcinfo", ".zebug_srcinfo" }, 318 /* SGI/MIPS DWARF 2 extensions */ 319 { ".debug_funcnames", ".zdebug_funcnames" }, 320 { ".debug_typenames", ".zdebug_typenames" }, 321 { ".debug_varnames", ".zdebug_varnames" }, 322 { ".debug_weaknames", ".zdebug_weaknames" }, 323 { NULL, NULL }, 324 }; 325 326 /* NB/ Numbers in this enum must match up with indicies 327 into the dwarf_debug_sections[] array above. */ 328 enum dwarf_debug_section_enum 329 { 330 debug_abbrev = 0, 331 debug_aranges, 332 debug_frame, 333 debug_info, 334 debug_info_alt, 335 debug_line, 336 debug_loc, 337 debug_macinfo, 338 debug_macro, 339 debug_pubnames, 340 debug_pubtypes, 341 debug_ranges, 342 debug_static_func, 343 debug_static_vars, 344 debug_str, 345 debug_str_alt, 346 debug_types, 347 debug_sfnames, 348 debug_srcinfo, 349 debug_funcnames, 350 debug_typenames, 351 debug_varnames, 352 debug_weaknames 353 }; 354 355 #ifndef ABBREV_HASH_SIZE 356 #define ABBREV_HASH_SIZE 121 357 #endif 358 #ifndef ATTR_ALLOC_CHUNK 359 #define ATTR_ALLOC_CHUNK 4 360 #endif 361 362 /* Variable and function hash tables. This is used to speed up look-up 363 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table(). 364 In order to share code between variable and function infos, we use 365 a list of untyped pointer for all variable/function info associated with 366 a symbol. We waste a bit of memory for list with one node but that 367 simplifies the code. */ 368 369 struct info_list_node 370 { 371 struct info_list_node *next; 372 void *info; 373 }; 374 375 /* Info hash entry. */ 376 struct info_hash_entry 377 { 378 struct bfd_hash_entry root; 379 struct info_list_node *head; 380 }; 381 382 struct info_hash_table 383 { 384 struct bfd_hash_table base; 385 }; 386 387 /* Function to create a new entry in info hash table. */ 388 389 static struct bfd_hash_entry * 390 info_hash_table_newfunc (struct bfd_hash_entry *entry, 391 struct bfd_hash_table *table, 392 const char *string) 393 { 394 struct info_hash_entry *ret = (struct info_hash_entry *) entry; 395 396 /* Allocate the structure if it has not already been allocated by a 397 derived class. */ 398 if (ret == NULL) 399 { 400 ret = (struct info_hash_entry *) bfd_hash_allocate (table, 401 sizeof (* ret)); 402 if (ret == NULL) 403 return NULL; 404 } 405 406 /* Call the allocation method of the base class. */ 407 ret = ((struct info_hash_entry *) 408 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 409 410 /* Initialize the local fields here. */ 411 if (ret) 412 ret->head = NULL; 413 414 return (struct bfd_hash_entry *) ret; 415 } 416 417 /* Function to create a new info hash table. It returns a pointer to the 418 newly created table or NULL if there is any error. We need abfd 419 solely for memory allocation. */ 420 421 static struct info_hash_table * 422 create_info_hash_table (bfd *abfd) 423 { 424 struct info_hash_table *hash_table; 425 426 hash_table = ((struct info_hash_table *) 427 bfd_alloc (abfd, sizeof (struct info_hash_table))); 428 if (!hash_table) 429 return hash_table; 430 431 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc, 432 sizeof (struct info_hash_entry))) 433 { 434 bfd_release (abfd, hash_table); 435 return NULL; 436 } 437 438 return hash_table; 439 } 440 441 /* Insert an info entry into an info hash table. We do not check of 442 duplicate entries. Also, the caller need to guarantee that the 443 right type of info in inserted as info is passed as a void* pointer. 444 This function returns true if there is no error. */ 445 446 static bfd_boolean 447 insert_info_hash_table (struct info_hash_table *hash_table, 448 const char *key, 449 void *info, 450 bfd_boolean copy_p) 451 { 452 struct info_hash_entry *entry; 453 struct info_list_node *node; 454 455 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, 456 key, TRUE, copy_p); 457 if (!entry) 458 return FALSE; 459 460 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base, 461 sizeof (*node)); 462 if (!node) 463 return FALSE; 464 465 node->info = info; 466 node->next = entry->head; 467 entry->head = node; 468 469 return TRUE; 470 } 471 472 /* Look up an info entry list from an info hash table. Return NULL 473 if there is none. */ 474 475 static struct info_list_node * 476 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key) 477 { 478 struct info_hash_entry *entry; 479 480 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key, 481 FALSE, FALSE); 482 return entry ? entry->head : NULL; 483 } 484 485 /* Read a section into its appropriate place in the dwarf2_debug 486 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is 487 not NULL, use bfd_simple_get_relocated_section_contents to read the 488 section contents, otherwise use bfd_get_section_contents. Fail if 489 the located section does not contain at least OFFSET bytes. */ 490 491 static bfd_boolean 492 read_section (bfd * abfd, 493 const struct dwarf_debug_section *sec, 494 asymbol ** syms, 495 bfd_uint64_t offset, 496 bfd_byte ** section_buffer, 497 bfd_size_type * section_size) 498 { 499 asection *msec; 500 const char *section_name = sec->uncompressed_name; 501 502 /* The section may have already been read. */ 503 if (*section_buffer == NULL) 504 { 505 msec = bfd_get_section_by_name (abfd, section_name); 506 if (! msec) 507 { 508 section_name = sec->compressed_name; 509 if (section_name != NULL) 510 msec = bfd_get_section_by_name (abfd, section_name); 511 } 512 if (! msec) 513 { 514 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."), 515 sec->uncompressed_name); 516 bfd_set_error (bfd_error_bad_value); 517 return FALSE; 518 } 519 520 *section_size = msec->rawsize ? msec->rawsize : msec->size; 521 if (syms) 522 { 523 *section_buffer 524 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms); 525 if (! *section_buffer) 526 return FALSE; 527 } 528 else 529 { 530 *section_buffer = (bfd_byte *) bfd_malloc (*section_size); 531 if (! *section_buffer) 532 return FALSE; 533 if (! bfd_get_section_contents (abfd, msec, *section_buffer, 534 0, *section_size)) 535 return FALSE; 536 } 537 } 538 539 /* It is possible to get a bad value for the offset into the section 540 that the client wants. Validate it here to avoid trouble later. */ 541 if (offset != 0 && offset >= *section_size) 542 { 543 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)" 544 " greater than or equal to %s size (%lu)."), 545 (long) offset, section_name, *section_size); 546 bfd_set_error (bfd_error_bad_value); 547 return FALSE; 548 } 549 550 return TRUE; 551 } 552 553 /* VERBATIM 554 The following function up to the END VERBATIM mark are 555 copied directly from dwarf2read.c. */ 556 557 /* Read dwarf information from a buffer. */ 558 559 static unsigned int 560 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf) 561 { 562 return bfd_get_8 (abfd, buf); 563 } 564 565 static int 566 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf) 567 { 568 return bfd_get_signed_8 (abfd, buf); 569 } 570 571 static unsigned int 572 read_2_bytes (bfd *abfd, bfd_byte *buf) 573 { 574 return bfd_get_16 (abfd, buf); 575 } 576 577 static unsigned int 578 read_4_bytes (bfd *abfd, bfd_byte *buf) 579 { 580 return bfd_get_32 (abfd, buf); 581 } 582 583 static bfd_uint64_t 584 read_8_bytes (bfd *abfd, bfd_byte *buf) 585 { 586 return bfd_get_64 (abfd, buf); 587 } 588 589 static bfd_byte * 590 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED, 591 bfd_byte *buf, 592 unsigned int size ATTRIBUTE_UNUSED) 593 { 594 return buf; 595 } 596 597 static char * 598 read_string (bfd *abfd ATTRIBUTE_UNUSED, 599 bfd_byte *buf, 600 unsigned int *bytes_read_ptr) 601 { 602 /* Return a pointer to the embedded string. */ 603 char *str = (char *) buf; 604 605 if (*str == '\0') 606 { 607 *bytes_read_ptr = 1; 608 return NULL; 609 } 610 611 *bytes_read_ptr = strlen (str) + 1; 612 return str; 613 } 614 615 /* END VERBATIM */ 616 617 static char * 618 read_indirect_string (struct comp_unit * unit, 619 bfd_byte * buf, 620 unsigned int * bytes_read_ptr) 621 { 622 bfd_uint64_t offset; 623 struct dwarf2_debug *stash = unit->stash; 624 char *str; 625 626 if (unit->offset_size == 4) 627 offset = read_4_bytes (unit->abfd, buf); 628 else 629 offset = read_8_bytes (unit->abfd, buf); 630 631 *bytes_read_ptr = unit->offset_size; 632 633 if (! read_section (unit->abfd, &stash->debug_sections[debug_str], 634 stash->syms, offset, 635 &stash->dwarf_str_buffer, &stash->dwarf_str_size)) 636 return NULL; 637 638 str = (char *) stash->dwarf_str_buffer + offset; 639 if (*str == '\0') 640 return NULL; 641 return str; 642 } 643 644 /* Like read_indirect_string but uses a .debug_str located in 645 an alternate filepointed to by the .gnu_debuglink section. 646 Used to impement DW_FORM_GNU_strp_alt. */ 647 648 static char * 649 read_alt_indirect_string (struct comp_unit * unit, 650 bfd_byte * buf, 651 unsigned int * bytes_read_ptr) 652 { 653 bfd_uint64_t offset; 654 struct dwarf2_debug *stash = unit->stash; 655 char *str; 656 657 if (unit->offset_size == 4) 658 offset = read_4_bytes (unit->abfd, buf); 659 else 660 offset = read_8_bytes (unit->abfd, buf); 661 662 *bytes_read_ptr = unit->offset_size; 663 664 if (stash->alt_bfd_ptr == NULL) 665 { 666 bfd * debug_bfd; 667 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR); 668 669 if (debug_filename == NULL) 670 return NULL; 671 672 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL 673 || ! bfd_check_format (debug_bfd, bfd_object)) 674 { 675 if (debug_bfd) 676 bfd_close (debug_bfd); 677 678 /* FIXME: Should we report our failure to follow the debuglink ? */ 679 free (debug_filename); 680 return NULL; 681 } 682 stash->alt_bfd_ptr = debug_bfd; 683 } 684 685 if (! read_section (unit->stash->alt_bfd_ptr, 686 stash->debug_sections + debug_str_alt, 687 NULL, /* FIXME: Do we need to load alternate symbols ? */ 688 offset, 689 &stash->alt_dwarf_str_buffer, 690 &stash->alt_dwarf_str_size)) 691 return NULL; 692 693 str = (char *) stash->alt_dwarf_str_buffer + offset; 694 if (*str == '\0') 695 return NULL; 696 697 return str; 698 } 699 700 /* Resolve an alternate reference from UNIT at OFFSET. 701 Returns a pointer into the loaded alternate CU upon success 702 or NULL upon failure. */ 703 704 static bfd_byte * 705 read_alt_indirect_ref (struct comp_unit * unit, 706 bfd_uint64_t offset) 707 { 708 struct dwarf2_debug *stash = unit->stash; 709 710 if (stash->alt_bfd_ptr == NULL) 711 { 712 bfd * debug_bfd; 713 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR); 714 715 if (debug_filename == NULL) 716 return FALSE; 717 718 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL 719 || ! bfd_check_format (debug_bfd, bfd_object)) 720 { 721 if (debug_bfd) 722 bfd_close (debug_bfd); 723 724 /* FIXME: Should we report our failure to follow the debuglink ? */ 725 free (debug_filename); 726 return NULL; 727 } 728 stash->alt_bfd_ptr = debug_bfd; 729 } 730 731 if (! read_section (unit->stash->alt_bfd_ptr, 732 stash->debug_sections + debug_info_alt, 733 NULL, /* FIXME: Do we need to load alternate symbols ? */ 734 offset, 735 &stash->alt_dwarf_info_buffer, 736 &stash->alt_dwarf_info_size)) 737 return NULL; 738 739 return stash->alt_dwarf_info_buffer + offset; 740 } 741 742 static bfd_uint64_t 743 read_address (struct comp_unit *unit, bfd_byte *buf) 744 { 745 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma; 746 747 if (signed_vma) 748 { 749 switch (unit->addr_size) 750 { 751 case 8: 752 return bfd_get_signed_64 (unit->abfd, buf); 753 case 4: 754 return bfd_get_signed_32 (unit->abfd, buf); 755 case 2: 756 return bfd_get_signed_16 (unit->abfd, buf); 757 default: 758 abort (); 759 } 760 } 761 else 762 { 763 switch (unit->addr_size) 764 { 765 case 8: 766 return bfd_get_64 (unit->abfd, buf); 767 case 4: 768 return bfd_get_32 (unit->abfd, buf); 769 case 2: 770 return bfd_get_16 (unit->abfd, buf); 771 default: 772 abort (); 773 } 774 } 775 } 776 777 /* Lookup an abbrev_info structure in the abbrev hash table. */ 778 779 static struct abbrev_info * 780 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs) 781 { 782 unsigned int hash_number; 783 struct abbrev_info *abbrev; 784 785 hash_number = number % ABBREV_HASH_SIZE; 786 abbrev = abbrevs[hash_number]; 787 788 while (abbrev) 789 { 790 if (abbrev->number == number) 791 return abbrev; 792 else 793 abbrev = abbrev->next; 794 } 795 796 return NULL; 797 } 798 799 /* In DWARF version 2, the description of the debugging information is 800 stored in a separate .debug_abbrev section. Before we read any 801 dies from a section we read in all abbreviations and install them 802 in a hash table. */ 803 804 static struct abbrev_info** 805 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash) 806 { 807 struct abbrev_info **abbrevs; 808 bfd_byte *abbrev_ptr; 809 struct abbrev_info *cur_abbrev; 810 unsigned int abbrev_number, bytes_read, abbrev_name; 811 unsigned int abbrev_form, hash_number; 812 bfd_size_type amt; 813 814 if (! read_section (abfd, &stash->debug_sections[debug_abbrev], 815 stash->syms, offset, 816 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size)) 817 return NULL; 818 819 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE; 820 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt); 821 if (abbrevs == NULL) 822 return NULL; 823 824 abbrev_ptr = stash->dwarf_abbrev_buffer + offset; 825 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 826 abbrev_ptr += bytes_read; 827 828 /* Loop until we reach an abbrev number of 0. */ 829 while (abbrev_number) 830 { 831 amt = sizeof (struct abbrev_info); 832 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt); 833 if (cur_abbrev == NULL) 834 return NULL; 835 836 /* Read in abbrev header. */ 837 cur_abbrev->number = abbrev_number; 838 cur_abbrev->tag = (enum dwarf_tag) 839 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 840 abbrev_ptr += bytes_read; 841 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr); 842 abbrev_ptr += 1; 843 844 /* Now read in declarations. */ 845 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 846 abbrev_ptr += bytes_read; 847 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 848 abbrev_ptr += bytes_read; 849 850 while (abbrev_name) 851 { 852 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0) 853 { 854 struct attr_abbrev *tmp; 855 856 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK; 857 amt *= sizeof (struct attr_abbrev); 858 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt); 859 if (tmp == NULL) 860 { 861 size_t i; 862 863 for (i = 0; i < ABBREV_HASH_SIZE; i++) 864 { 865 struct abbrev_info *abbrev = abbrevs[i]; 866 867 while (abbrev) 868 { 869 free (abbrev->attrs); 870 abbrev = abbrev->next; 871 } 872 } 873 return NULL; 874 } 875 cur_abbrev->attrs = tmp; 876 } 877 878 cur_abbrev->attrs[cur_abbrev->num_attrs].name 879 = (enum dwarf_attribute) abbrev_name; 880 cur_abbrev->attrs[cur_abbrev->num_attrs++].form 881 = (enum dwarf_form) abbrev_form; 882 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 883 abbrev_ptr += bytes_read; 884 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 885 abbrev_ptr += bytes_read; 886 } 887 888 hash_number = abbrev_number % ABBREV_HASH_SIZE; 889 cur_abbrev->next = abbrevs[hash_number]; 890 abbrevs[hash_number] = cur_abbrev; 891 892 /* Get next abbreviation. 893 Under Irix6 the abbreviations for a compilation unit are not 894 always properly terminated with an abbrev number of 0. 895 Exit loop if we encounter an abbreviation which we have 896 already read (which means we are about to read the abbreviations 897 for the next compile unit) or if the end of the abbreviation 898 table is reached. */ 899 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer) 900 >= stash->dwarf_abbrev_size) 901 break; 902 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 903 abbrev_ptr += bytes_read; 904 if (lookup_abbrev (abbrev_number,abbrevs) != NULL) 905 break; 906 } 907 908 return abbrevs; 909 } 910 911 /* Read an attribute value described by an attribute form. */ 912 913 static bfd_byte * 914 read_attribute_value (struct attribute *attr, 915 unsigned form, 916 struct comp_unit *unit, 917 bfd_byte *info_ptr) 918 { 919 bfd *abfd = unit->abfd; 920 unsigned int bytes_read; 921 struct dwarf_block *blk; 922 bfd_size_type amt; 923 924 attr->form = (enum dwarf_form) form; 925 926 switch (form) 927 { 928 case DW_FORM_ref_addr: 929 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in 930 DWARF3. */ 931 if (unit->version == 3 || unit->version == 4) 932 { 933 if (unit->offset_size == 4) 934 attr->u.val = read_4_bytes (unit->abfd, info_ptr); 935 else 936 attr->u.val = read_8_bytes (unit->abfd, info_ptr); 937 info_ptr += unit->offset_size; 938 break; 939 } 940 /* FALLTHROUGH */ 941 case DW_FORM_addr: 942 attr->u.val = read_address (unit, info_ptr); 943 info_ptr += unit->addr_size; 944 break; 945 case DW_FORM_GNU_ref_alt: 946 case DW_FORM_sec_offset: 947 if (unit->offset_size == 4) 948 attr->u.val = read_4_bytes (unit->abfd, info_ptr); 949 else 950 attr->u.val = read_8_bytes (unit->abfd, info_ptr); 951 info_ptr += unit->offset_size; 952 break; 953 case DW_FORM_block2: 954 amt = sizeof (struct dwarf_block); 955 blk = (struct dwarf_block *) bfd_alloc (abfd, amt); 956 if (blk == NULL) 957 return NULL; 958 blk->size = read_2_bytes (abfd, info_ptr); 959 info_ptr += 2; 960 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 961 info_ptr += blk->size; 962 attr->u.blk = blk; 963 break; 964 case DW_FORM_block4: 965 amt = sizeof (struct dwarf_block); 966 blk = (struct dwarf_block *) bfd_alloc (abfd, amt); 967 if (blk == NULL) 968 return NULL; 969 blk->size = read_4_bytes (abfd, info_ptr); 970 info_ptr += 4; 971 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 972 info_ptr += blk->size; 973 attr->u.blk = blk; 974 break; 975 case DW_FORM_data2: 976 attr->u.val = read_2_bytes (abfd, info_ptr); 977 info_ptr += 2; 978 break; 979 case DW_FORM_data4: 980 attr->u.val = read_4_bytes (abfd, info_ptr); 981 info_ptr += 4; 982 break; 983 case DW_FORM_data8: 984 attr->u.val = read_8_bytes (abfd, info_ptr); 985 info_ptr += 8; 986 break; 987 case DW_FORM_string: 988 attr->u.str = read_string (abfd, info_ptr, &bytes_read); 989 info_ptr += bytes_read; 990 break; 991 case DW_FORM_strp: 992 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read); 993 info_ptr += bytes_read; 994 break; 995 case DW_FORM_GNU_strp_alt: 996 attr->u.str = read_alt_indirect_string (unit, info_ptr, &bytes_read); 997 info_ptr += bytes_read; 998 break; 999 case DW_FORM_exprloc: 1000 case DW_FORM_block: 1001 amt = sizeof (struct dwarf_block); 1002 blk = (struct dwarf_block *) bfd_alloc (abfd, amt); 1003 if (blk == NULL) 1004 return NULL; 1005 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1006 info_ptr += bytes_read; 1007 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 1008 info_ptr += blk->size; 1009 attr->u.blk = blk; 1010 break; 1011 case DW_FORM_block1: 1012 amt = sizeof (struct dwarf_block); 1013 blk = (struct dwarf_block *) bfd_alloc (abfd, amt); 1014 if (blk == NULL) 1015 return NULL; 1016 blk->size = read_1_byte (abfd, info_ptr); 1017 info_ptr += 1; 1018 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 1019 info_ptr += blk->size; 1020 attr->u.blk = blk; 1021 break; 1022 case DW_FORM_data1: 1023 attr->u.val = read_1_byte (abfd, info_ptr); 1024 info_ptr += 1; 1025 break; 1026 case DW_FORM_flag: 1027 attr->u.val = read_1_byte (abfd, info_ptr); 1028 info_ptr += 1; 1029 break; 1030 case DW_FORM_flag_present: 1031 attr->u.val = 1; 1032 break; 1033 case DW_FORM_sdata: 1034 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read); 1035 info_ptr += bytes_read; 1036 break; 1037 case DW_FORM_udata: 1038 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1039 info_ptr += bytes_read; 1040 break; 1041 case DW_FORM_ref1: 1042 attr->u.val = read_1_byte (abfd, info_ptr); 1043 info_ptr += 1; 1044 break; 1045 case DW_FORM_ref2: 1046 attr->u.val = read_2_bytes (abfd, info_ptr); 1047 info_ptr += 2; 1048 break; 1049 case DW_FORM_ref4: 1050 attr->u.val = read_4_bytes (abfd, info_ptr); 1051 info_ptr += 4; 1052 break; 1053 case DW_FORM_ref8: 1054 attr->u.val = read_8_bytes (abfd, info_ptr); 1055 info_ptr += 8; 1056 break; 1057 case DW_FORM_ref_sig8: 1058 attr->u.val = read_8_bytes (abfd, info_ptr); 1059 info_ptr += 8; 1060 break; 1061 case DW_FORM_ref_udata: 1062 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1063 info_ptr += bytes_read; 1064 break; 1065 case DW_FORM_indirect: 1066 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 1067 info_ptr += bytes_read; 1068 info_ptr = read_attribute_value (attr, form, unit, info_ptr); 1069 break; 1070 default: 1071 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."), 1072 form); 1073 bfd_set_error (bfd_error_bad_value); 1074 return NULL; 1075 } 1076 return info_ptr; 1077 } 1078 1079 /* Read an attribute described by an abbreviated attribute. */ 1080 1081 static bfd_byte * 1082 read_attribute (struct attribute *attr, 1083 struct attr_abbrev *abbrev, 1084 struct comp_unit *unit, 1085 bfd_byte *info_ptr) 1086 { 1087 attr->name = abbrev->name; 1088 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr); 1089 return info_ptr; 1090 } 1091 1092 /* Source line information table routines. */ 1093 1094 #define FILE_ALLOC_CHUNK 5 1095 #define DIR_ALLOC_CHUNK 5 1096 1097 struct line_info 1098 { 1099 struct line_info* prev_line; 1100 bfd_vma address; 1101 char *filename; 1102 unsigned int line; 1103 unsigned int column; 1104 unsigned int discriminator; 1105 unsigned char op_index; 1106 unsigned char end_sequence; /* End of (sequential) code sequence. */ 1107 }; 1108 1109 struct fileinfo 1110 { 1111 char *name; 1112 unsigned int dir; 1113 unsigned int time; 1114 unsigned int size; 1115 }; 1116 1117 struct line_sequence 1118 { 1119 bfd_vma low_pc; 1120 struct line_sequence* prev_sequence; 1121 struct line_info* last_line; /* Largest VMA. */ 1122 }; 1123 1124 struct line_info_table 1125 { 1126 bfd* abfd; 1127 unsigned int num_files; 1128 unsigned int num_dirs; 1129 unsigned int num_sequences; 1130 char * comp_dir; 1131 char ** dirs; 1132 struct fileinfo* files; 1133 struct line_sequence* sequences; 1134 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */ 1135 }; 1136 1137 /* Remember some information about each function. If the function is 1138 inlined (DW_TAG_inlined_subroutine) it may have two additional 1139 attributes, DW_AT_call_file and DW_AT_call_line, which specify the 1140 source code location where this function was inlined. */ 1141 1142 struct funcinfo 1143 { 1144 /* Pointer to previous function in list of all functions. */ 1145 struct funcinfo *prev_func; 1146 /* Pointer to function one scope higher. */ 1147 struct funcinfo *caller_func; 1148 /* Source location file name where caller_func inlines this func. */ 1149 char *caller_file; 1150 /* Source location line number where caller_func inlines this func. */ 1151 int caller_line; 1152 /* Source location file name. */ 1153 char *file; 1154 /* Source location line number. */ 1155 int line; 1156 int tag; 1157 char *name; 1158 struct arange arange; 1159 /* Where the symbol is defined. */ 1160 asection *sec; 1161 }; 1162 1163 struct varinfo 1164 { 1165 /* Pointer to previous variable in list of all variables */ 1166 struct varinfo *prev_var; 1167 /* Source location file name */ 1168 char *file; 1169 /* Source location line number */ 1170 int line; 1171 int tag; 1172 char *name; 1173 bfd_vma addr; 1174 /* Where the symbol is defined */ 1175 asection *sec; 1176 /* Is this a stack variable? */ 1177 unsigned int stack: 1; 1178 }; 1179 1180 /* Return TRUE if NEW_LINE should sort after LINE. */ 1181 1182 static inline bfd_boolean 1183 new_line_sorts_after (struct line_info *new_line, struct line_info *line) 1184 { 1185 return (new_line->address > line->address 1186 || (new_line->address == line->address 1187 && (new_line->op_index > line->op_index 1188 || (new_line->op_index == line->op_index 1189 && new_line->end_sequence < line->end_sequence)))); 1190 } 1191 1192 1193 /* Adds a new entry to the line_info list in the line_info_table, ensuring 1194 that the list is sorted. Note that the line_info list is sorted from 1195 highest to lowest VMA (with possible duplicates); that is, 1196 line_info->prev_line always accesses an equal or smaller VMA. */ 1197 1198 static bfd_boolean 1199 add_line_info (struct line_info_table *table, 1200 bfd_vma address, 1201 unsigned char op_index, 1202 char *filename, 1203 unsigned int line, 1204 unsigned int column, 1205 unsigned int discriminator, 1206 int end_sequence) 1207 { 1208 bfd_size_type amt = sizeof (struct line_info); 1209 struct line_sequence* seq = table->sequences; 1210 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt); 1211 1212 if (info == NULL) 1213 return FALSE; 1214 1215 /* Set member data of 'info'. */ 1216 info->prev_line = NULL; 1217 info->address = address; 1218 info->op_index = op_index; 1219 info->line = line; 1220 info->column = column; 1221 info->discriminator = discriminator; 1222 info->end_sequence = end_sequence; 1223 1224 if (filename && filename[0]) 1225 { 1226 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1); 1227 if (info->filename == NULL) 1228 return FALSE; 1229 strcpy (info->filename, filename); 1230 } 1231 else 1232 info->filename = NULL; 1233 1234 /* Find the correct location for 'info'. Normally we will receive 1235 new line_info data 1) in order and 2) with increasing VMAs. 1236 However some compilers break the rules (cf. decode_line_info) and 1237 so we include some heuristics for quickly finding the correct 1238 location for 'info'. In particular, these heuristics optimize for 1239 the common case in which the VMA sequence that we receive is a 1240 list of locally sorted VMAs such as 1241 p...z a...j (where a < j < p < z) 1242 1243 Note: table->lcl_head is used to head an *actual* or *possible* 1244 sub-sequence within the list (such as a...j) that is not directly 1245 headed by table->last_line 1246 1247 Note: we may receive duplicate entries from 'decode_line_info'. */ 1248 1249 if (seq 1250 && seq->last_line->address == address 1251 && seq->last_line->op_index == op_index 1252 && seq->last_line->end_sequence == end_sequence) 1253 { 1254 /* We only keep the last entry with the same address and end 1255 sequence. See PR ld/4986. */ 1256 if (table->lcl_head == seq->last_line) 1257 table->lcl_head = info; 1258 info->prev_line = seq->last_line->prev_line; 1259 seq->last_line = info; 1260 } 1261 else if (!seq || seq->last_line->end_sequence) 1262 { 1263 /* Start a new line sequence. */ 1264 amt = sizeof (struct line_sequence); 1265 seq = (struct line_sequence *) bfd_malloc (amt); 1266 if (seq == NULL) 1267 return FALSE; 1268 seq->low_pc = address; 1269 seq->prev_sequence = table->sequences; 1270 seq->last_line = info; 1271 table->lcl_head = info; 1272 table->sequences = seq; 1273 table->num_sequences++; 1274 } 1275 else if (new_line_sorts_after (info, seq->last_line)) 1276 { 1277 /* Normal case: add 'info' to the beginning of the current sequence. */ 1278 info->prev_line = seq->last_line; 1279 seq->last_line = info; 1280 1281 /* lcl_head: initialize to head a *possible* sequence at the end. */ 1282 if (!table->lcl_head) 1283 table->lcl_head = info; 1284 } 1285 else if (!new_line_sorts_after (info, table->lcl_head) 1286 && (!table->lcl_head->prev_line 1287 || new_line_sorts_after (info, table->lcl_head->prev_line))) 1288 { 1289 /* Abnormal but easy: lcl_head is the head of 'info'. */ 1290 info->prev_line = table->lcl_head->prev_line; 1291 table->lcl_head->prev_line = info; 1292 } 1293 else 1294 { 1295 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' 1296 are valid heads for 'info'. Reset 'lcl_head'. */ 1297 struct line_info* li2 = seq->last_line; /* Always non-NULL. */ 1298 struct line_info* li1 = li2->prev_line; 1299 1300 while (li1) 1301 { 1302 if (!new_line_sorts_after (info, li2) 1303 && new_line_sorts_after (info, li1)) 1304 break; 1305 1306 li2 = li1; /* always non-NULL */ 1307 li1 = li1->prev_line; 1308 } 1309 table->lcl_head = li2; 1310 info->prev_line = table->lcl_head->prev_line; 1311 table->lcl_head->prev_line = info; 1312 if (address < seq->low_pc) 1313 seq->low_pc = address; 1314 } 1315 return TRUE; 1316 } 1317 1318 /* Extract a fully qualified filename from a line info table. 1319 The returned string has been malloc'ed and it is the caller's 1320 responsibility to free it. */ 1321 1322 static char * 1323 concat_filename (struct line_info_table *table, unsigned int file) 1324 { 1325 char *filename; 1326 1327 if (file - 1 >= table->num_files) 1328 { 1329 /* FILE == 0 means unknown. */ 1330 if (file) 1331 (*_bfd_error_handler) 1332 (_("Dwarf Error: mangled line number section (bad file number).")); 1333 return strdup ("<unknown>"); 1334 } 1335 1336 filename = table->files[file - 1].name; 1337 1338 if (!IS_ABSOLUTE_PATH (filename)) 1339 { 1340 char *dir_name = NULL; 1341 char *subdir_name = NULL; 1342 char *name; 1343 size_t len; 1344 1345 if (table->files[file - 1].dir) 1346 subdir_name = table->dirs[table->files[file - 1].dir - 1]; 1347 1348 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name)) 1349 dir_name = table->comp_dir; 1350 1351 if (!dir_name) 1352 { 1353 dir_name = subdir_name; 1354 subdir_name = NULL; 1355 } 1356 1357 if (!dir_name) 1358 return strdup (filename); 1359 1360 len = strlen (dir_name) + strlen (filename) + 2; 1361 1362 if (subdir_name) 1363 { 1364 len += strlen (subdir_name) + 1; 1365 name = (char *) bfd_malloc (len); 1366 if (name) 1367 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename); 1368 } 1369 else 1370 { 1371 name = (char *) bfd_malloc (len); 1372 if (name) 1373 sprintf (name, "%s/%s", dir_name, filename); 1374 } 1375 1376 return name; 1377 } 1378 1379 return strdup (filename); 1380 } 1381 1382 static bfd_boolean 1383 arange_add (const struct comp_unit *unit, struct arange *first_arange, 1384 bfd_vma low_pc, bfd_vma high_pc) 1385 { 1386 struct arange *arange; 1387 1388 /* Ignore empty ranges. */ 1389 if (low_pc == high_pc) 1390 return TRUE; 1391 1392 /* If the first arange is empty, use it. */ 1393 if (first_arange->high == 0) 1394 { 1395 first_arange->low = low_pc; 1396 first_arange->high = high_pc; 1397 return TRUE; 1398 } 1399 1400 /* Next see if we can cheaply extend an existing range. */ 1401 arange = first_arange; 1402 do 1403 { 1404 if (low_pc == arange->high) 1405 { 1406 arange->high = high_pc; 1407 return TRUE; 1408 } 1409 if (high_pc == arange->low) 1410 { 1411 arange->low = low_pc; 1412 return TRUE; 1413 } 1414 arange = arange->next; 1415 } 1416 while (arange); 1417 1418 /* Need to allocate a new arange and insert it into the arange list. 1419 Order isn't significant, so just insert after the first arange. */ 1420 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange)); 1421 if (arange == NULL) 1422 return FALSE; 1423 arange->low = low_pc; 1424 arange->high = high_pc; 1425 arange->next = first_arange->next; 1426 first_arange->next = arange; 1427 return TRUE; 1428 } 1429 1430 /* Compare function for line sequences. */ 1431 1432 static int 1433 compare_sequences (const void* a, const void* b) 1434 { 1435 const struct line_sequence* seq1 = a; 1436 const struct line_sequence* seq2 = b; 1437 1438 /* Sort by low_pc as the primary key. */ 1439 if (seq1->low_pc < seq2->low_pc) 1440 return -1; 1441 if (seq1->low_pc > seq2->low_pc) 1442 return 1; 1443 1444 /* If low_pc values are equal, sort in reverse order of 1445 high_pc, so that the largest region comes first. */ 1446 if (seq1->last_line->address < seq2->last_line->address) 1447 return 1; 1448 if (seq1->last_line->address > seq2->last_line->address) 1449 return -1; 1450 1451 if (seq1->last_line->op_index < seq2->last_line->op_index) 1452 return 1; 1453 if (seq1->last_line->op_index > seq2->last_line->op_index) 1454 return -1; 1455 1456 return 0; 1457 } 1458 1459 /* Sort the line sequences for quick lookup. */ 1460 1461 static bfd_boolean 1462 sort_line_sequences (struct line_info_table* table) 1463 { 1464 bfd_size_type amt; 1465 struct line_sequence* sequences; 1466 struct line_sequence* seq; 1467 unsigned int n = 0; 1468 unsigned int num_sequences = table->num_sequences; 1469 bfd_vma last_high_pc; 1470 1471 if (num_sequences == 0) 1472 return TRUE; 1473 1474 /* Allocate space for an array of sequences. */ 1475 amt = sizeof (struct line_sequence) * num_sequences; 1476 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt); 1477 if (sequences == NULL) 1478 return FALSE; 1479 1480 /* Copy the linked list into the array, freeing the original nodes. */ 1481 seq = table->sequences; 1482 for (n = 0; n < num_sequences; n++) 1483 { 1484 struct line_sequence* last_seq = seq; 1485 1486 BFD_ASSERT (seq); 1487 sequences[n].low_pc = seq->low_pc; 1488 sequences[n].prev_sequence = NULL; 1489 sequences[n].last_line = seq->last_line; 1490 seq = seq->prev_sequence; 1491 free (last_seq); 1492 } 1493 BFD_ASSERT (seq == NULL); 1494 1495 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences); 1496 1497 /* Make the list binary-searchable by trimming overlapping entries 1498 and removing nested entries. */ 1499 num_sequences = 1; 1500 last_high_pc = sequences[0].last_line->address; 1501 for (n = 1; n < table->num_sequences; n++) 1502 { 1503 if (sequences[n].low_pc < last_high_pc) 1504 { 1505 if (sequences[n].last_line->address <= last_high_pc) 1506 /* Skip nested entries. */ 1507 continue; 1508 1509 /* Trim overlapping entries. */ 1510 sequences[n].low_pc = last_high_pc; 1511 } 1512 last_high_pc = sequences[n].last_line->address; 1513 if (n > num_sequences) 1514 { 1515 /* Close up the gap. */ 1516 sequences[num_sequences].low_pc = sequences[n].low_pc; 1517 sequences[num_sequences].last_line = sequences[n].last_line; 1518 } 1519 num_sequences++; 1520 } 1521 1522 table->sequences = sequences; 1523 table->num_sequences = num_sequences; 1524 return TRUE; 1525 } 1526 1527 /* Decode the line number information for UNIT. */ 1528 1529 static struct line_info_table* 1530 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) 1531 { 1532 bfd *abfd = unit->abfd; 1533 struct line_info_table* table; 1534 bfd_byte *line_ptr; 1535 bfd_byte *line_end; 1536 struct line_head lh; 1537 unsigned int i, bytes_read, offset_size; 1538 char *cur_file, *cur_dir; 1539 unsigned char op_code, extended_op, adj_opcode; 1540 unsigned int exop_len; 1541 bfd_size_type amt; 1542 1543 if (! read_section (abfd, &stash->debug_sections[debug_line], 1544 stash->syms, unit->line_offset, 1545 &stash->dwarf_line_buffer, &stash->dwarf_line_size)) 1546 return NULL; 1547 1548 amt = sizeof (struct line_info_table); 1549 table = (struct line_info_table *) bfd_alloc (abfd, amt); 1550 if (table == NULL) 1551 return NULL; 1552 table->abfd = abfd; 1553 table->comp_dir = unit->comp_dir; 1554 1555 table->num_files = 0; 1556 table->files = NULL; 1557 1558 table->num_dirs = 0; 1559 table->dirs = NULL; 1560 1561 table->num_sequences = 0; 1562 table->sequences = NULL; 1563 1564 table->lcl_head = NULL; 1565 1566 line_ptr = stash->dwarf_line_buffer + unit->line_offset; 1567 1568 /* Read in the prologue. */ 1569 lh.total_length = read_4_bytes (abfd, line_ptr); 1570 line_ptr += 4; 1571 offset_size = 4; 1572 if (lh.total_length == 0xffffffff) 1573 { 1574 lh.total_length = read_8_bytes (abfd, line_ptr); 1575 line_ptr += 8; 1576 offset_size = 8; 1577 } 1578 else if (lh.total_length == 0 && unit->addr_size == 8) 1579 { 1580 /* Handle (non-standard) 64-bit DWARF2 formats. */ 1581 lh.total_length = read_4_bytes (abfd, line_ptr); 1582 line_ptr += 4; 1583 offset_size = 8; 1584 } 1585 line_end = line_ptr + lh.total_length; 1586 lh.version = read_2_bytes (abfd, line_ptr); 1587 if (lh.version < 2 || lh.version > 4) 1588 { 1589 (*_bfd_error_handler) 1590 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version); 1591 bfd_set_error (bfd_error_bad_value); 1592 return NULL; 1593 } 1594 line_ptr += 2; 1595 if (offset_size == 4) 1596 lh.prologue_length = read_4_bytes (abfd, line_ptr); 1597 else 1598 lh.prologue_length = read_8_bytes (abfd, line_ptr); 1599 line_ptr += offset_size; 1600 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr); 1601 line_ptr += 1; 1602 if (lh.version >= 4) 1603 { 1604 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr); 1605 line_ptr += 1; 1606 } 1607 else 1608 lh.maximum_ops_per_insn = 1; 1609 if (lh.maximum_ops_per_insn == 0) 1610 { 1611 (*_bfd_error_handler) 1612 (_("Dwarf Error: Invalid maximum operations per instruction.")); 1613 bfd_set_error (bfd_error_bad_value); 1614 return NULL; 1615 } 1616 lh.default_is_stmt = read_1_byte (abfd, line_ptr); 1617 line_ptr += 1; 1618 lh.line_base = read_1_signed_byte (abfd, line_ptr); 1619 line_ptr += 1; 1620 lh.line_range = read_1_byte (abfd, line_ptr); 1621 line_ptr += 1; 1622 lh.opcode_base = read_1_byte (abfd, line_ptr); 1623 line_ptr += 1; 1624 amt = lh.opcode_base * sizeof (unsigned char); 1625 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt); 1626 1627 lh.standard_opcode_lengths[0] = 1; 1628 1629 for (i = 1; i < lh.opcode_base; ++i) 1630 { 1631 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr); 1632 line_ptr += 1; 1633 } 1634 1635 /* Read directory table. */ 1636 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL) 1637 { 1638 line_ptr += bytes_read; 1639 1640 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0) 1641 { 1642 char **tmp; 1643 1644 amt = table->num_dirs + DIR_ALLOC_CHUNK; 1645 amt *= sizeof (char *); 1646 1647 tmp = (char **) bfd_realloc (table->dirs, amt); 1648 if (tmp == NULL) 1649 goto fail; 1650 table->dirs = tmp; 1651 } 1652 1653 table->dirs[table->num_dirs++] = cur_dir; 1654 } 1655 1656 line_ptr += bytes_read; 1657 1658 /* Read file name table. */ 1659 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL) 1660 { 1661 line_ptr += bytes_read; 1662 1663 if ((table->num_files % FILE_ALLOC_CHUNK) == 0) 1664 { 1665 struct fileinfo *tmp; 1666 1667 amt = table->num_files + FILE_ALLOC_CHUNK; 1668 amt *= sizeof (struct fileinfo); 1669 1670 tmp = (struct fileinfo *) bfd_realloc (table->files, amt); 1671 if (tmp == NULL) 1672 goto fail; 1673 table->files = tmp; 1674 } 1675 1676 table->files[table->num_files].name = cur_file; 1677 table->files[table->num_files].dir = 1678 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1679 line_ptr += bytes_read; 1680 table->files[table->num_files].time = 1681 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1682 line_ptr += bytes_read; 1683 table->files[table->num_files].size = 1684 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1685 line_ptr += bytes_read; 1686 table->num_files++; 1687 } 1688 1689 line_ptr += bytes_read; 1690 1691 /* Read the statement sequences until there's nothing left. */ 1692 while (line_ptr < line_end) 1693 { 1694 /* State machine registers. */ 1695 bfd_vma address = 0; 1696 unsigned char op_index = 0; 1697 char * filename = table->num_files ? concat_filename (table, 1) : NULL; 1698 unsigned int line = 1; 1699 unsigned int column = 0; 1700 unsigned int discriminator = 0; 1701 int is_stmt = lh.default_is_stmt; 1702 int end_sequence = 0; 1703 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some 1704 compilers generate address sequences that are wildly out of 1705 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler 1706 for ia64-Linux). Thus, to determine the low and high 1707 address, we must compare on every DW_LNS_copy, etc. */ 1708 bfd_vma low_pc = (bfd_vma) -1; 1709 bfd_vma high_pc = 0; 1710 1711 /* Decode the table. */ 1712 while (! end_sequence) 1713 { 1714 op_code = read_1_byte (abfd, line_ptr); 1715 line_ptr += 1; 1716 1717 if (op_code >= lh.opcode_base) 1718 { 1719 /* Special operand. */ 1720 adj_opcode = op_code - lh.opcode_base; 1721 if (lh.maximum_ops_per_insn == 1) 1722 address += (adj_opcode / lh.line_range 1723 * lh.minimum_instruction_length); 1724 else 1725 { 1726 address += ((op_index + adj_opcode / lh.line_range) 1727 / lh.maximum_ops_per_insn 1728 * lh.minimum_instruction_length); 1729 op_index = ((op_index + adj_opcode / lh.line_range) 1730 % lh.maximum_ops_per_insn); 1731 } 1732 line += lh.line_base + (adj_opcode % lh.line_range); 1733 /* Append row to matrix using current values. */ 1734 if (!add_line_info (table, address, op_index, filename, 1735 line, column, discriminator, 0)) 1736 goto line_fail; 1737 discriminator = 0; 1738 if (address < low_pc) 1739 low_pc = address; 1740 if (address > high_pc) 1741 high_pc = address; 1742 } 1743 else switch (op_code) 1744 { 1745 case DW_LNS_extended_op: 1746 exop_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1747 line_ptr += bytes_read; 1748 extended_op = read_1_byte (abfd, line_ptr); 1749 line_ptr += 1; 1750 1751 switch (extended_op) 1752 { 1753 case DW_LNE_end_sequence: 1754 end_sequence = 1; 1755 if (!add_line_info (table, address, op_index, filename, line, 1756 column, discriminator, end_sequence)) 1757 goto line_fail; 1758 discriminator = 0; 1759 if (address < low_pc) 1760 low_pc = address; 1761 if (address > high_pc) 1762 high_pc = address; 1763 if (!arange_add (unit, &unit->arange, low_pc, high_pc)) 1764 goto line_fail; 1765 break; 1766 case DW_LNE_set_address: 1767 address = read_address (unit, line_ptr); 1768 op_index = 0; 1769 line_ptr += unit->addr_size; 1770 break; 1771 case DW_LNE_define_file: 1772 cur_file = read_string (abfd, line_ptr, &bytes_read); 1773 line_ptr += bytes_read; 1774 if ((table->num_files % FILE_ALLOC_CHUNK) == 0) 1775 { 1776 struct fileinfo *tmp; 1777 1778 amt = table->num_files + FILE_ALLOC_CHUNK; 1779 amt *= sizeof (struct fileinfo); 1780 tmp = (struct fileinfo *) bfd_realloc (table->files, amt); 1781 if (tmp == NULL) 1782 goto line_fail; 1783 table->files = tmp; 1784 } 1785 table->files[table->num_files].name = cur_file; 1786 table->files[table->num_files].dir = 1787 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1788 line_ptr += bytes_read; 1789 table->files[table->num_files].time = 1790 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1791 line_ptr += bytes_read; 1792 table->files[table->num_files].size = 1793 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1794 line_ptr += bytes_read; 1795 table->num_files++; 1796 break; 1797 case DW_LNE_set_discriminator: 1798 discriminator = 1799 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1800 line_ptr += bytes_read; 1801 break; 1802 case DW_LNE_HP_source_file_correlation: 1803 line_ptr += exop_len - 1; 1804 break; 1805 default: 1806 (*_bfd_error_handler) 1807 (_("Dwarf Error: mangled line number section.")); 1808 bfd_set_error (bfd_error_bad_value); 1809 line_fail: 1810 if (filename != NULL) 1811 free (filename); 1812 goto fail; 1813 } 1814 break; 1815 case DW_LNS_copy: 1816 if (!add_line_info (table, address, op_index, 1817 filename, line, column, discriminator, 0)) 1818 goto line_fail; 1819 discriminator = 0; 1820 if (address < low_pc) 1821 low_pc = address; 1822 if (address > high_pc) 1823 high_pc = address; 1824 break; 1825 case DW_LNS_advance_pc: 1826 if (lh.maximum_ops_per_insn == 1) 1827 address += (lh.minimum_instruction_length 1828 * read_unsigned_leb128 (abfd, line_ptr, 1829 &bytes_read)); 1830 else 1831 { 1832 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr, 1833 &bytes_read); 1834 address = ((op_index + adjust) / lh.maximum_ops_per_insn 1835 * lh.minimum_instruction_length); 1836 op_index = (op_index + adjust) % lh.maximum_ops_per_insn; 1837 } 1838 line_ptr += bytes_read; 1839 break; 1840 case DW_LNS_advance_line: 1841 line += read_signed_leb128 (abfd, line_ptr, &bytes_read); 1842 line_ptr += bytes_read; 1843 break; 1844 case DW_LNS_set_file: 1845 { 1846 unsigned int file; 1847 1848 /* The file and directory tables are 0 1849 based, the references are 1 based. */ 1850 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1851 line_ptr += bytes_read; 1852 if (filename) 1853 free (filename); 1854 filename = concat_filename (table, file); 1855 break; 1856 } 1857 case DW_LNS_set_column: 1858 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1859 line_ptr += bytes_read; 1860 break; 1861 case DW_LNS_negate_stmt: 1862 is_stmt = (!is_stmt); 1863 break; 1864 case DW_LNS_set_basic_block: 1865 break; 1866 case DW_LNS_const_add_pc: 1867 if (lh.maximum_ops_per_insn == 1) 1868 address += (lh.minimum_instruction_length 1869 * ((255 - lh.opcode_base) / lh.line_range)); 1870 else 1871 { 1872 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range); 1873 address += (lh.minimum_instruction_length 1874 * ((op_index + adjust) 1875 / lh.maximum_ops_per_insn)); 1876 op_index = (op_index + adjust) % lh.maximum_ops_per_insn; 1877 } 1878 break; 1879 case DW_LNS_fixed_advance_pc: 1880 address += read_2_bytes (abfd, line_ptr); 1881 op_index = 0; 1882 line_ptr += 2; 1883 break; 1884 default: 1885 /* Unknown standard opcode, ignore it. */ 1886 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++) 1887 { 1888 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 1889 line_ptr += bytes_read; 1890 } 1891 break; 1892 } 1893 } 1894 1895 if (filename) 1896 free (filename); 1897 } 1898 1899 if (sort_line_sequences (table)) 1900 return table; 1901 1902 fail: 1903 if (table->sequences != NULL) 1904 free (table->sequences); 1905 if (table->files != NULL) 1906 free (table->files); 1907 if (table->dirs != NULL) 1908 free (table->dirs); 1909 return NULL; 1910 } 1911 1912 /* If ADDR is within TABLE set the output parameters and return the 1913 range of addresses covered by the entry used to fill them out. 1914 Otherwise set * FILENAME_PTR to NULL and return 0. 1915 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR 1916 are pointers to the objects to be filled in. */ 1917 1918 static bfd_vma 1919 lookup_address_in_line_info_table (struct line_info_table *table, 1920 bfd_vma addr, 1921 const char **filename_ptr, 1922 unsigned int *linenumber_ptr, 1923 unsigned int *discriminator_ptr) 1924 { 1925 struct line_sequence *seq = NULL; 1926 struct line_info *each_line; 1927 int low, high, mid; 1928 1929 /* Binary search the array of sequences. */ 1930 low = 0; 1931 high = table->num_sequences; 1932 while (low < high) 1933 { 1934 mid = (low + high) / 2; 1935 seq = &table->sequences[mid]; 1936 if (addr < seq->low_pc) 1937 high = mid; 1938 else if (addr >= seq->last_line->address) 1939 low = mid + 1; 1940 else 1941 break; 1942 } 1943 1944 if (seq && addr >= seq->low_pc && addr < seq->last_line->address) 1945 { 1946 /* Note: seq->last_line should be a descendingly sorted list. */ 1947 for (each_line = seq->last_line; 1948 each_line; 1949 each_line = each_line->prev_line) 1950 if (addr >= each_line->address) 1951 break; 1952 1953 if (each_line 1954 && !(each_line->end_sequence || each_line == seq->last_line)) 1955 { 1956 *filename_ptr = each_line->filename; 1957 *linenumber_ptr = each_line->line; 1958 if (discriminator_ptr) 1959 *discriminator_ptr = each_line->discriminator; 1960 return seq->last_line->address - seq->low_pc; 1961 } 1962 } 1963 1964 *filename_ptr = NULL; 1965 return 0; 1966 } 1967 1968 /* Read in the .debug_ranges section for future reference. */ 1969 1970 static bfd_boolean 1971 read_debug_ranges (struct comp_unit *unit) 1972 { 1973 struct dwarf2_debug *stash = unit->stash; 1974 return read_section (unit->abfd, &stash->debug_sections[debug_ranges], 1975 stash->syms, 0, 1976 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size); 1977 } 1978 1979 /* Function table functions. */ 1980 1981 /* If ADDR is within UNIT's function tables, set FUNCTIONNAME_PTR, and return 1982 TRUE. Note that we need to find the function that has the smallest range 1983 that contains ADDR, to handle inlined functions without depending upon 1984 them being ordered in TABLE by increasing range. */ 1985 1986 static bfd_boolean 1987 lookup_address_in_function_table (struct comp_unit *unit, 1988 bfd_vma addr, 1989 struct funcinfo **function_ptr, 1990 const char **functionname_ptr) 1991 { 1992 struct funcinfo* each_func; 1993 struct funcinfo* best_fit = NULL; 1994 struct arange *arange; 1995 1996 for (each_func = unit->function_table; 1997 each_func; 1998 each_func = each_func->prev_func) 1999 { 2000 for (arange = &each_func->arange; 2001 arange; 2002 arange = arange->next) 2003 { 2004 if (addr >= arange->low && addr < arange->high) 2005 { 2006 if (!best_fit 2007 || (arange->high - arange->low 2008 < best_fit->arange.high - best_fit->arange.low)) 2009 best_fit = each_func; 2010 } 2011 } 2012 } 2013 2014 if (best_fit) 2015 { 2016 *functionname_ptr = best_fit->name; 2017 *function_ptr = best_fit; 2018 return TRUE; 2019 } 2020 else 2021 { 2022 return FALSE; 2023 } 2024 } 2025 2026 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR 2027 and LINENUMBER_PTR, and return TRUE. */ 2028 2029 static bfd_boolean 2030 lookup_symbol_in_function_table (struct comp_unit *unit, 2031 asymbol *sym, 2032 bfd_vma addr, 2033 const char **filename_ptr, 2034 unsigned int *linenumber_ptr) 2035 { 2036 struct funcinfo* each_func; 2037 struct funcinfo* best_fit = NULL; 2038 struct arange *arange; 2039 const char *name = bfd_asymbol_name (sym); 2040 asection *sec = bfd_get_section (sym); 2041 2042 for (each_func = unit->function_table; 2043 each_func; 2044 each_func = each_func->prev_func) 2045 { 2046 for (arange = &each_func->arange; 2047 arange; 2048 arange = arange->next) 2049 { 2050 if ((!each_func->sec || each_func->sec == sec) 2051 && addr >= arange->low 2052 && addr < arange->high 2053 && each_func->name 2054 && strcmp (name, each_func->name) == 0 2055 && (!best_fit 2056 || (arange->high - arange->low 2057 < best_fit->arange.high - best_fit->arange.low))) 2058 best_fit = each_func; 2059 } 2060 } 2061 2062 if (best_fit) 2063 { 2064 best_fit->sec = sec; 2065 *filename_ptr = best_fit->file; 2066 *linenumber_ptr = best_fit->line; 2067 return TRUE; 2068 } 2069 else 2070 return FALSE; 2071 } 2072 2073 /* Variable table functions. */ 2074 2075 /* If SYM is within variable table of UNIT, set FILENAME_PTR and 2076 LINENUMBER_PTR, and return TRUE. */ 2077 2078 static bfd_boolean 2079 lookup_symbol_in_variable_table (struct comp_unit *unit, 2080 asymbol *sym, 2081 bfd_vma addr, 2082 const char **filename_ptr, 2083 unsigned int *linenumber_ptr) 2084 { 2085 const char *name = bfd_asymbol_name (sym); 2086 asection *sec = bfd_get_section (sym); 2087 struct varinfo* each; 2088 2089 for (each = unit->variable_table; each; each = each->prev_var) 2090 if (each->stack == 0 2091 && each->file != NULL 2092 && each->name != NULL 2093 && each->addr == addr 2094 && (!each->sec || each->sec == sec) 2095 && strcmp (name, each->name) == 0) 2096 break; 2097 2098 if (each) 2099 { 2100 each->sec = sec; 2101 *filename_ptr = each->file; 2102 *linenumber_ptr = each->line; 2103 return TRUE; 2104 } 2105 else 2106 return FALSE; 2107 } 2108 2109 static char * 2110 find_abstract_instance_name (struct comp_unit *unit, 2111 struct attribute *attr_ptr) 2112 { 2113 bfd *abfd = unit->abfd; 2114 bfd_byte *info_ptr; 2115 unsigned int abbrev_number, bytes_read, i; 2116 struct abbrev_info *abbrev; 2117 bfd_uint64_t die_ref = attr_ptr->u.val; 2118 struct attribute attr; 2119 char *name = NULL; 2120 2121 /* DW_FORM_ref_addr can reference an entry in a different CU. It 2122 is an offset from the .debug_info section, not the current CU. */ 2123 if (attr_ptr->form == DW_FORM_ref_addr) 2124 { 2125 /* We only support DW_FORM_ref_addr within the same file, so 2126 any relocations should be resolved already. */ 2127 if (!die_ref) 2128 abort (); 2129 2130 info_ptr = unit->sec_info_ptr + die_ref; 2131 } 2132 else if (attr_ptr->form == DW_FORM_GNU_ref_alt) 2133 { 2134 info_ptr = read_alt_indirect_ref (unit, die_ref); 2135 if (info_ptr == NULL) 2136 { 2137 (*_bfd_error_handler) 2138 (_("Dwarf Error: Unable to read alt ref %u."), die_ref); 2139 bfd_set_error (bfd_error_bad_value); 2140 return name; 2141 } 2142 } 2143 else 2144 info_ptr = unit->info_ptr_unit + die_ref; 2145 2146 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 2147 info_ptr += bytes_read; 2148 2149 if (abbrev_number) 2150 { 2151 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs); 2152 if (! abbrev) 2153 { 2154 (*_bfd_error_handler) 2155 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number); 2156 bfd_set_error (bfd_error_bad_value); 2157 } 2158 else 2159 { 2160 for (i = 0; i < abbrev->num_attrs; ++i) 2161 { 2162 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, 2163 info_ptr); 2164 if (info_ptr == NULL) 2165 break; 2166 switch (attr.name) 2167 { 2168 case DW_AT_name: 2169 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name 2170 over DW_AT_name. */ 2171 if (name == NULL) 2172 name = attr.u.str; 2173 break; 2174 case DW_AT_specification: 2175 name = find_abstract_instance_name (unit, &attr); 2176 break; 2177 case DW_AT_linkage_name: 2178 case DW_AT_MIPS_linkage_name: 2179 name = attr.u.str; 2180 break; 2181 default: 2182 break; 2183 } 2184 } 2185 } 2186 } 2187 return name; 2188 } 2189 2190 static bfd_boolean 2191 read_rangelist (struct comp_unit *unit, struct arange *arange, 2192 bfd_uint64_t offset) 2193 { 2194 bfd_byte *ranges_ptr; 2195 bfd_vma base_address = unit->base_address; 2196 2197 if (! unit->stash->dwarf_ranges_buffer) 2198 { 2199 if (! read_debug_ranges (unit)) 2200 return FALSE; 2201 } 2202 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset; 2203 2204 for (;;) 2205 { 2206 bfd_vma low_pc; 2207 bfd_vma high_pc; 2208 2209 low_pc = read_address (unit, ranges_ptr); 2210 ranges_ptr += unit->addr_size; 2211 high_pc = read_address (unit, ranges_ptr); 2212 ranges_ptr += unit->addr_size; 2213 2214 if (low_pc == 0 && high_pc == 0) 2215 break; 2216 if (low_pc == -1UL && high_pc != -1UL) 2217 base_address = high_pc; 2218 else 2219 { 2220 if (!arange_add (unit, arange, 2221 base_address + low_pc, base_address + high_pc)) 2222 return FALSE; 2223 } 2224 } 2225 return TRUE; 2226 } 2227 2228 /* DWARF2 Compilation unit functions. */ 2229 2230 /* Scan over each die in a comp. unit looking for functions to add 2231 to the function table and variables to the variable table. */ 2232 2233 static bfd_boolean 2234 scan_unit_for_symbols (struct comp_unit *unit) 2235 { 2236 bfd *abfd = unit->abfd; 2237 bfd_byte *info_ptr = unit->first_child_die_ptr; 2238 int nesting_level = 1; 2239 struct funcinfo **nested_funcs; 2240 int nested_funcs_size; 2241 2242 /* Maintain a stack of in-scope functions and inlined functions, which we 2243 can use to set the caller_func field. */ 2244 nested_funcs_size = 32; 2245 nested_funcs = (struct funcinfo **) 2246 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *)); 2247 if (nested_funcs == NULL) 2248 return FALSE; 2249 nested_funcs[nesting_level] = 0; 2250 2251 while (nesting_level) 2252 { 2253 unsigned int abbrev_number, bytes_read, i; 2254 struct abbrev_info *abbrev; 2255 struct attribute attr; 2256 struct funcinfo *func; 2257 struct varinfo *var; 2258 bfd_vma low_pc = 0; 2259 bfd_vma high_pc = 0; 2260 bfd_boolean high_pc_relative = FALSE; 2261 2262 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 2263 info_ptr += bytes_read; 2264 2265 if (! abbrev_number) 2266 { 2267 nesting_level--; 2268 continue; 2269 } 2270 2271 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs); 2272 if (! abbrev) 2273 { 2274 (*_bfd_error_handler) 2275 (_("Dwarf Error: Could not find abbrev number %u."), 2276 abbrev_number); 2277 bfd_set_error (bfd_error_bad_value); 2278 goto fail; 2279 } 2280 2281 var = NULL; 2282 if (abbrev->tag == DW_TAG_subprogram 2283 || abbrev->tag == DW_TAG_entry_point 2284 || abbrev->tag == DW_TAG_inlined_subroutine) 2285 { 2286 bfd_size_type amt = sizeof (struct funcinfo); 2287 func = (struct funcinfo *) bfd_zalloc (abfd, amt); 2288 if (func == NULL) 2289 goto fail; 2290 func->tag = abbrev->tag; 2291 func->prev_func = unit->function_table; 2292 unit->function_table = func; 2293 BFD_ASSERT (!unit->cached); 2294 2295 if (func->tag == DW_TAG_inlined_subroutine) 2296 for (i = nesting_level - 1; i >= 1; i--) 2297 if (nested_funcs[i]) 2298 { 2299 func->caller_func = nested_funcs[i]; 2300 break; 2301 } 2302 nested_funcs[nesting_level] = func; 2303 } 2304 else 2305 { 2306 func = NULL; 2307 if (abbrev->tag == DW_TAG_variable) 2308 { 2309 bfd_size_type amt = sizeof (struct varinfo); 2310 var = (struct varinfo *) bfd_zalloc (abfd, amt); 2311 if (var == NULL) 2312 goto fail; 2313 var->tag = abbrev->tag; 2314 var->stack = 1; 2315 var->prev_var = unit->variable_table; 2316 unit->variable_table = var; 2317 BFD_ASSERT (!unit->cached); 2318 } 2319 2320 /* No inline function in scope at this nesting level. */ 2321 nested_funcs[nesting_level] = 0; 2322 } 2323 2324 for (i = 0; i < abbrev->num_attrs; ++i) 2325 { 2326 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); 2327 if (info_ptr == NULL) 2328 goto fail; 2329 2330 if (func) 2331 { 2332 switch (attr.name) 2333 { 2334 case DW_AT_call_file: 2335 func->caller_file = concat_filename (unit->line_table, 2336 attr.u.val); 2337 break; 2338 2339 case DW_AT_call_line: 2340 func->caller_line = attr.u.val; 2341 break; 2342 2343 case DW_AT_abstract_origin: 2344 case DW_AT_specification: 2345 func->name = find_abstract_instance_name (unit, &attr); 2346 break; 2347 2348 case DW_AT_name: 2349 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name 2350 over DW_AT_name. */ 2351 if (func->name == NULL) 2352 func->name = attr.u.str; 2353 break; 2354 2355 case DW_AT_linkage_name: 2356 case DW_AT_MIPS_linkage_name: 2357 func->name = attr.u.str; 2358 break; 2359 2360 case DW_AT_low_pc: 2361 low_pc = attr.u.val; 2362 break; 2363 2364 case DW_AT_high_pc: 2365 high_pc = attr.u.val; 2366 high_pc_relative = attr.form != DW_FORM_addr; 2367 break; 2368 2369 case DW_AT_ranges: 2370 if (!read_rangelist (unit, &func->arange, attr.u.val)) 2371 goto fail; 2372 break; 2373 2374 case DW_AT_decl_file: 2375 func->file = concat_filename (unit->line_table, 2376 attr.u.val); 2377 break; 2378 2379 case DW_AT_decl_line: 2380 func->line = attr.u.val; 2381 break; 2382 2383 default: 2384 break; 2385 } 2386 } 2387 else if (var) 2388 { 2389 switch (attr.name) 2390 { 2391 case DW_AT_name: 2392 var->name = attr.u.str; 2393 break; 2394 2395 case DW_AT_decl_file: 2396 var->file = concat_filename (unit->line_table, 2397 attr.u.val); 2398 break; 2399 2400 case DW_AT_decl_line: 2401 var->line = attr.u.val; 2402 break; 2403 2404 case DW_AT_external: 2405 if (attr.u.val != 0) 2406 var->stack = 0; 2407 break; 2408 2409 case DW_AT_location: 2410 switch (attr.form) 2411 { 2412 case DW_FORM_block: 2413 case DW_FORM_block1: 2414 case DW_FORM_block2: 2415 case DW_FORM_block4: 2416 case DW_FORM_exprloc: 2417 if (*attr.u.blk->data == DW_OP_addr) 2418 { 2419 var->stack = 0; 2420 2421 /* Verify that DW_OP_addr is the only opcode in the 2422 location, in which case the block size will be 1 2423 plus the address size. */ 2424 /* ??? For TLS variables, gcc can emit 2425 DW_OP_addr <addr> DW_OP_GNU_push_tls_address 2426 which we don't handle here yet. */ 2427 if (attr.u.blk->size == unit->addr_size + 1U) 2428 var->addr = bfd_get (unit->addr_size * 8, 2429 unit->abfd, 2430 attr.u.blk->data + 1); 2431 } 2432 break; 2433 2434 default: 2435 break; 2436 } 2437 break; 2438 2439 default: 2440 break; 2441 } 2442 } 2443 } 2444 2445 if (high_pc_relative) 2446 high_pc += low_pc; 2447 2448 if (func && high_pc != 0) 2449 { 2450 if (!arange_add (unit, &func->arange, low_pc, high_pc)) 2451 goto fail; 2452 } 2453 2454 if (abbrev->has_children) 2455 { 2456 nesting_level++; 2457 2458 if (nesting_level >= nested_funcs_size) 2459 { 2460 struct funcinfo **tmp; 2461 2462 nested_funcs_size *= 2; 2463 tmp = (struct funcinfo **) 2464 bfd_realloc (nested_funcs, 2465 nested_funcs_size * sizeof (struct funcinfo *)); 2466 if (tmp == NULL) 2467 goto fail; 2468 nested_funcs = tmp; 2469 } 2470 nested_funcs[nesting_level] = 0; 2471 } 2472 } 2473 2474 free (nested_funcs); 2475 return TRUE; 2476 2477 fail: 2478 free (nested_funcs); 2479 return FALSE; 2480 } 2481 2482 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This 2483 includes the compilation unit header that proceeds the DIE's, but 2484 does not include the length field that precedes each compilation 2485 unit header. END_PTR points one past the end of this comp unit. 2486 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes). 2487 2488 This routine does not read the whole compilation unit; only enough 2489 to get to the line number information for the compilation unit. */ 2490 2491 static struct comp_unit * 2492 parse_comp_unit (struct dwarf2_debug *stash, 2493 bfd_vma unit_length, 2494 bfd_byte *info_ptr_unit, 2495 unsigned int offset_size) 2496 { 2497 struct comp_unit* unit; 2498 unsigned int version; 2499 bfd_uint64_t abbrev_offset = 0; 2500 unsigned int addr_size; 2501 struct abbrev_info** abbrevs; 2502 unsigned int abbrev_number, bytes_read, i; 2503 struct abbrev_info *abbrev; 2504 struct attribute attr; 2505 bfd_byte *info_ptr = stash->info_ptr; 2506 bfd_byte *end_ptr = info_ptr + unit_length; 2507 bfd_size_type amt; 2508 bfd_vma low_pc = 0; 2509 bfd_vma high_pc = 0; 2510 bfd *abfd = stash->bfd_ptr; 2511 bfd_boolean high_pc_relative = FALSE; 2512 2513 version = read_2_bytes (abfd, info_ptr); 2514 info_ptr += 2; 2515 BFD_ASSERT (offset_size == 4 || offset_size == 8); 2516 if (offset_size == 4) 2517 abbrev_offset = read_4_bytes (abfd, info_ptr); 2518 else 2519 abbrev_offset = read_8_bytes (abfd, info_ptr); 2520 info_ptr += offset_size; 2521 addr_size = read_1_byte (abfd, info_ptr); 2522 info_ptr += 1; 2523 2524 if (version != 2 && version != 3 && version != 4) 2525 { 2526 (*_bfd_error_handler) 2527 (_("Dwarf Error: found dwarf version '%u', this reader" 2528 " only handles version 2, 3 and 4 information."), version); 2529 bfd_set_error (bfd_error_bad_value); 2530 return 0; 2531 } 2532 2533 if (addr_size > sizeof (bfd_vma)) 2534 { 2535 (*_bfd_error_handler) 2536 (_("Dwarf Error: found address size '%u', this reader" 2537 " can not handle sizes greater than '%u'."), 2538 addr_size, 2539 (unsigned int) sizeof (bfd_vma)); 2540 bfd_set_error (bfd_error_bad_value); 2541 return 0; 2542 } 2543 2544 if (addr_size != 2 && addr_size != 4 && addr_size != 8) 2545 { 2546 (*_bfd_error_handler) 2547 ("Dwarf Error: found address size '%u', this reader" 2548 " can only handle address sizes '2', '4' and '8'.", addr_size); 2549 bfd_set_error (bfd_error_bad_value); 2550 return 0; 2551 } 2552 2553 /* Read the abbrevs for this compilation unit into a table. */ 2554 abbrevs = read_abbrevs (abfd, abbrev_offset, stash); 2555 if (! abbrevs) 2556 return 0; 2557 2558 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 2559 info_ptr += bytes_read; 2560 if (! abbrev_number) 2561 { 2562 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."), 2563 abbrev_number); 2564 bfd_set_error (bfd_error_bad_value); 2565 return 0; 2566 } 2567 2568 abbrev = lookup_abbrev (abbrev_number, abbrevs); 2569 if (! abbrev) 2570 { 2571 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."), 2572 abbrev_number); 2573 bfd_set_error (bfd_error_bad_value); 2574 return 0; 2575 } 2576 2577 amt = sizeof (struct comp_unit); 2578 unit = (struct comp_unit *) bfd_zalloc (abfd, amt); 2579 if (unit == NULL) 2580 return NULL; 2581 unit->abfd = abfd; 2582 unit->version = version; 2583 unit->addr_size = addr_size; 2584 unit->offset_size = offset_size; 2585 unit->abbrevs = abbrevs; 2586 unit->end_ptr = end_ptr; 2587 unit->stash = stash; 2588 unit->info_ptr_unit = info_ptr_unit; 2589 unit->sec_info_ptr = stash->sec_info_ptr; 2590 2591 for (i = 0; i < abbrev->num_attrs; ++i) 2592 { 2593 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); 2594 if (info_ptr == NULL) 2595 return NULL; 2596 2597 /* Store the data if it is of an attribute we want to keep in a 2598 partial symbol table. */ 2599 switch (attr.name) 2600 { 2601 case DW_AT_stmt_list: 2602 unit->stmtlist = 1; 2603 unit->line_offset = attr.u.val; 2604 break; 2605 2606 case DW_AT_name: 2607 unit->name = attr.u.str; 2608 break; 2609 2610 case DW_AT_low_pc: 2611 low_pc = attr.u.val; 2612 /* If the compilation unit DIE has a DW_AT_low_pc attribute, 2613 this is the base address to use when reading location 2614 lists or range lists. */ 2615 if (abbrev->tag == DW_TAG_compile_unit) 2616 unit->base_address = low_pc; 2617 break; 2618 2619 case DW_AT_high_pc: 2620 high_pc = attr.u.val; 2621 high_pc_relative = attr.form != DW_FORM_addr; 2622 break; 2623 2624 case DW_AT_ranges: 2625 if (!read_rangelist (unit, &unit->arange, attr.u.val)) 2626 return NULL; 2627 break; 2628 2629 case DW_AT_comp_dir: 2630 { 2631 char *comp_dir = attr.u.str; 2632 if (comp_dir) 2633 { 2634 /* Irix 6.2 native cc prepends <machine>.: to the compilation 2635 directory, get rid of it. */ 2636 char *cp = strchr (comp_dir, ':'); 2637 2638 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/') 2639 comp_dir = cp + 1; 2640 } 2641 unit->comp_dir = comp_dir; 2642 break; 2643 } 2644 2645 default: 2646 break; 2647 } 2648 } 2649 if (high_pc_relative) 2650 high_pc += low_pc; 2651 if (high_pc != 0) 2652 { 2653 if (!arange_add (unit, &unit->arange, low_pc, high_pc)) 2654 return NULL; 2655 } 2656 2657 unit->first_child_die_ptr = info_ptr; 2658 return unit; 2659 } 2660 2661 /* Return TRUE if UNIT may contain the address given by ADDR. When 2662 there are functions written entirely with inline asm statements, the 2663 range info in the compilation unit header may not be correct. We 2664 need to consult the line info table to see if a compilation unit 2665 really contains the given address. */ 2666 2667 static bfd_boolean 2668 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr) 2669 { 2670 struct arange *arange; 2671 2672 if (unit->error) 2673 return FALSE; 2674 2675 arange = &unit->arange; 2676 do 2677 { 2678 if (addr >= arange->low && addr < arange->high) 2679 return TRUE; 2680 arange = arange->next; 2681 } 2682 while (arange); 2683 2684 return FALSE; 2685 } 2686 2687 /* If UNIT contains ADDR, set the output parameters to the values for 2688 the line containing ADDR. The output parameters, FILENAME_PTR, 2689 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects 2690 to be filled in. 2691 2692 Returns the range of addresses covered by the entry that was used 2693 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */ 2694 2695 static bfd_vma 2696 comp_unit_find_nearest_line (struct comp_unit *unit, 2697 bfd_vma addr, 2698 const char **filename_ptr, 2699 const char **functionname_ptr, 2700 unsigned int *linenumber_ptr, 2701 unsigned int *discriminator_ptr, 2702 struct dwarf2_debug *stash) 2703 { 2704 bfd_boolean func_p; 2705 struct funcinfo *function; 2706 2707 if (unit->error) 2708 return FALSE; 2709 2710 if (! unit->line_table) 2711 { 2712 if (! unit->stmtlist) 2713 { 2714 unit->error = 1; 2715 return FALSE; 2716 } 2717 2718 unit->line_table = decode_line_info (unit, stash); 2719 2720 if (! unit->line_table) 2721 { 2722 unit->error = 1; 2723 return FALSE; 2724 } 2725 2726 if (unit->first_child_die_ptr < unit->end_ptr 2727 && ! scan_unit_for_symbols (unit)) 2728 { 2729 unit->error = 1; 2730 return FALSE; 2731 } 2732 } 2733 2734 function = NULL; 2735 func_p = lookup_address_in_function_table (unit, addr, 2736 &function, functionname_ptr); 2737 if (func_p && (function->tag == DW_TAG_inlined_subroutine)) 2738 stash->inliner_chain = function; 2739 2740 return lookup_address_in_line_info_table (unit->line_table, addr, 2741 filename_ptr, 2742 linenumber_ptr, 2743 discriminator_ptr); 2744 } 2745 2746 /* Check to see if line info is already decoded in a comp_unit. 2747 If not, decode it. Returns TRUE if no errors were encountered; 2748 FALSE otherwise. */ 2749 2750 static bfd_boolean 2751 comp_unit_maybe_decode_line_info (struct comp_unit *unit, 2752 struct dwarf2_debug *stash) 2753 { 2754 if (unit->error) 2755 return FALSE; 2756 2757 if (! unit->line_table) 2758 { 2759 if (! unit->stmtlist) 2760 { 2761 unit->error = 1; 2762 return FALSE; 2763 } 2764 2765 unit->line_table = decode_line_info (unit, stash); 2766 2767 if (! unit->line_table) 2768 { 2769 unit->error = 1; 2770 return FALSE; 2771 } 2772 2773 if (unit->first_child_die_ptr < unit->end_ptr 2774 && ! scan_unit_for_symbols (unit)) 2775 { 2776 unit->error = 1; 2777 return FALSE; 2778 } 2779 } 2780 2781 return TRUE; 2782 } 2783 2784 /* If UNIT contains SYM at ADDR, set the output parameters to the 2785 values for the line containing SYM. The output parameters, 2786 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be 2787 filled in. 2788 2789 Return TRUE if UNIT contains SYM, and no errors were encountered; 2790 FALSE otherwise. */ 2791 2792 static bfd_boolean 2793 comp_unit_find_line (struct comp_unit *unit, 2794 asymbol *sym, 2795 bfd_vma addr, 2796 const char **filename_ptr, 2797 unsigned int *linenumber_ptr, 2798 struct dwarf2_debug *stash) 2799 { 2800 if (!comp_unit_maybe_decode_line_info (unit, stash)) 2801 return FALSE; 2802 2803 if (sym->flags & BSF_FUNCTION) 2804 return lookup_symbol_in_function_table (unit, sym, addr, 2805 filename_ptr, 2806 linenumber_ptr); 2807 2808 return lookup_symbol_in_variable_table (unit, sym, addr, 2809 filename_ptr, 2810 linenumber_ptr); 2811 } 2812 2813 static struct funcinfo * 2814 reverse_funcinfo_list (struct funcinfo *head) 2815 { 2816 struct funcinfo *rhead; 2817 struct funcinfo *temp; 2818 2819 for (rhead = NULL; head; head = temp) 2820 { 2821 temp = head->prev_func; 2822 head->prev_func = rhead; 2823 rhead = head; 2824 } 2825 return rhead; 2826 } 2827 2828 static struct varinfo * 2829 reverse_varinfo_list (struct varinfo *head) 2830 { 2831 struct varinfo *rhead; 2832 struct varinfo *temp; 2833 2834 for (rhead = NULL; head; head = temp) 2835 { 2836 temp = head->prev_var; 2837 head->prev_var = rhead; 2838 rhead = head; 2839 } 2840 return rhead; 2841 } 2842 2843 /* Extract all interesting funcinfos and varinfos of a compilation 2844 unit into hash tables for faster lookup. Returns TRUE if no 2845 errors were enountered; FALSE otherwise. */ 2846 2847 static bfd_boolean 2848 comp_unit_hash_info (struct dwarf2_debug *stash, 2849 struct comp_unit *unit, 2850 struct info_hash_table *funcinfo_hash_table, 2851 struct info_hash_table *varinfo_hash_table) 2852 { 2853 struct funcinfo* each_func; 2854 struct varinfo* each_var; 2855 bfd_boolean okay = TRUE; 2856 2857 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED); 2858 2859 if (!comp_unit_maybe_decode_line_info (unit, stash)) 2860 return FALSE; 2861 2862 BFD_ASSERT (!unit->cached); 2863 2864 /* To preserve the original search order, we went to visit the function 2865 infos in the reversed order of the list. However, making the list 2866 bi-directional use quite a bit of extra memory. So we reverse 2867 the list first, traverse the list in the now reversed order and 2868 finally reverse the list again to get back the original order. */ 2869 unit->function_table = reverse_funcinfo_list (unit->function_table); 2870 for (each_func = unit->function_table; 2871 each_func && okay; 2872 each_func = each_func->prev_func) 2873 { 2874 /* Skip nameless functions. */ 2875 if (each_func->name) 2876 /* There is no need to copy name string into hash table as 2877 name string is either in the dwarf string buffer or 2878 info in the stash. */ 2879 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name, 2880 (void*) each_func, FALSE); 2881 } 2882 unit->function_table = reverse_funcinfo_list (unit->function_table); 2883 if (!okay) 2884 return FALSE; 2885 2886 /* We do the same for variable infos. */ 2887 unit->variable_table = reverse_varinfo_list (unit->variable_table); 2888 for (each_var = unit->variable_table; 2889 each_var && okay; 2890 each_var = each_var->prev_var) 2891 { 2892 /* Skip stack vars and vars with no files or names. */ 2893 if (each_var->stack == 0 2894 && each_var->file != NULL 2895 && each_var->name != NULL) 2896 /* There is no need to copy name string into hash table as 2897 name string is either in the dwarf string buffer or 2898 info in the stash. */ 2899 okay = insert_info_hash_table (varinfo_hash_table, each_var->name, 2900 (void*) each_var, FALSE); 2901 } 2902 2903 unit->variable_table = reverse_varinfo_list (unit->variable_table); 2904 unit->cached = TRUE; 2905 return okay; 2906 } 2907 2908 /* Locate a section in a BFD containing debugging info. The search starts 2909 from the section after AFTER_SEC, or from the first section in the BFD if 2910 AFTER_SEC is NULL. The search works by examining the names of the 2911 sections. There are three permissiable names. The first two are given 2912 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info 2913 and .zdebug_info). The third is a prefix .gnu.linkonce.wi. 2914 This is a variation on the .debug_info section which has a checksum 2915 describing the contents appended onto the name. This allows the linker to 2916 identify and discard duplicate debugging sections for different 2917 compilation units. */ 2918 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi." 2919 2920 static asection * 2921 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections, 2922 asection *after_sec) 2923 { 2924 asection *msec; 2925 const char *look; 2926 2927 if (after_sec == NULL) 2928 { 2929 look = debug_sections[debug_info].uncompressed_name; 2930 msec = bfd_get_section_by_name (abfd, look); 2931 if (msec != NULL) 2932 return msec; 2933 2934 look = debug_sections[debug_info].compressed_name; 2935 if (look != NULL) 2936 { 2937 msec = bfd_get_section_by_name (abfd, look); 2938 if (msec != NULL) 2939 return msec; 2940 } 2941 2942 for (msec = abfd->sections; msec != NULL; msec = msec->next) 2943 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO)) 2944 return msec; 2945 2946 return NULL; 2947 } 2948 2949 for (msec = after_sec->next; msec != NULL; msec = msec->next) 2950 { 2951 look = debug_sections[debug_info].uncompressed_name; 2952 if (strcmp (msec->name, look) == 0) 2953 return msec; 2954 2955 look = debug_sections[debug_info].compressed_name; 2956 if (look != NULL && strcmp (msec->name, look) == 0) 2957 return msec; 2958 2959 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO)) 2960 return msec; 2961 } 2962 2963 return NULL; 2964 } 2965 2966 /* Unset vmas for adjusted sections in STASH. */ 2967 2968 static void 2969 unset_sections (struct dwarf2_debug *stash) 2970 { 2971 unsigned int i; 2972 struct adjusted_section *p; 2973 2974 i = stash->adjusted_section_count; 2975 p = stash->adjusted_sections; 2976 for (; i > 0; i--, p++) 2977 p->section->vma = 0; 2978 } 2979 2980 /* Set unique VMAs for loadable and DWARF sections in ABFD and save 2981 VMAs in STASH for unset_sections. */ 2982 2983 static bfd_boolean 2984 place_sections (bfd *abfd, struct dwarf2_debug *stash) 2985 { 2986 struct adjusted_section *p; 2987 unsigned int i; 2988 2989 if (stash->adjusted_section_count != 0) 2990 { 2991 i = stash->adjusted_section_count; 2992 p = stash->adjusted_sections; 2993 for (; i > 0; i--, p++) 2994 p->section->vma = p->adj_vma; 2995 } 2996 else 2997 { 2998 asection *sect; 2999 bfd_vma last_vma = 0, last_dwarf = 0; 3000 bfd_size_type amt; 3001 const char *debug_info_name; 3002 3003 debug_info_name = stash->debug_sections[debug_info].uncompressed_name; 3004 i = 0; 3005 for (sect = abfd->sections; sect != NULL; sect = sect->next) 3006 { 3007 bfd_size_type sz; 3008 int is_debug_info; 3009 3010 if (sect->vma != 0) 3011 continue; 3012 3013 /* We need to adjust the VMAs of any .debug_info sections. 3014 Skip compressed ones, since no relocations could target 3015 them - they should not appear in object files anyway. */ 3016 if (strcmp (sect->name, debug_info_name) == 0) 3017 is_debug_info = 1; 3018 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO)) 3019 is_debug_info = 1; 3020 else 3021 is_debug_info = 0; 3022 3023 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0) 3024 continue; 3025 3026 sz = sect->rawsize ? sect->rawsize : sect->size; 3027 if (sz == 0) 3028 continue; 3029 3030 i++; 3031 } 3032 3033 amt = i * sizeof (struct adjusted_section); 3034 p = (struct adjusted_section *) bfd_alloc (abfd, amt); 3035 if (! p) 3036 return FALSE; 3037 3038 stash->adjusted_sections = p; 3039 stash->adjusted_section_count = i; 3040 3041 for (sect = abfd->sections; sect != NULL; sect = sect->next) 3042 { 3043 bfd_size_type sz; 3044 int is_debug_info; 3045 3046 if (sect->vma != 0) 3047 continue; 3048 3049 /* We need to adjust the VMAs of any .debug_info sections. 3050 Skip compressed ones, since no relocations could target 3051 them - they should not appear in object files anyway. */ 3052 if (strcmp (sect->name, debug_info_name) == 0) 3053 is_debug_info = 1; 3054 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO)) 3055 is_debug_info = 1; 3056 else 3057 is_debug_info = 0; 3058 3059 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0) 3060 continue; 3061 3062 sz = sect->rawsize ? sect->rawsize : sect->size; 3063 if (sz == 0) 3064 continue; 3065 3066 p->section = sect; 3067 if (is_debug_info) 3068 { 3069 BFD_ASSERT (sect->alignment_power == 0); 3070 sect->vma = last_dwarf; 3071 last_dwarf += sz; 3072 } 3073 else if (last_vma != 0) 3074 { 3075 /* Align the new address to the current section 3076 alignment. */ 3077 last_vma = ((last_vma 3078 + ~((bfd_vma) -1 << sect->alignment_power)) 3079 & ((bfd_vma) -1 << sect->alignment_power)); 3080 sect->vma = last_vma; 3081 last_vma += sect->vma + sz; 3082 } 3083 else 3084 last_vma += sect->vma + sz; 3085 3086 p->adj_vma = sect->vma; 3087 3088 p++; 3089 } 3090 } 3091 3092 return TRUE; 3093 } 3094 3095 /* Look up a funcinfo by name using the given info hash table. If found, 3096 also update the locations pointed to by filename_ptr and linenumber_ptr. 3097 3098 This function returns TRUE if a funcinfo that matches the given symbol 3099 and address is found with any error; otherwise it returns FALSE. */ 3100 3101 static bfd_boolean 3102 info_hash_lookup_funcinfo (struct info_hash_table *hash_table, 3103 asymbol *sym, 3104 bfd_vma addr, 3105 const char **filename_ptr, 3106 unsigned int *linenumber_ptr) 3107 { 3108 struct funcinfo* each_func; 3109 struct funcinfo* best_fit = NULL; 3110 struct info_list_node *node; 3111 struct arange *arange; 3112 const char *name = bfd_asymbol_name (sym); 3113 asection *sec = bfd_get_section (sym); 3114 3115 for (node = lookup_info_hash_table (hash_table, name); 3116 node; 3117 node = node->next) 3118 { 3119 each_func = (struct funcinfo *) node->info; 3120 for (arange = &each_func->arange; 3121 arange; 3122 arange = arange->next) 3123 { 3124 if ((!each_func->sec || each_func->sec == sec) 3125 && addr >= arange->low 3126 && addr < arange->high 3127 && (!best_fit 3128 || (arange->high - arange->low 3129 < best_fit->arange.high - best_fit->arange.low))) 3130 best_fit = each_func; 3131 } 3132 } 3133 3134 if (best_fit) 3135 { 3136 best_fit->sec = sec; 3137 *filename_ptr = best_fit->file; 3138 *linenumber_ptr = best_fit->line; 3139 return TRUE; 3140 } 3141 3142 return FALSE; 3143 } 3144 3145 /* Look up a varinfo by name using the given info hash table. If found, 3146 also update the locations pointed to by filename_ptr and linenumber_ptr. 3147 3148 This function returns TRUE if a varinfo that matches the given symbol 3149 and address is found with any error; otherwise it returns FALSE. */ 3150 3151 static bfd_boolean 3152 info_hash_lookup_varinfo (struct info_hash_table *hash_table, 3153 asymbol *sym, 3154 bfd_vma addr, 3155 const char **filename_ptr, 3156 unsigned int *linenumber_ptr) 3157 { 3158 const char *name = bfd_asymbol_name (sym); 3159 asection *sec = bfd_get_section (sym); 3160 struct varinfo* each; 3161 struct info_list_node *node; 3162 3163 for (node = lookup_info_hash_table (hash_table, name); 3164 node; 3165 node = node->next) 3166 { 3167 each = (struct varinfo *) node->info; 3168 if (each->addr == addr 3169 && (!each->sec || each->sec == sec)) 3170 { 3171 each->sec = sec; 3172 *filename_ptr = each->file; 3173 *linenumber_ptr = each->line; 3174 return TRUE; 3175 } 3176 } 3177 3178 return FALSE; 3179 } 3180 3181 /* Update the funcinfo and varinfo info hash tables if they are 3182 not up to date. Returns TRUE if there is no error; otherwise 3183 returns FALSE and disable the info hash tables. */ 3184 3185 static bfd_boolean 3186 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash) 3187 { 3188 struct comp_unit *each; 3189 3190 /* Exit if hash tables are up-to-date. */ 3191 if (stash->all_comp_units == stash->hash_units_head) 3192 return TRUE; 3193 3194 if (stash->hash_units_head) 3195 each = stash->hash_units_head->prev_unit; 3196 else 3197 each = stash->last_comp_unit; 3198 3199 while (each) 3200 { 3201 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table, 3202 stash->varinfo_hash_table)) 3203 { 3204 stash->info_hash_status = STASH_INFO_HASH_DISABLED; 3205 return FALSE; 3206 } 3207 each = each->prev_unit; 3208 } 3209 3210 stash->hash_units_head = stash->all_comp_units; 3211 return TRUE; 3212 } 3213 3214 /* Check consistency of info hash tables. This is for debugging only. */ 3215 3216 static void ATTRIBUTE_UNUSED 3217 stash_verify_info_hash_table (struct dwarf2_debug *stash) 3218 { 3219 struct comp_unit *each_unit; 3220 struct funcinfo *each_func; 3221 struct varinfo *each_var; 3222 struct info_list_node *node; 3223 bfd_boolean found; 3224 3225 for (each_unit = stash->all_comp_units; 3226 each_unit; 3227 each_unit = each_unit->next_unit) 3228 { 3229 for (each_func = each_unit->function_table; 3230 each_func; 3231 each_func = each_func->prev_func) 3232 { 3233 if (!each_func->name) 3234 continue; 3235 node = lookup_info_hash_table (stash->funcinfo_hash_table, 3236 each_func->name); 3237 BFD_ASSERT (node); 3238 found = FALSE; 3239 while (node && !found) 3240 { 3241 found = node->info == each_func; 3242 node = node->next; 3243 } 3244 BFD_ASSERT (found); 3245 } 3246 3247 for (each_var = each_unit->variable_table; 3248 each_var; 3249 each_var = each_var->prev_var) 3250 { 3251 if (!each_var->name || !each_var->file || each_var->stack) 3252 continue; 3253 node = lookup_info_hash_table (stash->varinfo_hash_table, 3254 each_var->name); 3255 BFD_ASSERT (node); 3256 found = FALSE; 3257 while (node && !found) 3258 { 3259 found = node->info == each_var; 3260 node = node->next; 3261 } 3262 BFD_ASSERT (found); 3263 } 3264 } 3265 } 3266 3267 /* Check to see if we want to enable the info hash tables, which consume 3268 quite a bit of memory. Currently we only check the number times 3269 bfd_dwarf2_find_line is called. In the future, we may also want to 3270 take the number of symbols into account. */ 3271 3272 static void 3273 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash) 3274 { 3275 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF); 3276 3277 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER) 3278 return; 3279 3280 /* FIXME: Maybe we should check the reduce_memory_overheads 3281 and optimize fields in the bfd_link_info structure ? */ 3282 3283 /* Create hash tables. */ 3284 stash->funcinfo_hash_table = create_info_hash_table (abfd); 3285 stash->varinfo_hash_table = create_info_hash_table (abfd); 3286 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table) 3287 { 3288 /* Turn off info hashes if any allocation above fails. */ 3289 stash->info_hash_status = STASH_INFO_HASH_DISABLED; 3290 return; 3291 } 3292 /* We need a forced update so that the info hash tables will 3293 be created even though there is no compilation unit. That 3294 happens if STASH_INFO_HASH_TRIGGER is 0. */ 3295 stash_maybe_update_info_hash_tables (stash); 3296 stash->info_hash_status = STASH_INFO_HASH_ON; 3297 } 3298 3299 /* Find the file and line associated with a symbol and address using the 3300 info hash tables of a stash. If there is a match, the function returns 3301 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr; 3302 otherwise it returns FALSE. */ 3303 3304 static bfd_boolean 3305 stash_find_line_fast (struct dwarf2_debug *stash, 3306 asymbol *sym, 3307 bfd_vma addr, 3308 const char **filename_ptr, 3309 unsigned int *linenumber_ptr) 3310 { 3311 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON); 3312 3313 if (sym->flags & BSF_FUNCTION) 3314 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr, 3315 filename_ptr, linenumber_ptr); 3316 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr, 3317 filename_ptr, linenumber_ptr); 3318 } 3319 3320 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified. 3321 If DEBUG_BFD is not specified, we read debug information from ABFD 3322 or its gnu_debuglink. The results will be stored in PINFO. 3323 The function returns TRUE iff debug information is ready. */ 3324 3325 bfd_boolean 3326 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd, 3327 const struct dwarf_debug_section *debug_sections, 3328 asymbol **symbols, 3329 void **pinfo) 3330 { 3331 bfd_size_type amt = sizeof (struct dwarf2_debug); 3332 bfd_size_type total_size; 3333 asection *msec; 3334 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo; 3335 3336 if (stash != NULL) 3337 return TRUE; 3338 3339 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt); 3340 if (! stash) 3341 return FALSE; 3342 stash->debug_sections = debug_sections; 3343 stash->syms = symbols; 3344 3345 *pinfo = stash; 3346 3347 if (debug_bfd == NULL) 3348 debug_bfd = abfd; 3349 3350 msec = find_debug_info (debug_bfd, debug_sections, NULL); 3351 if (msec == NULL && abfd == debug_bfd) 3352 { 3353 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR); 3354 3355 if (debug_filename == NULL) 3356 /* No dwarf2 info, and no gnu_debuglink to follow. 3357 Note that at this point the stash has been allocated, but 3358 contains zeros. This lets future calls to this function 3359 fail more quickly. */ 3360 return FALSE; 3361 3362 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL 3363 || ! bfd_check_format (debug_bfd, bfd_object) 3364 || (msec = find_debug_info (debug_bfd, 3365 debug_sections, NULL)) == NULL) 3366 { 3367 if (debug_bfd) 3368 bfd_close (debug_bfd); 3369 /* FIXME: Should we report our failure to follow the debuglink ? */ 3370 free (debug_filename); 3371 return FALSE; 3372 } 3373 stash->close_on_cleanup = TRUE; 3374 } 3375 stash->bfd_ptr = debug_bfd; 3376 3377 /* There can be more than one DWARF2 info section in a BFD these 3378 days. First handle the easy case when there's only one. If 3379 there's more than one, try case two: none of the sections is 3380 compressed. In that case, read them all in and produce one 3381 large stash. We do this in two passes - in the first pass we 3382 just accumulate the section sizes, and in the second pass we 3383 read in the section's contents. (The allows us to avoid 3384 reallocing the data as we add sections to the stash.) If 3385 some or all sections are compressed, then do things the slow 3386 way, with a bunch of reallocs. */ 3387 3388 if (! find_debug_info (debug_bfd, debug_sections, msec)) 3389 { 3390 /* Case 1: only one info section. */ 3391 total_size = msec->size; 3392 if (! read_section (debug_bfd, &stash->debug_sections[debug_info], 3393 symbols, 0, 3394 &stash->info_ptr_memory, &total_size)) 3395 return FALSE; 3396 } 3397 else 3398 { 3399 /* Case 2: multiple sections. */ 3400 for (total_size = 0; 3401 msec; 3402 msec = find_debug_info (debug_bfd, debug_sections, msec)) 3403 total_size += msec->size; 3404 3405 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size); 3406 if (stash->info_ptr_memory == NULL) 3407 return FALSE; 3408 3409 total_size = 0; 3410 for (msec = find_debug_info (debug_bfd, debug_sections, NULL); 3411 msec; 3412 msec = find_debug_info (debug_bfd, debug_sections, msec)) 3413 { 3414 bfd_size_type size; 3415 3416 size = msec->size; 3417 if (size == 0) 3418 continue; 3419 3420 if (!(bfd_simple_get_relocated_section_contents 3421 (debug_bfd, msec, stash->info_ptr_memory + total_size, 3422 symbols))) 3423 return FALSE; 3424 3425 total_size += size; 3426 } 3427 } 3428 3429 stash->info_ptr = stash->info_ptr_memory; 3430 stash->info_ptr_end = stash->info_ptr + total_size; 3431 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL); 3432 stash->sec_info_ptr = stash->info_ptr; 3433 return TRUE; 3434 } 3435 3436 /* Find the source code location of SYMBOL. If SYMBOL is NULL 3437 then find the nearest source code location corresponding to 3438 the address SECTION + OFFSET. 3439 Returns TRUE if the line is found without error and fills in 3440 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was 3441 NULL the FUNCTIONNAME_PTR is also filled in. 3442 SYMBOLS contains the symbol table for ABFD. 3443 DEBUG_SECTIONS contains the name of the dwarf debug sections. 3444 ADDR_SIZE is the number of bytes in the initial .debug_info length 3445 field and in the abbreviation offset, or zero to indicate that the 3446 default value should be used. */ 3447 3448 static bfd_boolean 3449 find_line (bfd *abfd, 3450 const struct dwarf_debug_section *debug_sections, 3451 asection *section, 3452 bfd_vma offset, 3453 asymbol *symbol, 3454 asymbol **symbols, 3455 const char **filename_ptr, 3456 const char **functionname_ptr, 3457 unsigned int *linenumber_ptr, 3458 unsigned int *discriminator_ptr, 3459 unsigned int addr_size, 3460 void **pinfo) 3461 { 3462 /* Read each compilation unit from the section .debug_info, and check 3463 to see if it contains the address we are searching for. If yes, 3464 lookup the address, and return the line number info. If no, go 3465 on to the next compilation unit. 3466 3467 We keep a list of all the previously read compilation units, and 3468 a pointer to the next un-read compilation unit. Check the 3469 previously read units before reading more. */ 3470 struct dwarf2_debug *stash; 3471 /* What address are we looking for? */ 3472 bfd_vma addr; 3473 struct comp_unit* each; 3474 bfd_boolean found = FALSE; 3475 bfd_boolean do_line; 3476 3477 *filename_ptr = NULL; 3478 if (functionname_ptr != NULL) 3479 *functionname_ptr = NULL; 3480 *linenumber_ptr = 0; 3481 if (discriminator_ptr) 3482 *discriminator_ptr = 0; 3483 3484 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, 3485 debug_sections, symbols, pinfo)) 3486 return FALSE; 3487 3488 stash = (struct dwarf2_debug *) *pinfo; 3489 3490 /* In a relocatable file, 2 functions may have the same address. 3491 We change the section vma so that they won't overlap. */ 3492 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 3493 { 3494 if (! place_sections (abfd, stash)) 3495 return FALSE; 3496 } 3497 3498 do_line = (section == NULL 3499 && offset == 0 3500 && functionname_ptr == NULL 3501 && symbol != NULL); 3502 if (do_line) 3503 { 3504 addr = symbol->value; 3505 section = bfd_get_section (symbol); 3506 } 3507 else if (section != NULL 3508 && functionname_ptr != NULL 3509 && symbol == NULL) 3510 addr = offset; 3511 else 3512 abort (); 3513 3514 if (section->output_section) 3515 addr += section->output_section->vma + section->output_offset; 3516 else 3517 addr += section->vma; 3518 3519 /* A null info_ptr indicates that there is no dwarf2 info 3520 (or that an error occured while setting up the stash). */ 3521 if (! stash->info_ptr) 3522 return FALSE; 3523 3524 stash->inliner_chain = NULL; 3525 3526 /* Check the previously read comp. units first. */ 3527 if (do_line) 3528 { 3529 /* The info hash tables use quite a bit of memory. We may not want to 3530 always use them. We use some heuristics to decide if and when to 3531 turn it on. */ 3532 if (stash->info_hash_status == STASH_INFO_HASH_OFF) 3533 stash_maybe_enable_info_hash_tables (abfd, stash); 3534 3535 /* Keep info hash table up to date if they are available. Note that we 3536 may disable the hash tables if there is any error duing update. */ 3537 if (stash->info_hash_status == STASH_INFO_HASH_ON) 3538 stash_maybe_update_info_hash_tables (stash); 3539 3540 if (stash->info_hash_status == STASH_INFO_HASH_ON) 3541 { 3542 found = stash_find_line_fast (stash, symbol, addr, filename_ptr, 3543 linenumber_ptr); 3544 if (found) 3545 goto done; 3546 } 3547 else 3548 { 3549 /* Check the previously read comp. units first. */ 3550 for (each = stash->all_comp_units; each; each = each->next_unit) 3551 if ((symbol->flags & BSF_FUNCTION) == 0 3552 || each->arange.high == 0 3553 || comp_unit_contains_address (each, addr)) 3554 { 3555 found = comp_unit_find_line (each, symbol, addr, filename_ptr, 3556 linenumber_ptr, stash); 3557 if (found) 3558 goto done; 3559 } 3560 } 3561 } 3562 else 3563 { 3564 bfd_vma min_range = (bfd_vma) -1; 3565 const char * local_filename = NULL; 3566 const char * local_functionname = NULL; 3567 unsigned int local_linenumber = 0; 3568 unsigned int local_discriminator = 0; 3569 3570 for (each = stash->all_comp_units; each; each = each->next_unit) 3571 { 3572 bfd_vma range = (bfd_vma) -1; 3573 3574 found = ((each->arange.high == 0 3575 || comp_unit_contains_address (each, addr)) 3576 && (range = comp_unit_find_nearest_line (each, addr, 3577 & local_filename, 3578 & local_functionname, 3579 & local_linenumber, 3580 & local_discriminator, 3581 stash)) != 0); 3582 if (found) 3583 { 3584 /* PRs 15935 15994: Bogus debug information may have provided us 3585 with an erroneous match. We attempt to counter this by 3586 selecting the match that has the smallest address range 3587 associated with it. (We are assuming that corrupt debug info 3588 will tend to result in extra large address ranges rather than 3589 extra small ranges). 3590 3591 This does mean that we scan through all of the CUs associated 3592 with the bfd each time this function is called. But this does 3593 have the benefit of producing consistent results every time the 3594 function is called. */ 3595 if (range <= min_range) 3596 { 3597 if (filename_ptr && local_filename) 3598 * filename_ptr = local_filename; 3599 if (functionname_ptr && local_functionname) 3600 * functionname_ptr = local_functionname; 3601 if (discriminator_ptr && local_discriminator) 3602 * discriminator_ptr = local_discriminator; 3603 if (local_linenumber) 3604 * linenumber_ptr = local_linenumber; 3605 min_range = range; 3606 } 3607 } 3608 } 3609 3610 if (* linenumber_ptr) 3611 { 3612 found = TRUE; 3613 goto done; 3614 } 3615 } 3616 3617 /* The DWARF2 spec says that the initial length field, and the 3618 offset of the abbreviation table, should both be 4-byte values. 3619 However, some compilers do things differently. */ 3620 if (addr_size == 0) 3621 addr_size = 4; 3622 BFD_ASSERT (addr_size == 4 || addr_size == 8); 3623 3624 /* Read each remaining comp. units checking each as they are read. */ 3625 while (stash->info_ptr < stash->info_ptr_end) 3626 { 3627 bfd_vma length; 3628 unsigned int offset_size = addr_size; 3629 bfd_byte *info_ptr_unit = stash->info_ptr; 3630 3631 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr); 3632 /* A 0xffffff length is the DWARF3 way of indicating 3633 we use 64-bit offsets, instead of 32-bit offsets. */ 3634 if (length == 0xffffffff) 3635 { 3636 offset_size = 8; 3637 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4); 3638 stash->info_ptr += 12; 3639 } 3640 /* A zero length is the IRIX way of indicating 64-bit offsets, 3641 mostly because the 64-bit length will generally fit in 32 3642 bits, and the endianness helps. */ 3643 else if (length == 0) 3644 { 3645 offset_size = 8; 3646 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4); 3647 stash->info_ptr += 8; 3648 } 3649 /* In the absence of the hints above, we assume 32-bit DWARF2 3650 offsets even for targets with 64-bit addresses, because: 3651 a) most of the time these targets will not have generated 3652 more than 2Gb of debug info and so will not need 64-bit 3653 offsets, 3654 and 3655 b) if they do use 64-bit offsets but they are not using 3656 the size hints that are tested for above then they are 3657 not conforming to the DWARF3 standard anyway. */ 3658 else if (addr_size == 8) 3659 { 3660 offset_size = 4; 3661 stash->info_ptr += 4; 3662 } 3663 else 3664 stash->info_ptr += 4; 3665 3666 if (length > 0) 3667 { 3668 each = parse_comp_unit (stash, length, info_ptr_unit, 3669 offset_size); 3670 if (!each) 3671 /* The dwarf information is damaged, don't trust it any 3672 more. */ 3673 break; 3674 stash->info_ptr += length; 3675 3676 if (stash->all_comp_units) 3677 stash->all_comp_units->prev_unit = each; 3678 else 3679 stash->last_comp_unit = each; 3680 3681 each->next_unit = stash->all_comp_units; 3682 stash->all_comp_units = each; 3683 3684 /* DW_AT_low_pc and DW_AT_high_pc are optional for 3685 compilation units. If we don't have them (i.e., 3686 unit->high == 0), we need to consult the line info table 3687 to see if a compilation unit contains the given 3688 address. */ 3689 if (do_line) 3690 found = (((symbol->flags & BSF_FUNCTION) == 0 3691 || each->arange.high == 0 3692 || comp_unit_contains_address (each, addr)) 3693 && comp_unit_find_line (each, symbol, addr, 3694 filename_ptr, 3695 linenumber_ptr, 3696 stash)); 3697 else 3698 found = ((each->arange.high == 0 3699 || comp_unit_contains_address (each, addr)) 3700 && comp_unit_find_nearest_line (each, addr, 3701 filename_ptr, 3702 functionname_ptr, 3703 linenumber_ptr, 3704 discriminator_ptr, 3705 stash)) > 0; 3706 3707 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr) 3708 == stash->sec->size) 3709 { 3710 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections, 3711 stash->sec); 3712 stash->sec_info_ptr = stash->info_ptr; 3713 } 3714 3715 if (found) 3716 goto done; 3717 } 3718 } 3719 3720 done: 3721 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 3722 unset_sections (stash); 3723 3724 return found; 3725 } 3726 3727 /* The DWARF2 version of find_nearest_line. 3728 Return TRUE if the line is found without error. */ 3729 3730 bfd_boolean 3731 _bfd_dwarf2_find_nearest_line (bfd *abfd, 3732 const struct dwarf_debug_section *debug_sections, 3733 asection *section, 3734 asymbol **symbols, 3735 bfd_vma offset, 3736 const char **filename_ptr, 3737 const char **functionname_ptr, 3738 unsigned int *linenumber_ptr, 3739 unsigned int *discriminator_ptr, 3740 unsigned int addr_size, 3741 void **pinfo) 3742 { 3743 return find_line (abfd, debug_sections, section, offset, NULL, symbols, 3744 filename_ptr, functionname_ptr, linenumber_ptr, 3745 discriminator_ptr, addr_size, pinfo); 3746 } 3747 3748 /* The DWARF2 version of find_line. 3749 Return TRUE if the line is found without error. */ 3750 3751 bfd_boolean 3752 _bfd_dwarf2_find_line (bfd *abfd, 3753 asymbol **symbols, 3754 asymbol *symbol, 3755 const char **filename_ptr, 3756 unsigned int *linenumber_ptr, 3757 unsigned int *discriminator_ptr, 3758 unsigned int addr_size, 3759 void **pinfo) 3760 { 3761 return find_line (abfd, dwarf_debug_sections, NULL, 0, symbol, symbols, 3762 filename_ptr, NULL, linenumber_ptr, discriminator_ptr, 3763 addr_size, pinfo); 3764 } 3765 3766 bfd_boolean 3767 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED, 3768 const char **filename_ptr, 3769 const char **functionname_ptr, 3770 unsigned int *linenumber_ptr, 3771 void **pinfo) 3772 { 3773 struct dwarf2_debug *stash; 3774 3775 stash = (struct dwarf2_debug *) *pinfo; 3776 if (stash) 3777 { 3778 struct funcinfo *func = stash->inliner_chain; 3779 3780 if (func && func->caller_func) 3781 { 3782 *filename_ptr = func->caller_file; 3783 *functionname_ptr = func->caller_func->name; 3784 *linenumber_ptr = func->caller_line; 3785 stash->inliner_chain = func->caller_func; 3786 return TRUE; 3787 } 3788 } 3789 3790 return FALSE; 3791 } 3792 3793 void 3794 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo) 3795 { 3796 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo; 3797 struct comp_unit *each; 3798 3799 if (abfd == NULL || stash == NULL) 3800 return; 3801 3802 for (each = stash->all_comp_units; each; each = each->next_unit) 3803 { 3804 struct abbrev_info **abbrevs = each->abbrevs; 3805 struct funcinfo *function_table = each->function_table; 3806 struct varinfo *variable_table = each->variable_table; 3807 size_t i; 3808 3809 for (i = 0; i < ABBREV_HASH_SIZE; i++) 3810 { 3811 struct abbrev_info *abbrev = abbrevs[i]; 3812 3813 while (abbrev) 3814 { 3815 free (abbrev->attrs); 3816 abbrev = abbrev->next; 3817 } 3818 } 3819 3820 if (each->line_table) 3821 { 3822 free (each->line_table->dirs); 3823 free (each->line_table->files); 3824 } 3825 3826 while (function_table) 3827 { 3828 if (function_table->file) 3829 { 3830 free (function_table->file); 3831 function_table->file = NULL; 3832 } 3833 3834 if (function_table->caller_file) 3835 { 3836 free (function_table->caller_file); 3837 function_table->caller_file = NULL; 3838 } 3839 function_table = function_table->prev_func; 3840 } 3841 3842 while (variable_table) 3843 { 3844 if (variable_table->file) 3845 { 3846 free (variable_table->file); 3847 variable_table->file = NULL; 3848 } 3849 3850 variable_table = variable_table->prev_var; 3851 } 3852 } 3853 3854 if (stash->dwarf_abbrev_buffer) 3855 free (stash->dwarf_abbrev_buffer); 3856 if (stash->dwarf_line_buffer) 3857 free (stash->dwarf_line_buffer); 3858 if (stash->dwarf_str_buffer) 3859 free (stash->dwarf_str_buffer); 3860 if (stash->dwarf_ranges_buffer) 3861 free (stash->dwarf_ranges_buffer); 3862 if (stash->info_ptr_memory) 3863 free (stash->info_ptr_memory); 3864 if (stash->close_on_cleanup) 3865 bfd_close (stash->bfd_ptr); 3866 if (stash->alt_dwarf_str_buffer) 3867 free (stash->alt_dwarf_str_buffer); 3868 if (stash->alt_dwarf_info_buffer) 3869 free (stash->alt_dwarf_info_buffer); 3870 if (stash->alt_bfd_ptr) 3871 bfd_close (stash->alt_bfd_ptr); 3872 } 3873