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