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