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 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 file pointed to by the .gnu_debugaltlink 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 bfd_vma best_fit_len = 0;
1998 struct arange *arange;
2000 for (each_func = unit->function_table;
2002 each_func = each_func->prev_func)
2004 for (arange = &each_func->arange;
2006 arange = arange->next)
2008 if (addr >= arange->low && addr < arange->high)
2011 || arange->high - arange->low < best_fit_len)
2013 best_fit = each_func;
2014 best_fit_len = arange->high - arange->low;
2022 *functionname_ptr = best_fit->name;
2023 *function_ptr = best_fit;
2032 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2033 and LINENUMBER_PTR, and return TRUE. */
2036 lookup_symbol_in_function_table (struct comp_unit *unit,
2039 const char **filename_ptr,
2040 unsigned int *linenumber_ptr)
2042 struct funcinfo* each_func;
2043 struct funcinfo* best_fit = NULL;
2044 bfd_vma best_fit_len = 0;
2045 struct arange *arange;
2046 const char *name = bfd_asymbol_name (sym);
2047 asection *sec = bfd_get_section (sym);
2049 for (each_func = unit->function_table;
2051 each_func = each_func->prev_func)
2053 for (arange = &each_func->arange;
2055 arange = arange->next)
2057 if ((!each_func->sec || each_func->sec == sec)
2058 && addr >= arange->low
2059 && addr < arange->high
2061 && strcmp (name, each_func->name) == 0
2063 || arange->high - arange->low < best_fit_len))
2065 best_fit = each_func;
2066 best_fit_len = arange->high - arange->low;
2073 best_fit->sec = sec;
2074 *filename_ptr = best_fit->file;
2075 *linenumber_ptr = best_fit->line;
2082 /* Variable table functions. */
2084 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2085 LINENUMBER_PTR, and return TRUE. */
2088 lookup_symbol_in_variable_table (struct comp_unit *unit,
2091 const char **filename_ptr,
2092 unsigned int *linenumber_ptr)
2094 const char *name = bfd_asymbol_name (sym);
2095 asection *sec = bfd_get_section (sym);
2096 struct varinfo* each;
2098 for (each = unit->variable_table; each; each = each->prev_var)
2099 if (each->stack == 0
2100 && each->file != NULL
2101 && each->name != NULL
2102 && each->addr == addr
2103 && (!each->sec || each->sec == sec)
2104 && strcmp (name, each->name) == 0)
2110 *filename_ptr = each->file;
2111 *linenumber_ptr = each->line;
2119 find_abstract_instance_name (struct comp_unit *unit,
2120 struct attribute *attr_ptr)
2122 bfd *abfd = unit->abfd;
2124 unsigned int abbrev_number, bytes_read, i;
2125 struct abbrev_info *abbrev;
2126 bfd_uint64_t die_ref = attr_ptr->u.val;
2127 struct attribute attr;
2130 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2131 is an offset from the .debug_info section, not the current CU. */
2132 if (attr_ptr->form == DW_FORM_ref_addr)
2134 /* We only support DW_FORM_ref_addr within the same file, so
2135 any relocations should be resolved already. */
2139 info_ptr = unit->sec_info_ptr + die_ref;
2141 /* Now find the CU containing this pointer. */
2142 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2146 /* Check other CUs to see if they contain the abbrev. */
2147 struct comp_unit * u;
2149 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2150 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2154 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2155 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2160 /* else FIXME: What do we do now ? */
2163 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2165 info_ptr = read_alt_indirect_ref (unit, die_ref);
2166 if (info_ptr == NULL)
2168 (*_bfd_error_handler)
2169 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2170 bfd_set_error (bfd_error_bad_value);
2173 /* FIXME: Do we need to locate the correct CU, in a similar
2174 fashion to the code in the DW_FORM_ref_addr case above ? */
2177 info_ptr = unit->info_ptr_unit + die_ref;
2179 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2180 info_ptr += bytes_read;
2184 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2187 (*_bfd_error_handler)
2188 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2189 bfd_set_error (bfd_error_bad_value);
2193 for (i = 0; i < abbrev->num_attrs; ++i)
2195 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2197 if (info_ptr == NULL)
2202 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2207 case DW_AT_specification:
2208 name = find_abstract_instance_name (unit, &attr);
2210 case DW_AT_linkage_name:
2211 case DW_AT_MIPS_linkage_name:
2224 read_rangelist (struct comp_unit *unit, struct arange *arange,
2225 bfd_uint64_t offset)
2227 bfd_byte *ranges_ptr;
2228 bfd_vma base_address = unit->base_address;
2230 if (! unit->stash->dwarf_ranges_buffer)
2232 if (! read_debug_ranges (unit))
2235 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2242 low_pc = read_address (unit, ranges_ptr);
2243 ranges_ptr += unit->addr_size;
2244 high_pc = read_address (unit, ranges_ptr);
2245 ranges_ptr += unit->addr_size;
2247 if (low_pc == 0 && high_pc == 0)
2249 if (low_pc == -1UL && high_pc != -1UL)
2250 base_address = high_pc;
2253 if (!arange_add (unit, arange,
2254 base_address + low_pc, base_address + high_pc))
2261 /* DWARF2 Compilation unit functions. */
2263 /* Scan over each die in a comp. unit looking for functions to add
2264 to the function table and variables to the variable table. */
2267 scan_unit_for_symbols (struct comp_unit *unit)
2269 bfd *abfd = unit->abfd;
2270 bfd_byte *info_ptr = unit->first_child_die_ptr;
2271 int nesting_level = 1;
2272 struct funcinfo **nested_funcs;
2273 int nested_funcs_size;
2275 /* Maintain a stack of in-scope functions and inlined functions, which we
2276 can use to set the caller_func field. */
2277 nested_funcs_size = 32;
2278 nested_funcs = (struct funcinfo **)
2279 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2280 if (nested_funcs == NULL)
2282 nested_funcs[nesting_level] = 0;
2284 while (nesting_level)
2286 unsigned int abbrev_number, bytes_read, i;
2287 struct abbrev_info *abbrev;
2288 struct attribute attr;
2289 struct funcinfo *func;
2290 struct varinfo *var;
2292 bfd_vma high_pc = 0;
2293 bfd_boolean high_pc_relative = FALSE;
2295 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2296 info_ptr += bytes_read;
2298 if (! abbrev_number)
2304 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2307 (*_bfd_error_handler)
2308 (_("Dwarf Error: Could not find abbrev number %u."),
2310 bfd_set_error (bfd_error_bad_value);
2315 if (abbrev->tag == DW_TAG_subprogram
2316 || abbrev->tag == DW_TAG_entry_point
2317 || abbrev->tag == DW_TAG_inlined_subroutine)
2319 bfd_size_type amt = sizeof (struct funcinfo);
2320 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2323 func->tag = abbrev->tag;
2324 func->prev_func = unit->function_table;
2325 unit->function_table = func;
2326 BFD_ASSERT (!unit->cached);
2328 if (func->tag == DW_TAG_inlined_subroutine)
2329 for (i = nesting_level - 1; i >= 1; i--)
2330 if (nested_funcs[i])
2332 func->caller_func = nested_funcs[i];
2335 nested_funcs[nesting_level] = func;
2340 if (abbrev->tag == DW_TAG_variable)
2342 bfd_size_type amt = sizeof (struct varinfo);
2343 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2346 var->tag = abbrev->tag;
2348 var->prev_var = unit->variable_table;
2349 unit->variable_table = var;
2350 BFD_ASSERT (!unit->cached);
2353 /* No inline function in scope at this nesting level. */
2354 nested_funcs[nesting_level] = 0;
2357 for (i = 0; i < abbrev->num_attrs; ++i)
2359 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2360 if (info_ptr == NULL)
2367 case DW_AT_call_file:
2368 func->caller_file = concat_filename (unit->line_table,
2372 case DW_AT_call_line:
2373 func->caller_line = attr.u.val;
2376 case DW_AT_abstract_origin:
2377 case DW_AT_specification:
2378 func->name = find_abstract_instance_name (unit, &attr);
2382 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2384 if (func->name == NULL)
2385 func->name = attr.u.str;
2388 case DW_AT_linkage_name:
2389 case DW_AT_MIPS_linkage_name:
2390 func->name = attr.u.str;
2394 low_pc = attr.u.val;
2398 high_pc = attr.u.val;
2399 high_pc_relative = attr.form != DW_FORM_addr;
2403 if (!read_rangelist (unit, &func->arange, attr.u.val))
2407 case DW_AT_decl_file:
2408 func->file = concat_filename (unit->line_table,
2412 case DW_AT_decl_line:
2413 func->line = attr.u.val;
2425 var->name = attr.u.str;
2428 case DW_AT_decl_file:
2429 var->file = concat_filename (unit->line_table,
2433 case DW_AT_decl_line:
2434 var->line = attr.u.val;
2437 case DW_AT_external:
2438 if (attr.u.val != 0)
2442 case DW_AT_location:
2446 case DW_FORM_block1:
2447 case DW_FORM_block2:
2448 case DW_FORM_block4:
2449 case DW_FORM_exprloc:
2450 if (*attr.u.blk->data == DW_OP_addr)
2454 /* Verify that DW_OP_addr is the only opcode in the
2455 location, in which case the block size will be 1
2456 plus the address size. */
2457 /* ??? For TLS variables, gcc can emit
2458 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2459 which we don't handle here yet. */
2460 if (attr.u.blk->size == unit->addr_size + 1U)
2461 var->addr = bfd_get (unit->addr_size * 8,
2463 attr.u.blk->data + 1);
2478 if (high_pc_relative)
2481 if (func && high_pc != 0)
2483 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2487 if (abbrev->has_children)
2491 if (nesting_level >= nested_funcs_size)
2493 struct funcinfo **tmp;
2495 nested_funcs_size *= 2;
2496 tmp = (struct funcinfo **)
2497 bfd_realloc (nested_funcs,
2498 nested_funcs_size * sizeof (struct funcinfo *));
2503 nested_funcs[nesting_level] = 0;
2507 free (nested_funcs);
2511 free (nested_funcs);
2515 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2516 includes the compilation unit header that proceeds the DIE's, but
2517 does not include the length field that precedes each compilation
2518 unit header. END_PTR points one past the end of this comp unit.
2519 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2521 This routine does not read the whole compilation unit; only enough
2522 to get to the line number information for the compilation unit. */
2524 static struct comp_unit *
2525 parse_comp_unit (struct dwarf2_debug *stash,
2526 bfd_vma unit_length,
2527 bfd_byte *info_ptr_unit,
2528 unsigned int offset_size)
2530 struct comp_unit* unit;
2531 unsigned int version;
2532 bfd_uint64_t abbrev_offset = 0;
2533 unsigned int addr_size;
2534 struct abbrev_info** abbrevs;
2535 unsigned int abbrev_number, bytes_read, i;
2536 struct abbrev_info *abbrev;
2537 struct attribute attr;
2538 bfd_byte *info_ptr = stash->info_ptr;
2539 bfd_byte *end_ptr = info_ptr + unit_length;
2542 bfd_vma high_pc = 0;
2543 bfd *abfd = stash->bfd_ptr;
2544 bfd_boolean high_pc_relative = FALSE;
2546 version = read_2_bytes (abfd, info_ptr);
2548 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2549 if (offset_size == 4)
2550 abbrev_offset = read_4_bytes (abfd, info_ptr);
2552 abbrev_offset = read_8_bytes (abfd, info_ptr);
2553 info_ptr += offset_size;
2554 addr_size = read_1_byte (abfd, info_ptr);
2557 if (version != 2 && version != 3 && version != 4)
2559 (*_bfd_error_handler)
2560 (_("Dwarf Error: found dwarf version '%u', this reader"
2561 " only handles version 2, 3 and 4 information."), version);
2562 bfd_set_error (bfd_error_bad_value);
2566 if (addr_size > sizeof (bfd_vma))
2568 (*_bfd_error_handler)
2569 (_("Dwarf Error: found address size '%u', this reader"
2570 " can not handle sizes greater than '%u'."),
2572 (unsigned int) sizeof (bfd_vma));
2573 bfd_set_error (bfd_error_bad_value);
2577 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2579 (*_bfd_error_handler)
2580 ("Dwarf Error: found address size '%u', this reader"
2581 " can only handle address sizes '2', '4' and '8'.", addr_size);
2582 bfd_set_error (bfd_error_bad_value);
2586 /* Read the abbrevs for this compilation unit into a table. */
2587 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2591 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2592 info_ptr += bytes_read;
2593 if (! abbrev_number)
2595 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2597 bfd_set_error (bfd_error_bad_value);
2601 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2604 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2606 bfd_set_error (bfd_error_bad_value);
2610 amt = sizeof (struct comp_unit);
2611 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2615 unit->version = version;
2616 unit->addr_size = addr_size;
2617 unit->offset_size = offset_size;
2618 unit->abbrevs = abbrevs;
2619 unit->end_ptr = end_ptr;
2620 unit->stash = stash;
2621 unit->info_ptr_unit = info_ptr_unit;
2622 unit->sec_info_ptr = stash->sec_info_ptr;
2624 for (i = 0; i < abbrev->num_attrs; ++i)
2626 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2627 if (info_ptr == NULL)
2630 /* Store the data if it is of an attribute we want to keep in a
2631 partial symbol table. */
2634 case DW_AT_stmt_list:
2636 unit->line_offset = attr.u.val;
2640 unit->name = attr.u.str;
2644 low_pc = attr.u.val;
2645 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2646 this is the base address to use when reading location
2647 lists or range lists. */
2648 if (abbrev->tag == DW_TAG_compile_unit)
2649 unit->base_address = low_pc;
2653 high_pc = attr.u.val;
2654 high_pc_relative = attr.form != DW_FORM_addr;
2658 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2662 case DW_AT_comp_dir:
2664 char *comp_dir = attr.u.str;
2667 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2668 directory, get rid of it. */
2669 char *cp = strchr (comp_dir, ':');
2671 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2674 unit->comp_dir = comp_dir;
2682 if (high_pc_relative)
2686 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2690 unit->first_child_die_ptr = info_ptr;
2694 /* Return TRUE if UNIT may contain the address given by ADDR. When
2695 there are functions written entirely with inline asm statements, the
2696 range info in the compilation unit header may not be correct. We
2697 need to consult the line info table to see if a compilation unit
2698 really contains the given address. */
2701 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2703 struct arange *arange;
2708 arange = &unit->arange;
2711 if (addr >= arange->low && addr < arange->high)
2713 arange = arange->next;
2720 /* If UNIT contains ADDR, set the output parameters to the values for
2721 the line containing ADDR. The output parameters, FILENAME_PTR,
2722 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2725 Returns the range of addresses covered by the entry that was used
2726 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2729 comp_unit_find_nearest_line (struct comp_unit *unit,
2731 const char **filename_ptr,
2732 const char **functionname_ptr,
2733 unsigned int *linenumber_ptr,
2734 unsigned int *discriminator_ptr,
2735 struct dwarf2_debug *stash)
2738 struct funcinfo *function;
2743 if (! unit->line_table)
2745 if (! unit->stmtlist)
2751 unit->line_table = decode_line_info (unit, stash);
2753 if (! unit->line_table)
2759 if (unit->first_child_die_ptr < unit->end_ptr
2760 && ! scan_unit_for_symbols (unit))
2768 func_p = lookup_address_in_function_table (unit, addr,
2769 &function, functionname_ptr);
2770 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2771 stash->inliner_chain = function;
2773 return lookup_address_in_line_info_table (unit->line_table, addr,
2779 /* Check to see if line info is already decoded in a comp_unit.
2780 If not, decode it. Returns TRUE if no errors were encountered;
2784 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2785 struct dwarf2_debug *stash)
2790 if (! unit->line_table)
2792 if (! unit->stmtlist)
2798 unit->line_table = decode_line_info (unit, stash);
2800 if (! unit->line_table)
2806 if (unit->first_child_die_ptr < unit->end_ptr
2807 && ! scan_unit_for_symbols (unit))
2817 /* If UNIT contains SYM at ADDR, set the output parameters to the
2818 values for the line containing SYM. The output parameters,
2819 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2822 Return TRUE if UNIT contains SYM, and no errors were encountered;
2826 comp_unit_find_line (struct comp_unit *unit,
2829 const char **filename_ptr,
2830 unsigned int *linenumber_ptr,
2831 struct dwarf2_debug *stash)
2833 if (!comp_unit_maybe_decode_line_info (unit, stash))
2836 if (sym->flags & BSF_FUNCTION)
2837 return lookup_symbol_in_function_table (unit, sym, addr,
2841 return lookup_symbol_in_variable_table (unit, sym, addr,
2846 static struct funcinfo *
2847 reverse_funcinfo_list (struct funcinfo *head)
2849 struct funcinfo *rhead;
2850 struct funcinfo *temp;
2852 for (rhead = NULL; head; head = temp)
2854 temp = head->prev_func;
2855 head->prev_func = rhead;
2861 static struct varinfo *
2862 reverse_varinfo_list (struct varinfo *head)
2864 struct varinfo *rhead;
2865 struct varinfo *temp;
2867 for (rhead = NULL; head; head = temp)
2869 temp = head->prev_var;
2870 head->prev_var = rhead;
2876 /* Extract all interesting funcinfos and varinfos of a compilation
2877 unit into hash tables for faster lookup. Returns TRUE if no
2878 errors were enountered; FALSE otherwise. */
2881 comp_unit_hash_info (struct dwarf2_debug *stash,
2882 struct comp_unit *unit,
2883 struct info_hash_table *funcinfo_hash_table,
2884 struct info_hash_table *varinfo_hash_table)
2886 struct funcinfo* each_func;
2887 struct varinfo* each_var;
2888 bfd_boolean okay = TRUE;
2890 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2892 if (!comp_unit_maybe_decode_line_info (unit, stash))
2895 BFD_ASSERT (!unit->cached);
2897 /* To preserve the original search order, we went to visit the function
2898 infos in the reversed order of the list. However, making the list
2899 bi-directional use quite a bit of extra memory. So we reverse
2900 the list first, traverse the list in the now reversed order and
2901 finally reverse the list again to get back the original order. */
2902 unit->function_table = reverse_funcinfo_list (unit->function_table);
2903 for (each_func = unit->function_table;
2905 each_func = each_func->prev_func)
2907 /* Skip nameless functions. */
2908 if (each_func->name)
2909 /* There is no need to copy name string into hash table as
2910 name string is either in the dwarf string buffer or
2911 info in the stash. */
2912 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2913 (void*) each_func, FALSE);
2915 unit->function_table = reverse_funcinfo_list (unit->function_table);
2919 /* We do the same for variable infos. */
2920 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2921 for (each_var = unit->variable_table;
2923 each_var = each_var->prev_var)
2925 /* Skip stack vars and vars with no files or names. */
2926 if (each_var->stack == 0
2927 && each_var->file != NULL
2928 && each_var->name != NULL)
2929 /* There is no need to copy name string into hash table as
2930 name string is either in the dwarf string buffer or
2931 info in the stash. */
2932 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2933 (void*) each_var, FALSE);
2936 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2937 unit->cached = TRUE;
2941 /* Locate a section in a BFD containing debugging info. The search starts
2942 from the section after AFTER_SEC, or from the first section in the BFD if
2943 AFTER_SEC is NULL. The search works by examining the names of the
2944 sections. There are three permissiable names. The first two are given
2945 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
2946 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
2947 This is a variation on the .debug_info section which has a checksum
2948 describing the contents appended onto the name. This allows the linker to
2949 identify and discard duplicate debugging sections for different
2950 compilation units. */
2951 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2954 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
2955 asection *after_sec)
2960 if (after_sec == NULL)
2962 look = debug_sections[debug_info].uncompressed_name;
2963 msec = bfd_get_section_by_name (abfd, look);
2967 look = debug_sections[debug_info].compressed_name;
2970 msec = bfd_get_section_by_name (abfd, look);
2975 for (msec = abfd->sections; msec != NULL; msec = msec->next)
2976 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2982 for (msec = after_sec->next; msec != NULL; msec = msec->next)
2984 look = debug_sections[debug_info].uncompressed_name;
2985 if (strcmp (msec->name, look) == 0)
2988 look = debug_sections[debug_info].compressed_name;
2989 if (look != NULL && strcmp (msec->name, look) == 0)
2992 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2999 /* Transfer VMAs from object file to separate debug file. */
3002 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3006 for (s = orig_bfd->sections, d = debug_bfd->sections;
3007 s != NULL && d != NULL;
3008 s = s->next, d = d->next)
3010 if ((d->flags & SEC_DEBUGGING) != 0)
3012 /* ??? Assumes 1-1 correspondence between sections in the
3014 if (strcmp (s->name, d->name) == 0)
3016 d->output_section = s->output_section;
3017 d->output_offset = s->output_offset;
3023 /* Unset vmas for adjusted sections in STASH. */
3026 unset_sections (struct dwarf2_debug *stash)
3029 struct adjusted_section *p;
3031 i = stash->adjusted_section_count;
3032 p = stash->adjusted_sections;
3033 for (; i > 0; i--, p++)
3034 p->section->vma = 0;
3037 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3038 relocatable object file. VMAs are normally all zero in relocatable
3039 object files, so if we want to distinguish locations in sections by
3040 address we need to set VMAs so the sections do not overlap. We
3041 also set VMA on .debug_info so that when we have multiple
3042 .debug_info sections (or the linkonce variant) they also do not
3043 overlap. The multiple .debug_info sections make up a single
3044 logical section. ??? We should probably do the same for other
3048 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3051 struct adjusted_section *p;
3053 const char *debug_info_name;
3055 if (stash->adjusted_section_count != 0)
3057 i = stash->adjusted_section_count;
3058 p = stash->adjusted_sections;
3059 for (; i > 0; i--, p++)
3060 p->section->vma = p->adj_vma;
3064 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3071 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3075 if ((sect->output_section != NULL
3076 && sect->output_section != sect
3077 && (sect->flags & SEC_DEBUGGING) == 0)
3081 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3082 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3084 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3090 if (abfd == stash->bfd_ptr)
3092 abfd = stash->bfd_ptr;
3096 stash->adjusted_section_count = -1;
3099 bfd_vma last_vma = 0, last_dwarf = 0;
3100 bfd_size_type amt = i * sizeof (struct adjusted_section);
3102 p = (struct adjusted_section *) bfd_malloc (amt);
3106 stash->adjusted_sections = p;
3107 stash->adjusted_section_count = i;
3114 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3119 if ((sect->output_section != NULL
3120 && sect->output_section != sect
3121 && (sect->flags & SEC_DEBUGGING) == 0)
3125 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3126 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3128 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3132 sz = sect->rawsize ? sect->rawsize : sect->size;
3136 BFD_ASSERT (sect->alignment_power == 0);
3137 sect->vma = last_dwarf;
3142 /* Align the new address to the current section
3144 last_vma = ((last_vma
3145 + ~((bfd_vma) -1 << sect->alignment_power))
3146 & ((bfd_vma) -1 << sect->alignment_power));
3147 sect->vma = last_vma;
3152 p->adj_vma = sect->vma;
3155 if (abfd == stash->bfd_ptr)
3157 abfd = stash->bfd_ptr;
3161 if (orig_bfd != stash->bfd_ptr)
3162 set_debug_vma (orig_bfd, stash->bfd_ptr);
3167 /* Look up a funcinfo by name using the given info hash table. If found,
3168 also update the locations pointed to by filename_ptr and linenumber_ptr.
3170 This function returns TRUE if a funcinfo that matches the given symbol
3171 and address is found with any error; otherwise it returns FALSE. */
3174 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3177 const char **filename_ptr,
3178 unsigned int *linenumber_ptr)
3180 struct funcinfo* each_func;
3181 struct funcinfo* best_fit = NULL;
3182 bfd_vma best_fit_len = 0;
3183 struct info_list_node *node;
3184 struct arange *arange;
3185 const char *name = bfd_asymbol_name (sym);
3186 asection *sec = bfd_get_section (sym);
3188 for (node = lookup_info_hash_table (hash_table, name);
3192 each_func = (struct funcinfo *) node->info;
3193 for (arange = &each_func->arange;
3195 arange = arange->next)
3197 if ((!each_func->sec || each_func->sec == sec)
3198 && addr >= arange->low
3199 && addr < arange->high
3201 || arange->high - arange->low < best_fit_len))
3203 best_fit = each_func;
3204 best_fit_len = arange->high - arange->low;
3211 best_fit->sec = sec;
3212 *filename_ptr = best_fit->file;
3213 *linenumber_ptr = best_fit->line;
3220 /* Look up a varinfo by name using the given info hash table. If found,
3221 also update the locations pointed to by filename_ptr and linenumber_ptr.
3223 This function returns TRUE if a varinfo that matches the given symbol
3224 and address is found with any error; otherwise it returns FALSE. */
3227 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3230 const char **filename_ptr,
3231 unsigned int *linenumber_ptr)
3233 const char *name = bfd_asymbol_name (sym);
3234 asection *sec = bfd_get_section (sym);
3235 struct varinfo* each;
3236 struct info_list_node *node;
3238 for (node = lookup_info_hash_table (hash_table, name);
3242 each = (struct varinfo *) node->info;
3243 if (each->addr == addr
3244 && (!each->sec || each->sec == sec))
3247 *filename_ptr = each->file;
3248 *linenumber_ptr = each->line;
3256 /* Update the funcinfo and varinfo info hash tables if they are
3257 not up to date. Returns TRUE if there is no error; otherwise
3258 returns FALSE and disable the info hash tables. */
3261 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3263 struct comp_unit *each;
3265 /* Exit if hash tables are up-to-date. */
3266 if (stash->all_comp_units == stash->hash_units_head)
3269 if (stash->hash_units_head)
3270 each = stash->hash_units_head->prev_unit;
3272 each = stash->last_comp_unit;
3276 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3277 stash->varinfo_hash_table))
3279 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3282 each = each->prev_unit;
3285 stash->hash_units_head = stash->all_comp_units;
3289 /* Check consistency of info hash tables. This is for debugging only. */
3291 static void ATTRIBUTE_UNUSED
3292 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3294 struct comp_unit *each_unit;
3295 struct funcinfo *each_func;
3296 struct varinfo *each_var;
3297 struct info_list_node *node;
3300 for (each_unit = stash->all_comp_units;
3302 each_unit = each_unit->next_unit)
3304 for (each_func = each_unit->function_table;
3306 each_func = each_func->prev_func)
3308 if (!each_func->name)
3310 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3314 while (node && !found)
3316 found = node->info == each_func;
3322 for (each_var = each_unit->variable_table;
3324 each_var = each_var->prev_var)
3326 if (!each_var->name || !each_var->file || each_var->stack)
3328 node = lookup_info_hash_table (stash->varinfo_hash_table,
3332 while (node && !found)
3334 found = node->info == each_var;
3342 /* Check to see if we want to enable the info hash tables, which consume
3343 quite a bit of memory. Currently we only check the number times
3344 bfd_dwarf2_find_line is called. In the future, we may also want to
3345 take the number of symbols into account. */
3348 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3350 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3352 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3355 /* FIXME: Maybe we should check the reduce_memory_overheads
3356 and optimize fields in the bfd_link_info structure ? */
3358 /* Create hash tables. */
3359 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3360 stash->varinfo_hash_table = create_info_hash_table (abfd);
3361 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3363 /* Turn off info hashes if any allocation above fails. */
3364 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3367 /* We need a forced update so that the info hash tables will
3368 be created even though there is no compilation unit. That
3369 happens if STASH_INFO_HASH_TRIGGER is 0. */
3370 stash_maybe_update_info_hash_tables (stash);
3371 stash->info_hash_status = STASH_INFO_HASH_ON;
3374 /* Find the file and line associated with a symbol and address using the
3375 info hash tables of a stash. If there is a match, the function returns
3376 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3377 otherwise it returns FALSE. */
3380 stash_find_line_fast (struct dwarf2_debug *stash,
3383 const char **filename_ptr,
3384 unsigned int *linenumber_ptr)
3386 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3388 if (sym->flags & BSF_FUNCTION)
3389 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3390 filename_ptr, linenumber_ptr);
3391 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3392 filename_ptr, linenumber_ptr);
3395 /* Save current section VMAs. */
3398 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3403 if (abfd->section_count == 0)
3405 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3406 if (stash->sec_vma == NULL)
3408 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3410 if (s->output_section != NULL)
3411 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3413 stash->sec_vma[i] = s->vma;
3418 /* Compare current section VMAs against those at the time the stash
3419 was created. If find_nearest_line is used in linker warnings or
3420 errors early in the link process, the debug info stash will be
3421 invalid for later calls. This is because we relocate debug info
3422 sections, so the stashed section contents depend on symbol values,
3423 which in turn depend on section VMAs. */
3426 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3431 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3435 if (s->output_section != NULL)
3436 vma = s->output_section->vma + s->output_offset;
3439 if (vma != stash->sec_vma[i])
3445 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3446 If DEBUG_BFD is not specified, we read debug information from ABFD
3447 or its gnu_debuglink. The results will be stored in PINFO.
3448 The function returns TRUE iff debug information is ready. */
3451 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3452 const struct dwarf_debug_section *debug_sections,
3455 bfd_boolean do_place)
3457 bfd_size_type amt = sizeof (struct dwarf2_debug);
3458 bfd_size_type total_size;
3460 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3464 if (section_vma_same (abfd, stash))
3466 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3467 memset (stash, 0, amt);
3471 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3475 stash->debug_sections = debug_sections;
3476 stash->syms = symbols;
3477 if (!save_section_vma (abfd, stash))
3482 if (debug_bfd == NULL)
3485 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3486 if (msec == NULL && abfd == debug_bfd)
3488 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3490 if (debug_filename == NULL)
3491 /* No dwarf2 info, and no gnu_debuglink to follow.
3492 Note that at this point the stash has been allocated, but
3493 contains zeros. This lets future calls to this function
3494 fail more quickly. */
3497 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3498 || ! bfd_check_format (debug_bfd, bfd_object)
3499 || (msec = find_debug_info (debug_bfd,
3500 debug_sections, NULL)) == NULL
3501 || !bfd_generic_link_read_symbols (debug_bfd))
3504 bfd_close (debug_bfd);
3505 /* FIXME: Should we report our failure to follow the debuglink ? */
3506 free (debug_filename);
3510 symbols = bfd_get_outsymbols (debug_bfd);
3511 stash->syms = symbols;
3512 stash->close_on_cleanup = TRUE;
3514 stash->bfd_ptr = debug_bfd;
3517 && !place_sections (abfd, stash))
3520 /* There can be more than one DWARF2 info section in a BFD these
3521 days. First handle the easy case when there's only one. If
3522 there's more than one, try case two: none of the sections is
3523 compressed. In that case, read them all in and produce one
3524 large stash. We do this in two passes - in the first pass we
3525 just accumulate the section sizes, and in the second pass we
3526 read in the section's contents. (The allows us to avoid
3527 reallocing the data as we add sections to the stash.) If
3528 some or all sections are compressed, then do things the slow
3529 way, with a bunch of reallocs. */
3531 if (! find_debug_info (debug_bfd, debug_sections, msec))
3533 /* Case 1: only one info section. */
3534 total_size = msec->size;
3535 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3537 &stash->info_ptr_memory, &total_size))
3542 /* Case 2: multiple sections. */
3543 for (total_size = 0;
3545 msec = find_debug_info (debug_bfd, debug_sections, msec))
3546 total_size += msec->size;
3548 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3549 if (stash->info_ptr_memory == NULL)
3553 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3555 msec = find_debug_info (debug_bfd, debug_sections, msec))
3563 if (!(bfd_simple_get_relocated_section_contents
3564 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3572 stash->info_ptr = stash->info_ptr_memory;
3573 stash->info_ptr_end = stash->info_ptr + total_size;
3574 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
3575 stash->sec_info_ptr = stash->info_ptr;
3579 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3580 then find the nearest source code location corresponding to
3581 the address SECTION + OFFSET.
3582 Returns TRUE if the line is found without error and fills in
3583 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3584 NULL the FUNCTIONNAME_PTR is also filled in.
3585 SYMBOLS contains the symbol table for ABFD.
3586 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3587 ADDR_SIZE is the number of bytes in the initial .debug_info length
3588 field and in the abbreviation offset, or zero to indicate that the
3589 default value should be used. */
3592 find_line (bfd *abfd,
3593 const struct dwarf_debug_section *debug_sections,
3598 const char **filename_ptr,
3599 const char **functionname_ptr,
3600 unsigned int *linenumber_ptr,
3601 unsigned int *discriminator_ptr,
3602 unsigned int addr_size,
3605 /* Read each compilation unit from the section .debug_info, and check
3606 to see if it contains the address we are searching for. If yes,
3607 lookup the address, and return the line number info. If no, go
3608 on to the next compilation unit.
3610 We keep a list of all the previously read compilation units, and
3611 a pointer to the next un-read compilation unit. Check the
3612 previously read units before reading more. */
3613 struct dwarf2_debug *stash;
3614 /* What address are we looking for? */
3616 struct comp_unit* each;
3617 bfd_boolean found = FALSE;
3618 bfd_boolean do_line;
3620 *filename_ptr = NULL;
3621 if (functionname_ptr != NULL)
3622 *functionname_ptr = NULL;
3623 *linenumber_ptr = 0;
3624 if (discriminator_ptr)
3625 *discriminator_ptr = 0;
3627 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
3629 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
3632 stash = (struct dwarf2_debug *) *pinfo;
3634 do_line = (section == NULL
3636 && functionname_ptr == NULL
3640 addr = symbol->value;
3641 section = bfd_get_section (symbol);
3643 else if (section != NULL
3644 && functionname_ptr != NULL
3650 if (section->output_section)
3651 addr += section->output_section->vma + section->output_offset;
3653 addr += section->vma;
3655 /* A null info_ptr indicates that there is no dwarf2 info
3656 (or that an error occured while setting up the stash). */
3657 if (! stash->info_ptr)
3660 stash->inliner_chain = NULL;
3662 /* Check the previously read comp. units first. */
3665 /* The info hash tables use quite a bit of memory. We may not want to
3666 always use them. We use some heuristics to decide if and when to
3668 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3669 stash_maybe_enable_info_hash_tables (abfd, stash);
3671 /* Keep info hash table up to date if they are available. Note that we
3672 may disable the hash tables if there is any error duing update. */
3673 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3674 stash_maybe_update_info_hash_tables (stash);
3676 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3678 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3685 /* Check the previously read comp. units first. */
3686 for (each = stash->all_comp_units; each; each = each->next_unit)
3687 if ((symbol->flags & BSF_FUNCTION) == 0
3688 || each->arange.high == 0
3689 || comp_unit_contains_address (each, addr))
3691 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3692 linenumber_ptr, stash);
3700 bfd_vma min_range = (bfd_vma) -1;
3701 const char * local_filename = NULL;
3702 const char * local_functionname = NULL;
3703 unsigned int local_linenumber = 0;
3704 unsigned int local_discriminator = 0;
3706 for (each = stash->all_comp_units; each; each = each->next_unit)
3708 bfd_vma range = (bfd_vma) -1;
3710 found = ((each->arange.high == 0
3711 || comp_unit_contains_address (each, addr))
3712 && (range = comp_unit_find_nearest_line (each, addr,
3714 & local_functionname,
3716 & local_discriminator,
3720 /* PRs 15935 15994: Bogus debug information may have provided us
3721 with an erroneous match. We attempt to counter this by
3722 selecting the match that has the smallest address range
3723 associated with it. (We are assuming that corrupt debug info
3724 will tend to result in extra large address ranges rather than
3725 extra small ranges).
3727 This does mean that we scan through all of the CUs associated
3728 with the bfd each time this function is called. But this does
3729 have the benefit of producing consistent results every time the
3730 function is called. */
3731 if (range <= min_range)
3733 if (filename_ptr && local_filename)
3734 * filename_ptr = local_filename;
3735 if (functionname_ptr && local_functionname)
3736 * functionname_ptr = local_functionname;
3737 if (discriminator_ptr && local_discriminator)
3738 * discriminator_ptr = local_discriminator;
3739 if (local_linenumber)
3740 * linenumber_ptr = local_linenumber;
3746 if (* linenumber_ptr)
3753 /* The DWARF2 spec says that the initial length field, and the
3754 offset of the abbreviation table, should both be 4-byte values.
3755 However, some compilers do things differently. */
3758 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3760 /* Read each remaining comp. units checking each as they are read. */
3761 while (stash->info_ptr < stash->info_ptr_end)
3764 unsigned int offset_size = addr_size;
3765 bfd_byte *info_ptr_unit = stash->info_ptr;
3767 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
3768 /* A 0xffffff length is the DWARF3 way of indicating
3769 we use 64-bit offsets, instead of 32-bit offsets. */
3770 if (length == 0xffffffff)
3773 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3774 stash->info_ptr += 12;
3776 /* A zero length is the IRIX way of indicating 64-bit offsets,
3777 mostly because the 64-bit length will generally fit in 32
3778 bits, and the endianness helps. */
3779 else if (length == 0)
3782 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3783 stash->info_ptr += 8;
3785 /* In the absence of the hints above, we assume 32-bit DWARF2
3786 offsets even for targets with 64-bit addresses, because:
3787 a) most of the time these targets will not have generated
3788 more than 2Gb of debug info and so will not need 64-bit
3791 b) if they do use 64-bit offsets but they are not using
3792 the size hints that are tested for above then they are
3793 not conforming to the DWARF3 standard anyway. */
3794 else if (addr_size == 8)
3797 stash->info_ptr += 4;
3800 stash->info_ptr += 4;
3804 each = parse_comp_unit (stash, length, info_ptr_unit,
3807 /* The dwarf information is damaged, don't trust it any
3810 stash->info_ptr += length;
3812 if (stash->all_comp_units)
3813 stash->all_comp_units->prev_unit = each;
3815 stash->last_comp_unit = each;
3817 each->next_unit = stash->all_comp_units;
3818 stash->all_comp_units = each;
3820 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3821 compilation units. If we don't have them (i.e.,
3822 unit->high == 0), we need to consult the line info table
3823 to see if a compilation unit contains the given
3826 found = (((symbol->flags & BSF_FUNCTION) == 0
3827 || each->arange.high == 0
3828 || comp_unit_contains_address (each, addr))
3829 && comp_unit_find_line (each, symbol, addr,
3834 found = ((each->arange.high == 0
3835 || comp_unit_contains_address (each, addr))
3836 && comp_unit_find_nearest_line (each, addr,
3843 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3844 == stash->sec->size)
3846 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
3848 stash->sec_info_ptr = stash->info_ptr;
3857 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3858 unset_sections (stash);
3863 /* The DWARF2 version of find_nearest_line.
3864 Return TRUE if the line is found without error. */
3867 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3868 const struct dwarf_debug_section *debug_sections,
3872 const char **filename_ptr,
3873 const char **functionname_ptr,
3874 unsigned int *linenumber_ptr,
3875 unsigned int *discriminator_ptr,
3876 unsigned int addr_size,
3879 return find_line (abfd, debug_sections, section, offset, NULL, symbols,
3880 filename_ptr, functionname_ptr, linenumber_ptr,
3881 discriminator_ptr, addr_size, pinfo);
3884 /* The DWARF2 version of find_line.
3885 Return TRUE if the line is found without error. */
3888 _bfd_dwarf2_find_line (bfd *abfd,
3891 const char **filename_ptr,
3892 unsigned int *linenumber_ptr,
3893 unsigned int *discriminator_ptr,
3894 unsigned int addr_size,
3897 return find_line (abfd, dwarf_debug_sections, NULL, 0, symbol, symbols,
3898 filename_ptr, NULL, linenumber_ptr, discriminator_ptr,
3903 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3904 const char **filename_ptr,
3905 const char **functionname_ptr,
3906 unsigned int *linenumber_ptr,
3909 struct dwarf2_debug *stash;
3911 stash = (struct dwarf2_debug *) *pinfo;
3914 struct funcinfo *func = stash->inliner_chain;
3916 if (func && func->caller_func)
3918 *filename_ptr = func->caller_file;
3919 *functionname_ptr = func->caller_func->name;
3920 *linenumber_ptr = func->caller_line;
3921 stash->inliner_chain = func->caller_func;
3930 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
3932 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3933 struct comp_unit *each;
3935 if (abfd == NULL || stash == NULL)
3938 for (each = stash->all_comp_units; each; each = each->next_unit)
3940 struct abbrev_info **abbrevs = each->abbrevs;
3941 struct funcinfo *function_table = each->function_table;
3942 struct varinfo *variable_table = each->variable_table;
3945 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3947 struct abbrev_info *abbrev = abbrevs[i];
3951 free (abbrev->attrs);
3952 abbrev = abbrev->next;
3956 if (each->line_table)
3958 free (each->line_table->dirs);
3959 free (each->line_table->files);
3962 while (function_table)
3964 if (function_table->file)
3966 free (function_table->file);
3967 function_table->file = NULL;
3970 if (function_table->caller_file)
3972 free (function_table->caller_file);
3973 function_table->caller_file = NULL;
3975 function_table = function_table->prev_func;
3978 while (variable_table)
3980 if (variable_table->file)
3982 free (variable_table->file);
3983 variable_table->file = NULL;
3986 variable_table = variable_table->prev_var;
3990 if (stash->dwarf_abbrev_buffer)
3991 free (stash->dwarf_abbrev_buffer);
3992 if (stash->dwarf_line_buffer)
3993 free (stash->dwarf_line_buffer);
3994 if (stash->dwarf_str_buffer)
3995 free (stash->dwarf_str_buffer);
3996 if (stash->dwarf_ranges_buffer)
3997 free (stash->dwarf_ranges_buffer);
3998 if (stash->info_ptr_memory)
3999 free (stash->info_ptr_memory);
4000 if (stash->close_on_cleanup)
4001 bfd_close (stash->bfd_ptr);
4002 if (stash->alt_dwarf_str_buffer)
4003 free (stash->alt_dwarf_str_buffer);
4004 if (stash->alt_dwarf_info_buffer)
4005 free (stash->alt_dwarf_info_buffer);
4007 free (stash->sec_vma);
4008 if (stash->adjusted_sections)
4009 free (stash->adjusted_sections);
4010 if (stash->alt_bfd_ptr)
4011 bfd_close (stash->alt_bfd_ptr);