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