2 Copyright (C) 1994-2014 Free Software Foundation, Inc.
4 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
7 From the dwarf2read.c header:
8 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
9 Inc. with support from Florida State University (under contract
10 with the Ada Joint Program Office), and Silicon Graphics, Inc.
11 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
12 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 support in dwarfread.c
15 This file is part of BFD.
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 3 of the License, or (at
20 your option) any later version.
22 This program is distributed in the hope that it will be useful, but
23 WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
30 MA 02110-1301, USA. */
34 #include "libiberty.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char maximum_ops_per_insn;
48 unsigned char default_is_stmt;
50 unsigned char line_range;
51 unsigned char opcode_base;
52 unsigned char *standard_opcode_lengths;
55 /* Attributes have a name and a value. */
59 enum dwarf_attribute name;
64 struct dwarf_block *blk;
71 /* Blocks are a bunch of untyped bytes. */
78 struct adjusted_section
86 /* A list of all previously read comp_units. */
87 struct comp_unit *all_comp_units;
89 /* Last comp unit in list above. */
90 struct comp_unit *last_comp_unit;
92 /* Names of the debug sections. */
93 const struct dwarf_debug_section *debug_sections;
95 /* The next unread compilation unit within the .debug_info section.
96 Zero indicates that the .debug_info section has not been loaded
100 /* Pointer to the end of the .debug_info section memory buffer. */
101 bfd_byte *info_ptr_end;
103 /* Pointer to the bfd, section and address of the beginning of the
104 section. The bfd might be different than expected because of
105 gnu_debuglink sections. */
108 bfd_byte *sec_info_ptr;
110 /* Support for alternate debug info sections created by the DWZ utility:
111 This includes a pointer to an alternate bfd which contains *extra*,
112 possibly duplicate debug sections, and pointers to the loaded
113 .debug_str and .debug_info sections from this bfd. */
115 bfd_byte * alt_dwarf_str_buffer;
116 bfd_size_type alt_dwarf_str_size;
117 bfd_byte * alt_dwarf_info_buffer;
118 bfd_size_type alt_dwarf_info_size;
120 /* A pointer to the memory block allocated for info_ptr. Neither
121 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
122 beginning of the malloc block. This is used only to free the
124 bfd_byte *info_ptr_memory;
126 /* Pointer to the symbol table. */
129 /* Pointer to the .debug_abbrev section loaded into memory. */
130 bfd_byte *dwarf_abbrev_buffer;
132 /* Length of the loaded .debug_abbrev section. */
133 bfd_size_type dwarf_abbrev_size;
135 /* Buffer for decode_line_info. */
136 bfd_byte *dwarf_line_buffer;
138 /* Length of the loaded .debug_line section. */
139 bfd_size_type dwarf_line_size;
141 /* Pointer to the .debug_str section loaded into memory. */
142 bfd_byte *dwarf_str_buffer;
144 /* Length of the loaded .debug_str section. */
145 bfd_size_type dwarf_str_size;
147 /* Pointer to the .debug_ranges section loaded into memory. */
148 bfd_byte *dwarf_ranges_buffer;
150 /* Length of the loaded .debug_ranges section. */
151 bfd_size_type dwarf_ranges_size;
153 /* If the most recent call to bfd_find_nearest_line was given an
154 address in an inlined function, preserve a pointer into the
155 calling chain for subsequent calls to bfd_find_inliner_info to
157 struct funcinfo *inliner_chain;
159 /* Section VMAs at the time the stash was built. */
162 /* Number of sections whose VMA we must adjust. */
163 unsigned int adjusted_section_count;
165 /* Array of sections with adjusted VMA. */
166 struct adjusted_section *adjusted_sections;
168 /* Number of times find_line is called. This is used in
169 the heuristic for enabling the info hash tables. */
172 #define STASH_INFO_HASH_TRIGGER 100
174 /* Hash table mapping symbol names to function infos. */
175 struct info_hash_table *funcinfo_hash_table;
177 /* Hash table mapping symbol names to variable infos. */
178 struct info_hash_table *varinfo_hash_table;
180 /* Head of comp_unit list in the last hash table update. */
181 struct comp_unit *hash_units_head;
183 /* Status of info hash. */
184 int info_hash_status;
185 #define STASH_INFO_HASH_OFF 0
186 #define STASH_INFO_HASH_ON 1
187 #define STASH_INFO_HASH_DISABLED 2
189 /* True if we opened bfd_ptr. */
190 bfd_boolean close_on_cleanup;
200 /* A minimal decoding of DWARF2 compilation units. We only decode
201 what's needed to get to the line number information. */
205 /* Chain the previously read compilation units. */
206 struct comp_unit *next_unit;
208 /* Likewise, chain the compilation unit read after this one.
209 The comp units are stored in reversed reading order. */
210 struct comp_unit *prev_unit;
212 /* Keep the bfd convenient (for memory allocation). */
215 /* The lowest and highest addresses contained in this compilation
216 unit as specified in the compilation unit header. */
217 struct arange arange;
219 /* The DW_AT_name attribute (for error messages). */
222 /* The abbrev hash table. */
223 struct abbrev_info **abbrevs;
225 /* Note that an error was found by comp_unit_find_nearest_line. */
228 /* The DW_AT_comp_dir attribute. */
231 /* TRUE if there is a line number table associated with this comp. unit. */
234 /* Pointer to the current comp_unit so that we can find a given entry
236 bfd_byte *info_ptr_unit;
238 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
239 bfd_byte *sec_info_ptr;
241 /* The offset into .debug_line of the line number table. */
242 unsigned long line_offset;
244 /* Pointer to the first child die for the comp unit. */
245 bfd_byte *first_child_die_ptr;
247 /* The end of the comp unit. */
250 /* The decoded line number, NULL if not yet decoded. */
251 struct line_info_table *line_table;
253 /* A list of the functions found in this comp. unit. */
254 struct funcinfo *function_table;
256 /* A list of the variables found in this comp. unit. */
257 struct varinfo *variable_table;
259 /* Pointer to dwarf2_debug structure. */
260 struct dwarf2_debug *stash;
262 /* DWARF format version for this unit - from unit header. */
265 /* Address size for this unit - from unit header. */
266 unsigned char addr_size;
268 /* Offset size for this unit - from unit header. */
269 unsigned char offset_size;
271 /* Base address for this unit - from DW_AT_low_pc attribute of
272 DW_TAG_compile_unit DIE */
273 bfd_vma base_address;
275 /* TRUE if symbols are cached in hash table for faster lookup by name. */
279 /* This data structure holds the information of an abbrev. */
282 unsigned int number; /* Number identifying abbrev. */
283 enum dwarf_tag tag; /* DWARF tag. */
284 int has_children; /* Boolean. */
285 unsigned int num_attrs; /* Number of attributes. */
286 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
287 struct abbrev_info *next; /* Next in chain. */
292 enum dwarf_attribute name;
293 enum dwarf_form form;
296 /* Map of uncompressed DWARF debug section name to compressed one. It
297 is terminated by NULL uncompressed_name. */
299 const struct dwarf_debug_section dwarf_debug_sections[] =
301 { ".debug_abbrev", ".zdebug_abbrev" },
302 { ".debug_aranges", ".zdebug_aranges" },
303 { ".debug_frame", ".zdebug_frame" },
304 { ".debug_info", ".zdebug_info" },
305 { ".debug_info", ".zdebug_info" },
306 { ".debug_line", ".zdebug_line" },
307 { ".debug_loc", ".zdebug_loc" },
308 { ".debug_macinfo", ".zdebug_macinfo" },
309 { ".debug_macro", ".zdebug_macro" },
310 { ".debug_pubnames", ".zdebug_pubnames" },
311 { ".debug_pubtypes", ".zdebug_pubtypes" },
312 { ".debug_ranges", ".zdebug_ranges" },
313 { ".debug_static_func", ".zdebug_static_func" },
314 { ".debug_static_vars", ".zdebug_static_vars" },
315 { ".debug_str", ".zdebug_str", },
316 { ".debug_str", ".zdebug_str", },
317 { ".debug_types", ".zdebug_types" },
318 /* GNU DWARF 1 extensions */
319 { ".debug_sfnames", ".zdebug_sfnames" },
320 { ".debug_srcinfo", ".zebug_srcinfo" },
321 /* SGI/MIPS DWARF 2 extensions */
322 { ".debug_funcnames", ".zdebug_funcnames" },
323 { ".debug_typenames", ".zdebug_typenames" },
324 { ".debug_varnames", ".zdebug_varnames" },
325 { ".debug_weaknames", ".zdebug_weaknames" },
329 /* NB/ Numbers in this enum must match up with indicies
330 into the dwarf_debug_sections[] array above. */
331 enum dwarf_debug_section_enum
358 #ifndef ABBREV_HASH_SIZE
359 #define ABBREV_HASH_SIZE 121
361 #ifndef ATTR_ALLOC_CHUNK
362 #define ATTR_ALLOC_CHUNK 4
365 /* Variable and function hash tables. This is used to speed up look-up
366 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
367 In order to share code between variable and function infos, we use
368 a list of untyped pointer for all variable/function info associated with
369 a symbol. We waste a bit of memory for list with one node but that
370 simplifies the code. */
372 struct info_list_node
374 struct info_list_node *next;
378 /* Info hash entry. */
379 struct info_hash_entry
381 struct bfd_hash_entry root;
382 struct info_list_node *head;
385 struct info_hash_table
387 struct bfd_hash_table base;
390 /* Function to create a new entry in info hash table. */
392 static struct bfd_hash_entry *
393 info_hash_table_newfunc (struct bfd_hash_entry *entry,
394 struct bfd_hash_table *table,
397 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
399 /* Allocate the structure if it has not already been allocated by a
403 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
409 /* Call the allocation method of the base class. */
410 ret = ((struct info_hash_entry *)
411 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
413 /* Initialize the local fields here. */
417 return (struct bfd_hash_entry *) ret;
420 /* Function to create a new info hash table. It returns a pointer to the
421 newly created table or NULL if there is any error. We need abfd
422 solely for memory allocation. */
424 static struct info_hash_table *
425 create_info_hash_table (bfd *abfd)
427 struct info_hash_table *hash_table;
429 hash_table = ((struct info_hash_table *)
430 bfd_alloc (abfd, sizeof (struct info_hash_table)));
434 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
435 sizeof (struct info_hash_entry)))
437 bfd_release (abfd, hash_table);
444 /* Insert an info entry into an info hash table. We do not check of
445 duplicate entries. Also, the caller need to guarantee that the
446 right type of info in inserted as info is passed as a void* pointer.
447 This function returns true if there is no error. */
450 insert_info_hash_table (struct info_hash_table *hash_table,
455 struct info_hash_entry *entry;
456 struct info_list_node *node;
458 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
463 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
469 node->next = entry->head;
475 /* Look up an info entry list from an info hash table. Return NULL
478 static struct info_list_node *
479 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
481 struct info_hash_entry *entry;
483 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
485 return entry ? entry->head : NULL;
488 /* Read a section into its appropriate place in the dwarf2_debug
489 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
490 not NULL, use bfd_simple_get_relocated_section_contents to read the
491 section contents, otherwise use bfd_get_section_contents. Fail if
492 the located section does not contain at least OFFSET bytes. */
495 read_section (bfd * abfd,
496 const struct dwarf_debug_section *sec,
499 bfd_byte ** section_buffer,
500 bfd_size_type * section_size)
503 const char *section_name = sec->uncompressed_name;
505 /* The section may have already been read. */
506 if (*section_buffer == NULL)
508 msec = bfd_get_section_by_name (abfd, section_name);
511 section_name = sec->compressed_name;
512 if (section_name != NULL)
513 msec = bfd_get_section_by_name (abfd, section_name);
517 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."),
518 sec->uncompressed_name);
519 bfd_set_error (bfd_error_bad_value);
523 *section_size = msec->rawsize ? msec->rawsize : msec->size;
527 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
528 if (! *section_buffer)
533 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
534 if (! *section_buffer)
536 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
542 /* It is possible to get a bad value for the offset into the section
543 that the client wants. Validate it here to avoid trouble later. */
544 if (offset != 0 && offset >= *section_size)
546 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)"
547 " greater than or equal to %s size (%lu)."),
548 (long) offset, section_name, *section_size);
549 bfd_set_error (bfd_error_bad_value);
557 The following function up to the END VERBATIM mark are
558 copied directly from dwarf2read.c. */
560 /* Read dwarf information from a buffer. */
563 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
565 return bfd_get_8 (abfd, buf);
569 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
571 return bfd_get_signed_8 (abfd, buf);
575 read_2_bytes (bfd *abfd, bfd_byte *buf)
577 return bfd_get_16 (abfd, buf);
581 read_4_bytes (bfd *abfd, bfd_byte *buf)
583 return bfd_get_32 (abfd, buf);
587 read_8_bytes (bfd *abfd, bfd_byte *buf)
589 return bfd_get_64 (abfd, buf);
593 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
595 unsigned int size ATTRIBUTE_UNUSED)
601 read_string (bfd *abfd ATTRIBUTE_UNUSED,
603 unsigned int *bytes_read_ptr)
605 /* Return a pointer to the embedded string. */
606 char *str = (char *) buf;
614 *bytes_read_ptr = strlen (str) + 1;
621 read_indirect_string (struct comp_unit * unit,
623 unsigned int * bytes_read_ptr)
626 struct dwarf2_debug *stash = unit->stash;
629 if (unit->offset_size == 4)
630 offset = read_4_bytes (unit->abfd, buf);
632 offset = read_8_bytes (unit->abfd, buf);
634 *bytes_read_ptr = unit->offset_size;
636 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
638 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
641 str = (char *) stash->dwarf_str_buffer + offset;
647 /* Like read_indirect_string but uses a .debug_str located in
648 an alternate filepointed to by the .gnu_debuglink section.
649 Used to impement DW_FORM_GNU_strp_alt. */
652 read_alt_indirect_string (struct comp_unit * unit,
654 unsigned int * bytes_read_ptr)
657 struct dwarf2_debug *stash = unit->stash;
660 if (unit->offset_size == 4)
661 offset = read_4_bytes (unit->abfd, buf);
663 offset = read_8_bytes (unit->abfd, buf);
665 *bytes_read_ptr = unit->offset_size;
667 if (stash->alt_bfd_ptr == NULL)
670 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
672 if (debug_filename == NULL)
675 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
676 || ! bfd_check_format (debug_bfd, bfd_object))
679 bfd_close (debug_bfd);
681 /* FIXME: Should we report our failure to follow the debuglink ? */
682 free (debug_filename);
685 stash->alt_bfd_ptr = debug_bfd;
688 if (! read_section (unit->stash->alt_bfd_ptr,
689 stash->debug_sections + debug_str_alt,
690 NULL, /* FIXME: Do we need to load alternate symbols ? */
692 &stash->alt_dwarf_str_buffer,
693 &stash->alt_dwarf_str_size))
696 str = (char *) stash->alt_dwarf_str_buffer + offset;
703 /* Resolve an alternate reference from UNIT at OFFSET.
704 Returns a pointer into the loaded alternate CU upon success
705 or NULL upon failure. */
708 read_alt_indirect_ref (struct comp_unit * unit,
711 struct dwarf2_debug *stash = unit->stash;
713 if (stash->alt_bfd_ptr == NULL)
716 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
718 if (debug_filename == NULL)
721 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
722 || ! bfd_check_format (debug_bfd, bfd_object))
725 bfd_close (debug_bfd);
727 /* FIXME: Should we report our failure to follow the debuglink ? */
728 free (debug_filename);
731 stash->alt_bfd_ptr = debug_bfd;
734 if (! read_section (unit->stash->alt_bfd_ptr,
735 stash->debug_sections + debug_info_alt,
736 NULL, /* FIXME: Do we need to load alternate symbols ? */
738 &stash->alt_dwarf_info_buffer,
739 &stash->alt_dwarf_info_size))
742 return stash->alt_dwarf_info_buffer + offset;
746 read_address (struct comp_unit *unit, bfd_byte *buf)
748 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
752 switch (unit->addr_size)
755 return bfd_get_signed_64 (unit->abfd, buf);
757 return bfd_get_signed_32 (unit->abfd, buf);
759 return bfd_get_signed_16 (unit->abfd, buf);
766 switch (unit->addr_size)
769 return bfd_get_64 (unit->abfd, buf);
771 return bfd_get_32 (unit->abfd, buf);
773 return bfd_get_16 (unit->abfd, buf);
780 /* Lookup an abbrev_info structure in the abbrev hash table. */
782 static struct abbrev_info *
783 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
785 unsigned int hash_number;
786 struct abbrev_info *abbrev;
788 hash_number = number % ABBREV_HASH_SIZE;
789 abbrev = abbrevs[hash_number];
793 if (abbrev->number == number)
796 abbrev = abbrev->next;
802 /* In DWARF version 2, the description of the debugging information is
803 stored in a separate .debug_abbrev section. Before we read any
804 dies from a section we read in all abbreviations and install them
807 static struct abbrev_info**
808 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
810 struct abbrev_info **abbrevs;
811 bfd_byte *abbrev_ptr;
812 struct abbrev_info *cur_abbrev;
813 unsigned int abbrev_number, bytes_read, abbrev_name;
814 unsigned int abbrev_form, hash_number;
817 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
819 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
822 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
823 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
827 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
828 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
829 abbrev_ptr += bytes_read;
831 /* Loop until we reach an abbrev number of 0. */
832 while (abbrev_number)
834 amt = sizeof (struct abbrev_info);
835 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
836 if (cur_abbrev == NULL)
839 /* Read in abbrev header. */
840 cur_abbrev->number = abbrev_number;
841 cur_abbrev->tag = (enum dwarf_tag)
842 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
843 abbrev_ptr += bytes_read;
844 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
847 /* Now read in declarations. */
848 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
849 abbrev_ptr += bytes_read;
850 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
851 abbrev_ptr += bytes_read;
855 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
857 struct attr_abbrev *tmp;
859 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
860 amt *= sizeof (struct attr_abbrev);
861 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
866 for (i = 0; i < ABBREV_HASH_SIZE; i++)
868 struct abbrev_info *abbrev = abbrevs[i];
872 free (abbrev->attrs);
873 abbrev = abbrev->next;
878 cur_abbrev->attrs = tmp;
881 cur_abbrev->attrs[cur_abbrev->num_attrs].name
882 = (enum dwarf_attribute) abbrev_name;
883 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
884 = (enum dwarf_form) abbrev_form;
885 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
886 abbrev_ptr += bytes_read;
887 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
888 abbrev_ptr += bytes_read;
891 hash_number = abbrev_number % ABBREV_HASH_SIZE;
892 cur_abbrev->next = abbrevs[hash_number];
893 abbrevs[hash_number] = cur_abbrev;
895 /* Get next abbreviation.
896 Under Irix6 the abbreviations for a compilation unit are not
897 always properly terminated with an abbrev number of 0.
898 Exit loop if we encounter an abbreviation which we have
899 already read (which means we are about to read the abbreviations
900 for the next compile unit) or if the end of the abbreviation
902 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
903 >= stash->dwarf_abbrev_size)
905 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
906 abbrev_ptr += bytes_read;
907 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
914 /* Read an attribute value described by an attribute form. */
917 read_attribute_value (struct attribute *attr,
919 struct comp_unit *unit,
922 bfd *abfd = unit->abfd;
923 unsigned int bytes_read;
924 struct dwarf_block *blk;
927 attr->form = (enum dwarf_form) form;
931 case DW_FORM_ref_addr:
932 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
934 if (unit->version == 3 || unit->version == 4)
936 if (unit->offset_size == 4)
937 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
939 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
940 info_ptr += unit->offset_size;
945 attr->u.val = read_address (unit, info_ptr);
946 info_ptr += unit->addr_size;
948 case DW_FORM_GNU_ref_alt:
949 case DW_FORM_sec_offset:
950 if (unit->offset_size == 4)
951 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
953 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
954 info_ptr += unit->offset_size;
957 amt = sizeof (struct dwarf_block);
958 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
961 blk->size = read_2_bytes (abfd, info_ptr);
963 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
964 info_ptr += blk->size;
968 amt = sizeof (struct dwarf_block);
969 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
972 blk->size = read_4_bytes (abfd, info_ptr);
974 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
975 info_ptr += blk->size;
979 attr->u.val = read_2_bytes (abfd, info_ptr);
983 attr->u.val = read_4_bytes (abfd, info_ptr);
987 attr->u.val = read_8_bytes (abfd, info_ptr);
991 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
992 info_ptr += bytes_read;
995 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
996 info_ptr += bytes_read;
998 case DW_FORM_GNU_strp_alt:
999 attr->u.str = read_alt_indirect_string (unit, info_ptr, &bytes_read);
1000 info_ptr += bytes_read;
1002 case DW_FORM_exprloc:
1004 amt = sizeof (struct dwarf_block);
1005 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1008 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1009 info_ptr += bytes_read;
1010 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
1011 info_ptr += blk->size;
1014 case DW_FORM_block1:
1015 amt = sizeof (struct dwarf_block);
1016 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1019 blk->size = read_1_byte (abfd, info_ptr);
1021 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
1022 info_ptr += blk->size;
1026 attr->u.val = read_1_byte (abfd, info_ptr);
1030 attr->u.val = read_1_byte (abfd, info_ptr);
1033 case DW_FORM_flag_present:
1037 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
1038 info_ptr += bytes_read;
1041 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1042 info_ptr += bytes_read;
1045 attr->u.val = read_1_byte (abfd, info_ptr);
1049 attr->u.val = read_2_bytes (abfd, info_ptr);
1053 attr->u.val = read_4_bytes (abfd, info_ptr);
1057 attr->u.val = read_8_bytes (abfd, info_ptr);
1060 case DW_FORM_ref_sig8:
1061 attr->u.val = read_8_bytes (abfd, info_ptr);
1064 case DW_FORM_ref_udata:
1065 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1066 info_ptr += bytes_read;
1068 case DW_FORM_indirect:
1069 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1070 info_ptr += bytes_read;
1071 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
1074 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1076 bfd_set_error (bfd_error_bad_value);
1082 /* Read an attribute described by an abbreviated attribute. */
1085 read_attribute (struct attribute *attr,
1086 struct attr_abbrev *abbrev,
1087 struct comp_unit *unit,
1090 attr->name = abbrev->name;
1091 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
1095 /* Source line information table routines. */
1097 #define FILE_ALLOC_CHUNK 5
1098 #define DIR_ALLOC_CHUNK 5
1102 struct line_info* prev_line;
1106 unsigned int column;
1107 unsigned int discriminator;
1108 unsigned char op_index;
1109 unsigned char end_sequence; /* End of (sequential) code sequence. */
1120 struct line_sequence
1123 struct line_sequence* prev_sequence;
1124 struct line_info* last_line; /* Largest VMA. */
1127 struct line_info_table
1130 unsigned int num_files;
1131 unsigned int num_dirs;
1132 unsigned int num_sequences;
1135 struct fileinfo* files;
1136 struct line_sequence* sequences;
1137 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1140 /* Remember some information about each function. If the function is
1141 inlined (DW_TAG_inlined_subroutine) it may have two additional
1142 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1143 source code location where this function was inlined. */
1147 /* Pointer to previous function in list of all functions. */
1148 struct funcinfo *prev_func;
1149 /* Pointer to function one scope higher. */
1150 struct funcinfo *caller_func;
1151 /* Source location file name where caller_func inlines this func. */
1153 /* Source location line number where caller_func inlines this func. */
1155 /* Source location file name. */
1157 /* Source location line number. */
1161 struct arange arange;
1162 /* Where the symbol is defined. */
1168 /* Pointer to previous variable in list of all variables */
1169 struct varinfo *prev_var;
1170 /* Source location file name */
1172 /* Source location line number */
1177 /* Where the symbol is defined */
1179 /* Is this a stack variable? */
1180 unsigned int stack: 1;
1183 /* Return TRUE if NEW_LINE should sort after LINE. */
1185 static inline bfd_boolean
1186 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1188 return (new_line->address > line->address
1189 || (new_line->address == line->address
1190 && (new_line->op_index > line->op_index
1191 || (new_line->op_index == line->op_index
1192 && new_line->end_sequence < line->end_sequence))));
1196 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1197 that the list is sorted. Note that the line_info list is sorted from
1198 highest to lowest VMA (with possible duplicates); that is,
1199 line_info->prev_line always accesses an equal or smaller VMA. */
1202 add_line_info (struct line_info_table *table,
1204 unsigned char op_index,
1207 unsigned int column,
1208 unsigned int discriminator,
1211 bfd_size_type amt = sizeof (struct line_info);
1212 struct line_sequence* seq = table->sequences;
1213 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1218 /* Set member data of 'info'. */
1219 info->prev_line = NULL;
1220 info->address = address;
1221 info->op_index = op_index;
1223 info->column = column;
1224 info->discriminator = discriminator;
1225 info->end_sequence = end_sequence;
1227 if (filename && filename[0])
1229 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1230 if (info->filename == NULL)
1232 strcpy (info->filename, filename);
1235 info->filename = NULL;
1237 /* Find the correct location for 'info'. Normally we will receive
1238 new line_info data 1) in order and 2) with increasing VMAs.
1239 However some compilers break the rules (cf. decode_line_info) and
1240 so we include some heuristics for quickly finding the correct
1241 location for 'info'. In particular, these heuristics optimize for
1242 the common case in which the VMA sequence that we receive is a
1243 list of locally sorted VMAs such as
1244 p...z a...j (where a < j < p < z)
1246 Note: table->lcl_head is used to head an *actual* or *possible*
1247 sub-sequence within the list (such as a...j) that is not directly
1248 headed by table->last_line
1250 Note: we may receive duplicate entries from 'decode_line_info'. */
1253 && seq->last_line->address == address
1254 && seq->last_line->op_index == op_index
1255 && seq->last_line->end_sequence == end_sequence)
1257 /* We only keep the last entry with the same address and end
1258 sequence. See PR ld/4986. */
1259 if (table->lcl_head == seq->last_line)
1260 table->lcl_head = info;
1261 info->prev_line = seq->last_line->prev_line;
1262 seq->last_line = info;
1264 else if (!seq || seq->last_line->end_sequence)
1266 /* Start a new line sequence. */
1267 amt = sizeof (struct line_sequence);
1268 seq = (struct line_sequence *) bfd_malloc (amt);
1271 seq->low_pc = address;
1272 seq->prev_sequence = table->sequences;
1273 seq->last_line = info;
1274 table->lcl_head = info;
1275 table->sequences = seq;
1276 table->num_sequences++;
1278 else if (new_line_sorts_after (info, seq->last_line))
1280 /* Normal case: add 'info' to the beginning of the current sequence. */
1281 info->prev_line = seq->last_line;
1282 seq->last_line = info;
1284 /* lcl_head: initialize to head a *possible* sequence at the end. */
1285 if (!table->lcl_head)
1286 table->lcl_head = info;
1288 else if (!new_line_sorts_after (info, table->lcl_head)
1289 && (!table->lcl_head->prev_line
1290 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1292 /* Abnormal but easy: lcl_head is the head of 'info'. */
1293 info->prev_line = table->lcl_head->prev_line;
1294 table->lcl_head->prev_line = info;
1298 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1299 are valid heads for 'info'. Reset 'lcl_head'. */
1300 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1301 struct line_info* li1 = li2->prev_line;
1305 if (!new_line_sorts_after (info, li2)
1306 && new_line_sorts_after (info, li1))
1309 li2 = li1; /* always non-NULL */
1310 li1 = li1->prev_line;
1312 table->lcl_head = li2;
1313 info->prev_line = table->lcl_head->prev_line;
1314 table->lcl_head->prev_line = info;
1315 if (address < seq->low_pc)
1316 seq->low_pc = address;
1321 /* Extract a fully qualified filename from a line info table.
1322 The returned string has been malloc'ed and it is the caller's
1323 responsibility to free it. */
1326 concat_filename (struct line_info_table *table, unsigned int file)
1330 if (file - 1 >= table->num_files)
1332 /* FILE == 0 means unknown. */
1334 (*_bfd_error_handler)
1335 (_("Dwarf Error: mangled line number section (bad file number)."));
1336 return strdup ("<unknown>");
1339 filename = table->files[file - 1].name;
1341 if (!IS_ABSOLUTE_PATH (filename))
1343 char *dir_name = NULL;
1344 char *subdir_name = NULL;
1348 if (table->files[file - 1].dir)
1349 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1351 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1352 dir_name = table->comp_dir;
1356 dir_name = subdir_name;
1361 return strdup (filename);
1363 len = strlen (dir_name) + strlen (filename) + 2;
1367 len += strlen (subdir_name) + 1;
1368 name = (char *) bfd_malloc (len);
1370 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1374 name = (char *) bfd_malloc (len);
1376 sprintf (name, "%s/%s", dir_name, filename);
1382 return strdup (filename);
1386 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1387 bfd_vma low_pc, bfd_vma high_pc)
1389 struct arange *arange;
1391 /* Ignore empty ranges. */
1392 if (low_pc == high_pc)
1395 /* If the first arange is empty, use it. */
1396 if (first_arange->high == 0)
1398 first_arange->low = low_pc;
1399 first_arange->high = high_pc;
1403 /* Next see if we can cheaply extend an existing range. */
1404 arange = first_arange;
1407 if (low_pc == arange->high)
1409 arange->high = high_pc;
1412 if (high_pc == arange->low)
1414 arange->low = low_pc;
1417 arange = arange->next;
1421 /* Need to allocate a new arange and insert it into the arange list.
1422 Order isn't significant, so just insert after the first arange. */
1423 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1426 arange->low = low_pc;
1427 arange->high = high_pc;
1428 arange->next = first_arange->next;
1429 first_arange->next = arange;
1433 /* Compare function for line sequences. */
1436 compare_sequences (const void* a, const void* b)
1438 const struct line_sequence* seq1 = a;
1439 const struct line_sequence* seq2 = b;
1441 /* Sort by low_pc as the primary key. */
1442 if (seq1->low_pc < seq2->low_pc)
1444 if (seq1->low_pc > seq2->low_pc)
1447 /* If low_pc values are equal, sort in reverse order of
1448 high_pc, so that the largest region comes first. */
1449 if (seq1->last_line->address < seq2->last_line->address)
1451 if (seq1->last_line->address > seq2->last_line->address)
1454 if (seq1->last_line->op_index < seq2->last_line->op_index)
1456 if (seq1->last_line->op_index > seq2->last_line->op_index)
1462 /* Sort the line sequences for quick lookup. */
1465 sort_line_sequences (struct line_info_table* table)
1468 struct line_sequence* sequences;
1469 struct line_sequence* seq;
1471 unsigned int num_sequences = table->num_sequences;
1472 bfd_vma last_high_pc;
1474 if (num_sequences == 0)
1477 /* Allocate space for an array of sequences. */
1478 amt = sizeof (struct line_sequence) * num_sequences;
1479 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1480 if (sequences == NULL)
1483 /* Copy the linked list into the array, freeing the original nodes. */
1484 seq = table->sequences;
1485 for (n = 0; n < num_sequences; n++)
1487 struct line_sequence* last_seq = seq;
1490 sequences[n].low_pc = seq->low_pc;
1491 sequences[n].prev_sequence = NULL;
1492 sequences[n].last_line = seq->last_line;
1493 seq = seq->prev_sequence;
1496 BFD_ASSERT (seq == NULL);
1498 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1500 /* Make the list binary-searchable by trimming overlapping entries
1501 and removing nested entries. */
1503 last_high_pc = sequences[0].last_line->address;
1504 for (n = 1; n < table->num_sequences; n++)
1506 if (sequences[n].low_pc < last_high_pc)
1508 if (sequences[n].last_line->address <= last_high_pc)
1509 /* Skip nested entries. */
1512 /* Trim overlapping entries. */
1513 sequences[n].low_pc = last_high_pc;
1515 last_high_pc = sequences[n].last_line->address;
1516 if (n > num_sequences)
1518 /* Close up the gap. */
1519 sequences[num_sequences].low_pc = sequences[n].low_pc;
1520 sequences[num_sequences].last_line = sequences[n].last_line;
1525 table->sequences = sequences;
1526 table->num_sequences = num_sequences;
1530 /* Decode the line number information for UNIT. */
1532 static struct line_info_table*
1533 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1535 bfd *abfd = unit->abfd;
1536 struct line_info_table* table;
1539 struct line_head lh;
1540 unsigned int i, bytes_read, offset_size;
1541 char *cur_file, *cur_dir;
1542 unsigned char op_code, extended_op, adj_opcode;
1543 unsigned int exop_len;
1546 if (! read_section (abfd, &stash->debug_sections[debug_line],
1547 stash->syms, unit->line_offset,
1548 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1551 amt = sizeof (struct line_info_table);
1552 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1556 table->comp_dir = unit->comp_dir;
1558 table->num_files = 0;
1559 table->files = NULL;
1561 table->num_dirs = 0;
1564 table->num_sequences = 0;
1565 table->sequences = NULL;
1567 table->lcl_head = NULL;
1569 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1571 /* Read in the prologue. */
1572 lh.total_length = read_4_bytes (abfd, line_ptr);
1575 if (lh.total_length == 0xffffffff)
1577 lh.total_length = read_8_bytes (abfd, line_ptr);
1581 else if (lh.total_length == 0 && unit->addr_size == 8)
1583 /* Handle (non-standard) 64-bit DWARF2 formats. */
1584 lh.total_length = read_4_bytes (abfd, line_ptr);
1588 line_end = line_ptr + lh.total_length;
1589 lh.version = read_2_bytes (abfd, line_ptr);
1590 if (lh.version < 2 || lh.version > 4)
1592 (*_bfd_error_handler)
1593 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1594 bfd_set_error (bfd_error_bad_value);
1598 if (offset_size == 4)
1599 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1601 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1602 line_ptr += offset_size;
1603 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1605 if (lh.version >= 4)
1607 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr);
1611 lh.maximum_ops_per_insn = 1;
1612 if (lh.maximum_ops_per_insn == 0)
1614 (*_bfd_error_handler)
1615 (_("Dwarf Error: Invalid maximum operations per instruction."));
1616 bfd_set_error (bfd_error_bad_value);
1619 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1621 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1623 lh.line_range = read_1_byte (abfd, line_ptr);
1625 lh.opcode_base = read_1_byte (abfd, line_ptr);
1627 amt = lh.opcode_base * sizeof (unsigned char);
1628 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1630 lh.standard_opcode_lengths[0] = 1;
1632 for (i = 1; i < lh.opcode_base; ++i)
1634 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1638 /* Read directory table. */
1639 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1641 line_ptr += bytes_read;
1643 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1647 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1648 amt *= sizeof (char *);
1650 tmp = (char **) bfd_realloc (table->dirs, amt);
1656 table->dirs[table->num_dirs++] = cur_dir;
1659 line_ptr += bytes_read;
1661 /* Read file name table. */
1662 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1664 line_ptr += bytes_read;
1666 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1668 struct fileinfo *tmp;
1670 amt = table->num_files + FILE_ALLOC_CHUNK;
1671 amt *= sizeof (struct fileinfo);
1673 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1679 table->files[table->num_files].name = cur_file;
1680 table->files[table->num_files].dir =
1681 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1682 line_ptr += bytes_read;
1683 table->files[table->num_files].time =
1684 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1685 line_ptr += bytes_read;
1686 table->files[table->num_files].size =
1687 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1688 line_ptr += bytes_read;
1692 line_ptr += bytes_read;
1694 /* Read the statement sequences until there's nothing left. */
1695 while (line_ptr < line_end)
1697 /* State machine registers. */
1698 bfd_vma address = 0;
1699 unsigned char op_index = 0;
1700 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1701 unsigned int line = 1;
1702 unsigned int column = 0;
1703 unsigned int discriminator = 0;
1704 int is_stmt = lh.default_is_stmt;
1705 int end_sequence = 0;
1706 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1707 compilers generate address sequences that are wildly out of
1708 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1709 for ia64-Linux). Thus, to determine the low and high
1710 address, we must compare on every DW_LNS_copy, etc. */
1711 bfd_vma low_pc = (bfd_vma) -1;
1712 bfd_vma high_pc = 0;
1714 /* Decode the table. */
1715 while (! end_sequence)
1717 op_code = read_1_byte (abfd, line_ptr);
1720 if (op_code >= lh.opcode_base)
1722 /* Special operand. */
1723 adj_opcode = op_code - lh.opcode_base;
1724 if (lh.maximum_ops_per_insn == 1)
1725 address += (adj_opcode / lh.line_range
1726 * lh.minimum_instruction_length);
1729 address += ((op_index + adj_opcode / lh.line_range)
1730 / lh.maximum_ops_per_insn
1731 * lh.minimum_instruction_length);
1732 op_index = ((op_index + adj_opcode / lh.line_range)
1733 % lh.maximum_ops_per_insn);
1735 line += lh.line_base + (adj_opcode % lh.line_range);
1736 /* Append row to matrix using current values. */
1737 if (!add_line_info (table, address, op_index, filename,
1738 line, column, discriminator, 0))
1741 if (address < low_pc)
1743 if (address > high_pc)
1746 else switch (op_code)
1748 case DW_LNS_extended_op:
1749 exop_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1750 line_ptr += bytes_read;
1751 extended_op = read_1_byte (abfd, line_ptr);
1754 switch (extended_op)
1756 case DW_LNE_end_sequence:
1758 if (!add_line_info (table, address, op_index, filename, line,
1759 column, discriminator, end_sequence))
1762 if (address < low_pc)
1764 if (address > high_pc)
1766 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
1769 case DW_LNE_set_address:
1770 address = read_address (unit, line_ptr);
1772 line_ptr += unit->addr_size;
1774 case DW_LNE_define_file:
1775 cur_file = read_string (abfd, line_ptr, &bytes_read);
1776 line_ptr += bytes_read;
1777 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1779 struct fileinfo *tmp;
1781 amt = table->num_files + FILE_ALLOC_CHUNK;
1782 amt *= sizeof (struct fileinfo);
1783 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1788 table->files[table->num_files].name = cur_file;
1789 table->files[table->num_files].dir =
1790 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1791 line_ptr += bytes_read;
1792 table->files[table->num_files].time =
1793 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1794 line_ptr += bytes_read;
1795 table->files[table->num_files].size =
1796 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1797 line_ptr += bytes_read;
1800 case DW_LNE_set_discriminator:
1802 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1803 line_ptr += bytes_read;
1805 case DW_LNE_HP_source_file_correlation:
1806 line_ptr += exop_len - 1;
1809 (*_bfd_error_handler)
1810 (_("Dwarf Error: mangled line number section."));
1811 bfd_set_error (bfd_error_bad_value);
1813 if (filename != NULL)
1819 if (!add_line_info (table, address, op_index,
1820 filename, line, column, discriminator, 0))
1823 if (address < low_pc)
1825 if (address > high_pc)
1828 case DW_LNS_advance_pc:
1829 if (lh.maximum_ops_per_insn == 1)
1830 address += (lh.minimum_instruction_length
1831 * read_unsigned_leb128 (abfd, line_ptr,
1835 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
1837 address = ((op_index + adjust) / lh.maximum_ops_per_insn
1838 * lh.minimum_instruction_length);
1839 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1841 line_ptr += bytes_read;
1843 case DW_LNS_advance_line:
1844 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1845 line_ptr += bytes_read;
1847 case DW_LNS_set_file:
1851 /* The file and directory tables are 0
1852 based, the references are 1 based. */
1853 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1854 line_ptr += bytes_read;
1857 filename = concat_filename (table, file);
1860 case DW_LNS_set_column:
1861 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1862 line_ptr += bytes_read;
1864 case DW_LNS_negate_stmt:
1865 is_stmt = (!is_stmt);
1867 case DW_LNS_set_basic_block:
1869 case DW_LNS_const_add_pc:
1870 if (lh.maximum_ops_per_insn == 1)
1871 address += (lh.minimum_instruction_length
1872 * ((255 - lh.opcode_base) / lh.line_range));
1875 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
1876 address += (lh.minimum_instruction_length
1877 * ((op_index + adjust)
1878 / lh.maximum_ops_per_insn));
1879 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1882 case DW_LNS_fixed_advance_pc:
1883 address += read_2_bytes (abfd, line_ptr);
1888 /* Unknown standard opcode, ignore it. */
1889 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1891 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1892 line_ptr += bytes_read;
1902 if (sort_line_sequences (table))
1906 if (table->sequences != NULL)
1907 free (table->sequences);
1908 if (table->files != NULL)
1909 free (table->files);
1910 if (table->dirs != NULL)
1915 /* If ADDR is within TABLE set the output parameters and return the
1916 range of addresses covered by the entry used to fill them out.
1917 Otherwise set * FILENAME_PTR to NULL and return 0.
1918 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
1919 are pointers to the objects to be filled in. */
1922 lookup_address_in_line_info_table (struct line_info_table *table,
1924 const char **filename_ptr,
1925 unsigned int *linenumber_ptr,
1926 unsigned int *discriminator_ptr)
1928 struct line_sequence *seq = NULL;
1929 struct line_info *each_line;
1932 /* Binary search the array of sequences. */
1934 high = table->num_sequences;
1937 mid = (low + high) / 2;
1938 seq = &table->sequences[mid];
1939 if (addr < seq->low_pc)
1941 else if (addr >= seq->last_line->address)
1947 if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
1949 /* Note: seq->last_line should be a descendingly sorted list. */
1950 for (each_line = seq->last_line;
1952 each_line = each_line->prev_line)
1953 if (addr >= each_line->address)
1957 && !(each_line->end_sequence || each_line == seq->last_line))
1959 *filename_ptr = each_line->filename;
1960 *linenumber_ptr = each_line->line;
1961 if (discriminator_ptr)
1962 *discriminator_ptr = each_line->discriminator;
1963 return seq->last_line->address - seq->low_pc;
1967 *filename_ptr = NULL;
1971 /* Read in the .debug_ranges section for future reference. */
1974 read_debug_ranges (struct comp_unit *unit)
1976 struct dwarf2_debug *stash = unit->stash;
1977 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
1979 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
1982 /* Function table functions. */
1984 /* If ADDR is within UNIT's function tables, set FUNCTIONNAME_PTR, and return
1985 TRUE. Note that we need to find the function that has the smallest range
1986 that contains ADDR, to handle inlined functions without depending upon
1987 them being ordered in TABLE by increasing range. */
1990 lookup_address_in_function_table (struct comp_unit *unit,
1992 struct funcinfo **function_ptr,
1993 const char **functionname_ptr)
1995 struct funcinfo* each_func;
1996 struct funcinfo* best_fit = NULL;
1997 struct arange *arange;
1999 for (each_func = unit->function_table;
2001 each_func = each_func->prev_func)
2003 for (arange = &each_func->arange;
2005 arange = arange->next)
2007 if (addr >= arange->low && addr < arange->high)
2010 || (arange->high - arange->low
2011 < best_fit->arange.high - best_fit->arange.low))
2012 best_fit = each_func;
2019 *functionname_ptr = best_fit->name;
2020 *function_ptr = best_fit;
2029 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2030 and LINENUMBER_PTR, and return TRUE. */
2033 lookup_symbol_in_function_table (struct comp_unit *unit,
2036 const char **filename_ptr,
2037 unsigned int *linenumber_ptr)
2039 struct funcinfo* each_func;
2040 struct funcinfo* best_fit = NULL;
2041 struct arange *arange;
2042 const char *name = bfd_asymbol_name (sym);
2043 asection *sec = bfd_get_section (sym);
2045 for (each_func = unit->function_table;
2047 each_func = each_func->prev_func)
2049 for (arange = &each_func->arange;
2051 arange = arange->next)
2053 if ((!each_func->sec || each_func->sec == sec)
2054 && addr >= arange->low
2055 && addr < arange->high
2057 && strcmp (name, each_func->name) == 0
2059 || (arange->high - arange->low
2060 < best_fit->arange.high - best_fit->arange.low)))
2061 best_fit = each_func;
2067 best_fit->sec = sec;
2068 *filename_ptr = best_fit->file;
2069 *linenumber_ptr = best_fit->line;
2076 /* Variable table functions. */
2078 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2079 LINENUMBER_PTR, and return TRUE. */
2082 lookup_symbol_in_variable_table (struct comp_unit *unit,
2085 const char **filename_ptr,
2086 unsigned int *linenumber_ptr)
2088 const char *name = bfd_asymbol_name (sym);
2089 asection *sec = bfd_get_section (sym);
2090 struct varinfo* each;
2092 for (each = unit->variable_table; each; each = each->prev_var)
2093 if (each->stack == 0
2094 && each->file != NULL
2095 && each->name != NULL
2096 && each->addr == addr
2097 && (!each->sec || each->sec == sec)
2098 && strcmp (name, each->name) == 0)
2104 *filename_ptr = each->file;
2105 *linenumber_ptr = each->line;
2113 find_abstract_instance_name (struct comp_unit *unit,
2114 struct attribute *attr_ptr)
2116 bfd *abfd = unit->abfd;
2118 unsigned int abbrev_number, bytes_read, i;
2119 struct abbrev_info *abbrev;
2120 bfd_uint64_t die_ref = attr_ptr->u.val;
2121 struct attribute attr;
2124 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2125 is an offset from the .debug_info section, not the current CU. */
2126 if (attr_ptr->form == DW_FORM_ref_addr)
2128 /* We only support DW_FORM_ref_addr within the same file, so
2129 any relocations should be resolved already. */
2133 info_ptr = unit->sec_info_ptr + die_ref;
2135 /* Now find the CU containing this pointer. */
2136 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2140 /* Check other CUs to see if they contain the abbrev. */
2141 struct comp_unit * u;
2143 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2144 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2148 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2149 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2154 /* else FIXME: What do we do now ? */
2157 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2159 info_ptr = read_alt_indirect_ref (unit, die_ref);
2160 if (info_ptr == NULL)
2162 (*_bfd_error_handler)
2163 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2164 bfd_set_error (bfd_error_bad_value);
2167 /* FIXME: Do we need to locate the correct CU, in a similar
2168 fashion to the code in the DW_FORM_ref_addr case above ? */
2171 info_ptr = unit->info_ptr_unit + die_ref;
2173 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2174 info_ptr += bytes_read;
2178 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2181 (*_bfd_error_handler)
2182 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2183 bfd_set_error (bfd_error_bad_value);
2187 for (i = 0; i < abbrev->num_attrs; ++i)
2189 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2191 if (info_ptr == NULL)
2196 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2201 case DW_AT_specification:
2202 name = find_abstract_instance_name (unit, &attr);
2204 case DW_AT_linkage_name:
2205 case DW_AT_MIPS_linkage_name:
2218 read_rangelist (struct comp_unit *unit, struct arange *arange,
2219 bfd_uint64_t offset)
2221 bfd_byte *ranges_ptr;
2222 bfd_vma base_address = unit->base_address;
2224 if (! unit->stash->dwarf_ranges_buffer)
2226 if (! read_debug_ranges (unit))
2229 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2236 low_pc = read_address (unit, ranges_ptr);
2237 ranges_ptr += unit->addr_size;
2238 high_pc = read_address (unit, ranges_ptr);
2239 ranges_ptr += unit->addr_size;
2241 if (low_pc == 0 && high_pc == 0)
2243 if (low_pc == -1UL && high_pc != -1UL)
2244 base_address = high_pc;
2247 if (!arange_add (unit, arange,
2248 base_address + low_pc, base_address + high_pc))
2255 /* DWARF2 Compilation unit functions. */
2257 /* Scan over each die in a comp. unit looking for functions to add
2258 to the function table and variables to the variable table. */
2261 scan_unit_for_symbols (struct comp_unit *unit)
2263 bfd *abfd = unit->abfd;
2264 bfd_byte *info_ptr = unit->first_child_die_ptr;
2265 int nesting_level = 1;
2266 struct funcinfo **nested_funcs;
2267 int nested_funcs_size;
2269 /* Maintain a stack of in-scope functions and inlined functions, which we
2270 can use to set the caller_func field. */
2271 nested_funcs_size = 32;
2272 nested_funcs = (struct funcinfo **)
2273 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2274 if (nested_funcs == NULL)
2276 nested_funcs[nesting_level] = 0;
2278 while (nesting_level)
2280 unsigned int abbrev_number, bytes_read, i;
2281 struct abbrev_info *abbrev;
2282 struct attribute attr;
2283 struct funcinfo *func;
2284 struct varinfo *var;
2286 bfd_vma high_pc = 0;
2287 bfd_boolean high_pc_relative = FALSE;
2289 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2290 info_ptr += bytes_read;
2292 if (! abbrev_number)
2298 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2301 (*_bfd_error_handler)
2302 (_("Dwarf Error: Could not find abbrev number %u."),
2304 bfd_set_error (bfd_error_bad_value);
2309 if (abbrev->tag == DW_TAG_subprogram
2310 || abbrev->tag == DW_TAG_entry_point
2311 || abbrev->tag == DW_TAG_inlined_subroutine)
2313 bfd_size_type amt = sizeof (struct funcinfo);
2314 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2317 func->tag = abbrev->tag;
2318 func->prev_func = unit->function_table;
2319 unit->function_table = func;
2320 BFD_ASSERT (!unit->cached);
2322 if (func->tag == DW_TAG_inlined_subroutine)
2323 for (i = nesting_level - 1; i >= 1; i--)
2324 if (nested_funcs[i])
2326 func->caller_func = nested_funcs[i];
2329 nested_funcs[nesting_level] = func;
2334 if (abbrev->tag == DW_TAG_variable)
2336 bfd_size_type amt = sizeof (struct varinfo);
2337 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2340 var->tag = abbrev->tag;
2342 var->prev_var = unit->variable_table;
2343 unit->variable_table = var;
2344 BFD_ASSERT (!unit->cached);
2347 /* No inline function in scope at this nesting level. */
2348 nested_funcs[nesting_level] = 0;
2351 for (i = 0; i < abbrev->num_attrs; ++i)
2353 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2354 if (info_ptr == NULL)
2361 case DW_AT_call_file:
2362 func->caller_file = concat_filename (unit->line_table,
2366 case DW_AT_call_line:
2367 func->caller_line = attr.u.val;
2370 case DW_AT_abstract_origin:
2371 case DW_AT_specification:
2372 func->name = find_abstract_instance_name (unit, &attr);
2376 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2378 if (func->name == NULL)
2379 func->name = attr.u.str;
2382 case DW_AT_linkage_name:
2383 case DW_AT_MIPS_linkage_name:
2384 func->name = attr.u.str;
2388 low_pc = attr.u.val;
2392 high_pc = attr.u.val;
2393 high_pc_relative = attr.form != DW_FORM_addr;
2397 if (!read_rangelist (unit, &func->arange, attr.u.val))
2401 case DW_AT_decl_file:
2402 func->file = concat_filename (unit->line_table,
2406 case DW_AT_decl_line:
2407 func->line = attr.u.val;
2419 var->name = attr.u.str;
2422 case DW_AT_decl_file:
2423 var->file = concat_filename (unit->line_table,
2427 case DW_AT_decl_line:
2428 var->line = attr.u.val;
2431 case DW_AT_external:
2432 if (attr.u.val != 0)
2436 case DW_AT_location:
2440 case DW_FORM_block1:
2441 case DW_FORM_block2:
2442 case DW_FORM_block4:
2443 case DW_FORM_exprloc:
2444 if (*attr.u.blk->data == DW_OP_addr)
2448 /* Verify that DW_OP_addr is the only opcode in the
2449 location, in which case the block size will be 1
2450 plus the address size. */
2451 /* ??? For TLS variables, gcc can emit
2452 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2453 which we don't handle here yet. */
2454 if (attr.u.blk->size == unit->addr_size + 1U)
2455 var->addr = bfd_get (unit->addr_size * 8,
2457 attr.u.blk->data + 1);
2472 if (high_pc_relative)
2475 if (func && high_pc != 0)
2477 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2481 if (abbrev->has_children)
2485 if (nesting_level >= nested_funcs_size)
2487 struct funcinfo **tmp;
2489 nested_funcs_size *= 2;
2490 tmp = (struct funcinfo **)
2491 bfd_realloc (nested_funcs,
2492 nested_funcs_size * sizeof (struct funcinfo *));
2497 nested_funcs[nesting_level] = 0;
2501 free (nested_funcs);
2505 free (nested_funcs);
2509 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2510 includes the compilation unit header that proceeds the DIE's, but
2511 does not include the length field that precedes each compilation
2512 unit header. END_PTR points one past the end of this comp unit.
2513 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2515 This routine does not read the whole compilation unit; only enough
2516 to get to the line number information for the compilation unit. */
2518 static struct comp_unit *
2519 parse_comp_unit (struct dwarf2_debug *stash,
2520 bfd_vma unit_length,
2521 bfd_byte *info_ptr_unit,
2522 unsigned int offset_size)
2524 struct comp_unit* unit;
2525 unsigned int version;
2526 bfd_uint64_t abbrev_offset = 0;
2527 unsigned int addr_size;
2528 struct abbrev_info** abbrevs;
2529 unsigned int abbrev_number, bytes_read, i;
2530 struct abbrev_info *abbrev;
2531 struct attribute attr;
2532 bfd_byte *info_ptr = stash->info_ptr;
2533 bfd_byte *end_ptr = info_ptr + unit_length;
2536 bfd_vma high_pc = 0;
2537 bfd *abfd = stash->bfd_ptr;
2538 bfd_boolean high_pc_relative = FALSE;
2540 version = read_2_bytes (abfd, info_ptr);
2542 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2543 if (offset_size == 4)
2544 abbrev_offset = read_4_bytes (abfd, info_ptr);
2546 abbrev_offset = read_8_bytes (abfd, info_ptr);
2547 info_ptr += offset_size;
2548 addr_size = read_1_byte (abfd, info_ptr);
2551 if (version != 2 && version != 3 && version != 4)
2553 (*_bfd_error_handler)
2554 (_("Dwarf Error: found dwarf version '%u', this reader"
2555 " only handles version 2, 3 and 4 information."), version);
2556 bfd_set_error (bfd_error_bad_value);
2560 if (addr_size > sizeof (bfd_vma))
2562 (*_bfd_error_handler)
2563 (_("Dwarf Error: found address size '%u', this reader"
2564 " can not handle sizes greater than '%u'."),
2566 (unsigned int) sizeof (bfd_vma));
2567 bfd_set_error (bfd_error_bad_value);
2571 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2573 (*_bfd_error_handler)
2574 ("Dwarf Error: found address size '%u', this reader"
2575 " can only handle address sizes '2', '4' and '8'.", addr_size);
2576 bfd_set_error (bfd_error_bad_value);
2580 /* Read the abbrevs for this compilation unit into a table. */
2581 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2585 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2586 info_ptr += bytes_read;
2587 if (! abbrev_number)
2589 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2591 bfd_set_error (bfd_error_bad_value);
2595 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2598 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2600 bfd_set_error (bfd_error_bad_value);
2604 amt = sizeof (struct comp_unit);
2605 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2609 unit->version = version;
2610 unit->addr_size = addr_size;
2611 unit->offset_size = offset_size;
2612 unit->abbrevs = abbrevs;
2613 unit->end_ptr = end_ptr;
2614 unit->stash = stash;
2615 unit->info_ptr_unit = info_ptr_unit;
2616 unit->sec_info_ptr = stash->sec_info_ptr;
2618 for (i = 0; i < abbrev->num_attrs; ++i)
2620 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2621 if (info_ptr == NULL)
2624 /* Store the data if it is of an attribute we want to keep in a
2625 partial symbol table. */
2628 case DW_AT_stmt_list:
2630 unit->line_offset = attr.u.val;
2634 unit->name = attr.u.str;
2638 low_pc = attr.u.val;
2639 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2640 this is the base address to use when reading location
2641 lists or range lists. */
2642 if (abbrev->tag == DW_TAG_compile_unit)
2643 unit->base_address = low_pc;
2647 high_pc = attr.u.val;
2648 high_pc_relative = attr.form != DW_FORM_addr;
2652 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2656 case DW_AT_comp_dir:
2658 char *comp_dir = attr.u.str;
2661 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2662 directory, get rid of it. */
2663 char *cp = strchr (comp_dir, ':');
2665 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2668 unit->comp_dir = comp_dir;
2676 if (high_pc_relative)
2680 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2684 unit->first_child_die_ptr = info_ptr;
2688 /* Return TRUE if UNIT may contain the address given by ADDR. When
2689 there are functions written entirely with inline asm statements, the
2690 range info in the compilation unit header may not be correct. We
2691 need to consult the line info table to see if a compilation unit
2692 really contains the given address. */
2695 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2697 struct arange *arange;
2702 arange = &unit->arange;
2705 if (addr >= arange->low && addr < arange->high)
2707 arange = arange->next;
2714 /* If UNIT contains ADDR, set the output parameters to the values for
2715 the line containing ADDR. The output parameters, FILENAME_PTR,
2716 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2719 Returns the range of addresses covered by the entry that was used
2720 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2723 comp_unit_find_nearest_line (struct comp_unit *unit,
2725 const char **filename_ptr,
2726 const char **functionname_ptr,
2727 unsigned int *linenumber_ptr,
2728 unsigned int *discriminator_ptr,
2729 struct dwarf2_debug *stash)
2732 struct funcinfo *function;
2737 if (! unit->line_table)
2739 if (! unit->stmtlist)
2745 unit->line_table = decode_line_info (unit, stash);
2747 if (! unit->line_table)
2753 if (unit->first_child_die_ptr < unit->end_ptr
2754 && ! scan_unit_for_symbols (unit))
2762 func_p = lookup_address_in_function_table (unit, addr,
2763 &function, functionname_ptr);
2764 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2765 stash->inliner_chain = function;
2767 return lookup_address_in_line_info_table (unit->line_table, addr,
2773 /* Check to see if line info is already decoded in a comp_unit.
2774 If not, decode it. Returns TRUE if no errors were encountered;
2778 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2779 struct dwarf2_debug *stash)
2784 if (! unit->line_table)
2786 if (! unit->stmtlist)
2792 unit->line_table = decode_line_info (unit, stash);
2794 if (! unit->line_table)
2800 if (unit->first_child_die_ptr < unit->end_ptr
2801 && ! scan_unit_for_symbols (unit))
2811 /* If UNIT contains SYM at ADDR, set the output parameters to the
2812 values for the line containing SYM. The output parameters,
2813 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2816 Return TRUE if UNIT contains SYM, and no errors were encountered;
2820 comp_unit_find_line (struct comp_unit *unit,
2823 const char **filename_ptr,
2824 unsigned int *linenumber_ptr,
2825 struct dwarf2_debug *stash)
2827 if (!comp_unit_maybe_decode_line_info (unit, stash))
2830 if (sym->flags & BSF_FUNCTION)
2831 return lookup_symbol_in_function_table (unit, sym, addr,
2835 return lookup_symbol_in_variable_table (unit, sym, addr,
2840 static struct funcinfo *
2841 reverse_funcinfo_list (struct funcinfo *head)
2843 struct funcinfo *rhead;
2844 struct funcinfo *temp;
2846 for (rhead = NULL; head; head = temp)
2848 temp = head->prev_func;
2849 head->prev_func = rhead;
2855 static struct varinfo *
2856 reverse_varinfo_list (struct varinfo *head)
2858 struct varinfo *rhead;
2859 struct varinfo *temp;
2861 for (rhead = NULL; head; head = temp)
2863 temp = head->prev_var;
2864 head->prev_var = rhead;
2870 /* Extract all interesting funcinfos and varinfos of a compilation
2871 unit into hash tables for faster lookup. Returns TRUE if no
2872 errors were enountered; FALSE otherwise. */
2875 comp_unit_hash_info (struct dwarf2_debug *stash,
2876 struct comp_unit *unit,
2877 struct info_hash_table *funcinfo_hash_table,
2878 struct info_hash_table *varinfo_hash_table)
2880 struct funcinfo* each_func;
2881 struct varinfo* each_var;
2882 bfd_boolean okay = TRUE;
2884 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2886 if (!comp_unit_maybe_decode_line_info (unit, stash))
2889 BFD_ASSERT (!unit->cached);
2891 /* To preserve the original search order, we went to visit the function
2892 infos in the reversed order of the list. However, making the list
2893 bi-directional use quite a bit of extra memory. So we reverse
2894 the list first, traverse the list in the now reversed order and
2895 finally reverse the list again to get back the original order. */
2896 unit->function_table = reverse_funcinfo_list (unit->function_table);
2897 for (each_func = unit->function_table;
2899 each_func = each_func->prev_func)
2901 /* Skip nameless functions. */
2902 if (each_func->name)
2903 /* There is no need to copy name string into hash table as
2904 name string is either in the dwarf string buffer or
2905 info in the stash. */
2906 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2907 (void*) each_func, FALSE);
2909 unit->function_table = reverse_funcinfo_list (unit->function_table);
2913 /* We do the same for variable infos. */
2914 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2915 for (each_var = unit->variable_table;
2917 each_var = each_var->prev_var)
2919 /* Skip stack vars and vars with no files or names. */
2920 if (each_var->stack == 0
2921 && each_var->file != NULL
2922 && each_var->name != NULL)
2923 /* There is no need to copy name string into hash table as
2924 name string is either in the dwarf string buffer or
2925 info in the stash. */
2926 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2927 (void*) each_var, FALSE);
2930 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2931 unit->cached = TRUE;
2935 /* Locate a section in a BFD containing debugging info. The search starts
2936 from the section after AFTER_SEC, or from the first section in the BFD if
2937 AFTER_SEC is NULL. The search works by examining the names of the
2938 sections. There are three permissiable names. The first two are given
2939 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
2940 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
2941 This is a variation on the .debug_info section which has a checksum
2942 describing the contents appended onto the name. This allows the linker to
2943 identify and discard duplicate debugging sections for different
2944 compilation units. */
2945 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2948 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
2949 asection *after_sec)
2954 if (after_sec == NULL)
2956 look = debug_sections[debug_info].uncompressed_name;
2957 msec = bfd_get_section_by_name (abfd, look);
2961 look = debug_sections[debug_info].compressed_name;
2964 msec = bfd_get_section_by_name (abfd, look);
2969 for (msec = abfd->sections; msec != NULL; msec = msec->next)
2970 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2976 for (msec = after_sec->next; msec != NULL; msec = msec->next)
2978 look = debug_sections[debug_info].uncompressed_name;
2979 if (strcmp (msec->name, look) == 0)
2982 look = debug_sections[debug_info].compressed_name;
2983 if (look != NULL && strcmp (msec->name, look) == 0)
2986 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2993 /* Unset vmas for adjusted sections in STASH. */
2996 unset_sections (struct dwarf2_debug *stash)
2999 struct adjusted_section *p;
3001 i = stash->adjusted_section_count;
3002 p = stash->adjusted_sections;
3003 for (; i > 0; i--, p++)
3004 p->section->vma = 0;
3007 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
3008 VMAs in STASH for unset_sections. */
3011 place_sections (bfd *abfd, struct dwarf2_debug *stash)
3013 struct adjusted_section *p;
3016 if (stash->adjusted_section_count != 0)
3018 i = stash->adjusted_section_count;
3019 p = stash->adjusted_sections;
3020 for (; i > 0; i--, p++)
3021 p->section->vma = p->adj_vma;
3026 bfd_vma last_vma = 0, last_dwarf = 0;
3028 const char *debug_info_name;
3030 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3032 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3037 if ((sect->output_section != NULL
3038 && sect->output_section != sect)
3042 /* We need to adjust the VMAs of any .debug_info sections.
3043 Skip compressed ones, since no relocations could target
3044 them - they should not appear in object files anyway. */
3045 if (strcmp (sect->name, debug_info_name) == 0)
3047 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
3052 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
3055 sz = sect->rawsize ? sect->rawsize : sect->size;
3064 amt = i * sizeof (struct adjusted_section);
3065 p = (struct adjusted_section *) bfd_alloc (abfd, amt);
3069 stash->adjusted_sections = p;
3070 stash->adjusted_section_count = i;
3072 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3077 if ((sect->output_section != NULL
3078 && sect->output_section != sect)
3082 /* We need to adjust the VMAs of any .debug_info sections.
3083 Skip compressed ones, since no relocations could target
3084 them - they should not appear in object files anyway. */
3085 if (strcmp (sect->name, debug_info_name) == 0)
3087 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
3092 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
3095 sz = sect->rawsize ? sect->rawsize : sect->size;
3102 BFD_ASSERT (sect->alignment_power == 0);
3103 sect->vma = last_dwarf;
3106 else if (last_vma != 0)
3108 /* Align the new address to the current section
3110 last_vma = ((last_vma
3111 + ~((bfd_vma) -1 << sect->alignment_power))
3112 & ((bfd_vma) -1 << sect->alignment_power));
3113 sect->vma = last_vma;
3114 last_vma += sect->vma + sz;
3117 last_vma += sect->vma + sz;
3119 p->adj_vma = sect->vma;
3128 /* Look up a funcinfo by name using the given info hash table. If found,
3129 also update the locations pointed to by filename_ptr and linenumber_ptr.
3131 This function returns TRUE if a funcinfo that matches the given symbol
3132 and address is found with any error; otherwise it returns FALSE. */
3135 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3138 const char **filename_ptr,
3139 unsigned int *linenumber_ptr)
3141 struct funcinfo* each_func;
3142 struct funcinfo* best_fit = NULL;
3143 struct info_list_node *node;
3144 struct arange *arange;
3145 const char *name = bfd_asymbol_name (sym);
3146 asection *sec = bfd_get_section (sym);
3148 for (node = lookup_info_hash_table (hash_table, name);
3152 each_func = (struct funcinfo *) node->info;
3153 for (arange = &each_func->arange;
3155 arange = arange->next)
3157 if ((!each_func->sec || each_func->sec == sec)
3158 && addr >= arange->low
3159 && addr < arange->high
3161 || (arange->high - arange->low
3162 < best_fit->arange.high - best_fit->arange.low)))
3163 best_fit = each_func;
3169 best_fit->sec = sec;
3170 *filename_ptr = best_fit->file;
3171 *linenumber_ptr = best_fit->line;
3178 /* Look up a varinfo by name using the given info hash table. If found,
3179 also update the locations pointed to by filename_ptr and linenumber_ptr.
3181 This function returns TRUE if a varinfo that matches the given symbol
3182 and address is found with any error; otherwise it returns FALSE. */
3185 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3188 const char **filename_ptr,
3189 unsigned int *linenumber_ptr)
3191 const char *name = bfd_asymbol_name (sym);
3192 asection *sec = bfd_get_section (sym);
3193 struct varinfo* each;
3194 struct info_list_node *node;
3196 for (node = lookup_info_hash_table (hash_table, name);
3200 each = (struct varinfo *) node->info;
3201 if (each->addr == addr
3202 && (!each->sec || each->sec == sec))
3205 *filename_ptr = each->file;
3206 *linenumber_ptr = each->line;
3214 /* Update the funcinfo and varinfo info hash tables if they are
3215 not up to date. Returns TRUE if there is no error; otherwise
3216 returns FALSE and disable the info hash tables. */
3219 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3221 struct comp_unit *each;
3223 /* Exit if hash tables are up-to-date. */
3224 if (stash->all_comp_units == stash->hash_units_head)
3227 if (stash->hash_units_head)
3228 each = stash->hash_units_head->prev_unit;
3230 each = stash->last_comp_unit;
3234 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3235 stash->varinfo_hash_table))
3237 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3240 each = each->prev_unit;
3243 stash->hash_units_head = stash->all_comp_units;
3247 /* Check consistency of info hash tables. This is for debugging only. */
3249 static void ATTRIBUTE_UNUSED
3250 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3252 struct comp_unit *each_unit;
3253 struct funcinfo *each_func;
3254 struct varinfo *each_var;
3255 struct info_list_node *node;
3258 for (each_unit = stash->all_comp_units;
3260 each_unit = each_unit->next_unit)
3262 for (each_func = each_unit->function_table;
3264 each_func = each_func->prev_func)
3266 if (!each_func->name)
3268 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3272 while (node && !found)
3274 found = node->info == each_func;
3280 for (each_var = each_unit->variable_table;
3282 each_var = each_var->prev_var)
3284 if (!each_var->name || !each_var->file || each_var->stack)
3286 node = lookup_info_hash_table (stash->varinfo_hash_table,
3290 while (node && !found)
3292 found = node->info == each_var;
3300 /* Check to see if we want to enable the info hash tables, which consume
3301 quite a bit of memory. Currently we only check the number times
3302 bfd_dwarf2_find_line is called. In the future, we may also want to
3303 take the number of symbols into account. */
3306 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3308 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3310 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3313 /* FIXME: Maybe we should check the reduce_memory_overheads
3314 and optimize fields in the bfd_link_info structure ? */
3316 /* Create hash tables. */
3317 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3318 stash->varinfo_hash_table = create_info_hash_table (abfd);
3319 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3321 /* Turn off info hashes if any allocation above fails. */
3322 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3325 /* We need a forced update so that the info hash tables will
3326 be created even though there is no compilation unit. That
3327 happens if STASH_INFO_HASH_TRIGGER is 0. */
3328 stash_maybe_update_info_hash_tables (stash);
3329 stash->info_hash_status = STASH_INFO_HASH_ON;
3332 /* Find the file and line associated with a symbol and address using the
3333 info hash tables of a stash. If there is a match, the function returns
3334 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3335 otherwise it returns FALSE. */
3338 stash_find_line_fast (struct dwarf2_debug *stash,
3341 const char **filename_ptr,
3342 unsigned int *linenumber_ptr)
3344 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3346 if (sym->flags & BSF_FUNCTION)
3347 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3348 filename_ptr, linenumber_ptr);
3349 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3350 filename_ptr, linenumber_ptr);
3353 /* Save current section VMAs. */
3356 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3361 if (abfd->section_count == 0)
3363 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3364 if (stash->sec_vma == NULL)
3366 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3368 if (s->output_section != NULL)
3369 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3371 stash->sec_vma[i] = s->vma;
3376 /* Compare current section VMAs against those at the time the stash
3377 was created. If find_nearest_line is used in linker warnings or
3378 errors early in the link process, the debug info stash will be
3379 invalid for later calls. This is because we relocate debug info
3380 sections, so the stashed section contents depend on symbol values,
3381 which in turn depend on section VMAs. */
3384 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3389 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3393 if (s->output_section != NULL)
3394 vma = s->output_section->vma + s->output_offset;
3397 if (vma != stash->sec_vma[i])
3403 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3404 If DEBUG_BFD is not specified, we read debug information from ABFD
3405 or its gnu_debuglink. The results will be stored in PINFO.
3406 The function returns TRUE iff debug information is ready. */
3409 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3410 const struct dwarf_debug_section *debug_sections,
3414 bfd_size_type amt = sizeof (struct dwarf2_debug);
3415 bfd_size_type total_size;
3417 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3421 if (stash->syms == symbols
3422 && section_vma_same (abfd, stash))
3424 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3425 memset (stash, 0, amt);
3429 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3433 stash->debug_sections = debug_sections;
3434 stash->syms = symbols;
3435 if (!save_section_vma (abfd, stash))
3440 if (debug_bfd == NULL)
3443 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3444 if (msec == NULL && abfd == debug_bfd)
3446 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3448 if (debug_filename == NULL)
3449 /* No dwarf2 info, and no gnu_debuglink to follow.
3450 Note that at this point the stash has been allocated, but
3451 contains zeros. This lets future calls to this function
3452 fail more quickly. */
3455 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3456 || ! bfd_check_format (debug_bfd, bfd_object)
3457 || (msec = find_debug_info (debug_bfd,
3458 debug_sections, NULL)) == NULL)
3461 bfd_close (debug_bfd);
3462 /* FIXME: Should we report our failure to follow the debuglink ? */
3463 free (debug_filename);
3466 stash->close_on_cleanup = TRUE;
3468 stash->bfd_ptr = debug_bfd;
3470 /* There can be more than one DWARF2 info section in a BFD these
3471 days. First handle the easy case when there's only one. If
3472 there's more than one, try case two: none of the sections is
3473 compressed. In that case, read them all in and produce one
3474 large stash. We do this in two passes - in the first pass we
3475 just accumulate the section sizes, and in the second pass we
3476 read in the section's contents. (The allows us to avoid
3477 reallocing the data as we add sections to the stash.) If
3478 some or all sections are compressed, then do things the slow
3479 way, with a bunch of reallocs. */
3481 if (! find_debug_info (debug_bfd, debug_sections, msec))
3483 /* Case 1: only one info section. */
3484 total_size = msec->size;
3485 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3487 &stash->info_ptr_memory, &total_size))
3492 /* Case 2: multiple sections. */
3493 for (total_size = 0;
3495 msec = find_debug_info (debug_bfd, debug_sections, msec))
3496 total_size += msec->size;
3498 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3499 if (stash->info_ptr_memory == NULL)
3503 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3505 msec = find_debug_info (debug_bfd, debug_sections, msec))
3513 if (!(bfd_simple_get_relocated_section_contents
3514 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3522 stash->info_ptr = stash->info_ptr_memory;
3523 stash->info_ptr_end = stash->info_ptr + total_size;
3524 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
3525 stash->sec_info_ptr = stash->info_ptr;
3529 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3530 then find the nearest source code location corresponding to
3531 the address SECTION + OFFSET.
3532 Returns TRUE if the line is found without error and fills in
3533 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3534 NULL the FUNCTIONNAME_PTR is also filled in.
3535 SYMBOLS contains the symbol table for ABFD.
3536 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3537 ADDR_SIZE is the number of bytes in the initial .debug_info length
3538 field and in the abbreviation offset, or zero to indicate that the
3539 default value should be used. */
3542 find_line (bfd *abfd,
3543 const struct dwarf_debug_section *debug_sections,
3548 const char **filename_ptr,
3549 const char **functionname_ptr,
3550 unsigned int *linenumber_ptr,
3551 unsigned int *discriminator_ptr,
3552 unsigned int addr_size,
3555 /* Read each compilation unit from the section .debug_info, and check
3556 to see if it contains the address we are searching for. If yes,
3557 lookup the address, and return the line number info. If no, go
3558 on to the next compilation unit.
3560 We keep a list of all the previously read compilation units, and
3561 a pointer to the next un-read compilation unit. Check the
3562 previously read units before reading more. */
3563 struct dwarf2_debug *stash;
3564 /* What address are we looking for? */
3566 struct comp_unit* each;
3567 bfd_boolean found = FALSE;
3568 bfd_boolean do_line;
3570 *filename_ptr = NULL;
3571 if (functionname_ptr != NULL)
3572 *functionname_ptr = NULL;
3573 *linenumber_ptr = 0;
3574 if (discriminator_ptr)
3575 *discriminator_ptr = 0;
3577 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL,
3578 debug_sections, symbols, pinfo))
3581 stash = (struct dwarf2_debug *) *pinfo;
3583 /* In a relocatable file, 2 functions may have the same address.
3584 We change the section vma so that they won't overlap. */
3585 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3587 if (! place_sections (abfd, stash))
3591 do_line = (section == NULL
3593 && functionname_ptr == NULL
3597 addr = symbol->value;
3598 section = bfd_get_section (symbol);
3600 else if (section != NULL
3601 && functionname_ptr != NULL
3607 if (section->output_section)
3608 addr += section->output_section->vma + section->output_offset;
3610 addr += section->vma;
3612 /* A null info_ptr indicates that there is no dwarf2 info
3613 (or that an error occured while setting up the stash). */
3614 if (! stash->info_ptr)
3617 stash->inliner_chain = NULL;
3619 /* Check the previously read comp. units first. */
3622 /* The info hash tables use quite a bit of memory. We may not want to
3623 always use them. We use some heuristics to decide if and when to
3625 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3626 stash_maybe_enable_info_hash_tables (abfd, stash);
3628 /* Keep info hash table up to date if they are available. Note that we
3629 may disable the hash tables if there is any error duing update. */
3630 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3631 stash_maybe_update_info_hash_tables (stash);
3633 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3635 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3642 /* Check the previously read comp. units first. */
3643 for (each = stash->all_comp_units; each; each = each->next_unit)
3644 if ((symbol->flags & BSF_FUNCTION) == 0
3645 || each->arange.high == 0
3646 || comp_unit_contains_address (each, addr))
3648 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3649 linenumber_ptr, stash);
3657 bfd_vma min_range = (bfd_vma) -1;
3658 const char * local_filename = NULL;
3659 const char * local_functionname = NULL;
3660 unsigned int local_linenumber = 0;
3661 unsigned int local_discriminator = 0;
3663 for (each = stash->all_comp_units; each; each = each->next_unit)
3665 bfd_vma range = (bfd_vma) -1;
3667 found = ((each->arange.high == 0
3668 || comp_unit_contains_address (each, addr))
3669 && (range = comp_unit_find_nearest_line (each, addr,
3671 & local_functionname,
3673 & local_discriminator,
3677 /* PRs 15935 15994: Bogus debug information may have provided us
3678 with an erroneous match. We attempt to counter this by
3679 selecting the match that has the smallest address range
3680 associated with it. (We are assuming that corrupt debug info
3681 will tend to result in extra large address ranges rather than
3682 extra small ranges).
3684 This does mean that we scan through all of the CUs associated
3685 with the bfd each time this function is called. But this does
3686 have the benefit of producing consistent results every time the
3687 function is called. */
3688 if (range <= min_range)
3690 if (filename_ptr && local_filename)
3691 * filename_ptr = local_filename;
3692 if (functionname_ptr && local_functionname)
3693 * functionname_ptr = local_functionname;
3694 if (discriminator_ptr && local_discriminator)
3695 * discriminator_ptr = local_discriminator;
3696 if (local_linenumber)
3697 * linenumber_ptr = local_linenumber;
3703 if (* linenumber_ptr)
3710 /* The DWARF2 spec says that the initial length field, and the
3711 offset of the abbreviation table, should both be 4-byte values.
3712 However, some compilers do things differently. */
3715 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3717 /* Read each remaining comp. units checking each as they are read. */
3718 while (stash->info_ptr < stash->info_ptr_end)
3721 unsigned int offset_size = addr_size;
3722 bfd_byte *info_ptr_unit = stash->info_ptr;
3724 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
3725 /* A 0xffffff length is the DWARF3 way of indicating
3726 we use 64-bit offsets, instead of 32-bit offsets. */
3727 if (length == 0xffffffff)
3730 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3731 stash->info_ptr += 12;
3733 /* A zero length is the IRIX way of indicating 64-bit offsets,
3734 mostly because the 64-bit length will generally fit in 32
3735 bits, and the endianness helps. */
3736 else if (length == 0)
3739 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3740 stash->info_ptr += 8;
3742 /* In the absence of the hints above, we assume 32-bit DWARF2
3743 offsets even for targets with 64-bit addresses, because:
3744 a) most of the time these targets will not have generated
3745 more than 2Gb of debug info and so will not need 64-bit
3748 b) if they do use 64-bit offsets but they are not using
3749 the size hints that are tested for above then they are
3750 not conforming to the DWARF3 standard anyway. */
3751 else if (addr_size == 8)
3754 stash->info_ptr += 4;
3757 stash->info_ptr += 4;
3761 each = parse_comp_unit (stash, length, info_ptr_unit,
3764 /* The dwarf information is damaged, don't trust it any
3767 stash->info_ptr += length;
3769 if (stash->all_comp_units)
3770 stash->all_comp_units->prev_unit = each;
3772 stash->last_comp_unit = each;
3774 each->next_unit = stash->all_comp_units;
3775 stash->all_comp_units = each;
3777 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3778 compilation units. If we don't have them (i.e.,
3779 unit->high == 0), we need to consult the line info table
3780 to see if a compilation unit contains the given
3783 found = (((symbol->flags & BSF_FUNCTION) == 0
3784 || each->arange.high == 0
3785 || comp_unit_contains_address (each, addr))
3786 && comp_unit_find_line (each, symbol, addr,
3791 found = ((each->arange.high == 0
3792 || comp_unit_contains_address (each, addr))
3793 && comp_unit_find_nearest_line (each, addr,
3800 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3801 == stash->sec->size)
3803 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
3805 stash->sec_info_ptr = stash->info_ptr;
3814 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3815 unset_sections (stash);
3820 /* The DWARF2 version of find_nearest_line.
3821 Return TRUE if the line is found without error. */
3824 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3825 const struct dwarf_debug_section *debug_sections,
3829 const char **filename_ptr,
3830 const char **functionname_ptr,
3831 unsigned int *linenumber_ptr,
3832 unsigned int *discriminator_ptr,
3833 unsigned int addr_size,
3836 return find_line (abfd, debug_sections, section, offset, NULL, symbols,
3837 filename_ptr, functionname_ptr, linenumber_ptr,
3838 discriminator_ptr, addr_size, pinfo);
3841 /* The DWARF2 version of find_line.
3842 Return TRUE if the line is found without error. */
3845 _bfd_dwarf2_find_line (bfd *abfd,
3848 const char **filename_ptr,
3849 unsigned int *linenumber_ptr,
3850 unsigned int *discriminator_ptr,
3851 unsigned int addr_size,
3854 return find_line (abfd, dwarf_debug_sections, NULL, 0, symbol, symbols,
3855 filename_ptr, NULL, linenumber_ptr, discriminator_ptr,
3860 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3861 const char **filename_ptr,
3862 const char **functionname_ptr,
3863 unsigned int *linenumber_ptr,
3866 struct dwarf2_debug *stash;
3868 stash = (struct dwarf2_debug *) *pinfo;
3871 struct funcinfo *func = stash->inliner_chain;
3873 if (func && func->caller_func)
3875 *filename_ptr = func->caller_file;
3876 *functionname_ptr = func->caller_func->name;
3877 *linenumber_ptr = func->caller_line;
3878 stash->inliner_chain = func->caller_func;
3887 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
3889 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3890 struct comp_unit *each;
3892 if (abfd == NULL || stash == NULL)
3895 for (each = stash->all_comp_units; each; each = each->next_unit)
3897 struct abbrev_info **abbrevs = each->abbrevs;
3898 struct funcinfo *function_table = each->function_table;
3899 struct varinfo *variable_table = each->variable_table;
3902 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3904 struct abbrev_info *abbrev = abbrevs[i];
3908 free (abbrev->attrs);
3909 abbrev = abbrev->next;
3913 if (each->line_table)
3915 free (each->line_table->dirs);
3916 free (each->line_table->files);
3919 while (function_table)
3921 if (function_table->file)
3923 free (function_table->file);
3924 function_table->file = NULL;
3927 if (function_table->caller_file)
3929 free (function_table->caller_file);
3930 function_table->caller_file = NULL;
3932 function_table = function_table->prev_func;
3935 while (variable_table)
3937 if (variable_table->file)
3939 free (variable_table->file);
3940 variable_table->file = NULL;
3943 variable_table = variable_table->prev_var;
3947 if (stash->dwarf_abbrev_buffer)
3948 free (stash->dwarf_abbrev_buffer);
3949 if (stash->dwarf_line_buffer)
3950 free (stash->dwarf_line_buffer);
3951 if (stash->dwarf_str_buffer)
3952 free (stash->dwarf_str_buffer);
3953 if (stash->dwarf_ranges_buffer)
3954 free (stash->dwarf_ranges_buffer);
3955 if (stash->info_ptr_memory)
3956 free (stash->info_ptr_memory);
3957 if (stash->close_on_cleanup)
3958 bfd_close (stash->bfd_ptr);
3959 if (stash->alt_dwarf_str_buffer)
3960 free (stash->alt_dwarf_str_buffer);
3961 if (stash->alt_dwarf_info_buffer)
3962 free (stash->alt_dwarf_info_buffer);
3964 free (stash->sec_vma);
3965 if (stash->alt_bfd_ptr)
3966 bfd_close (stash->alt_bfd_ptr);