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)
750 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
751 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
755 switch (unit->addr_size)
758 return bfd_get_signed_64 (unit->abfd, buf);
760 return bfd_get_signed_32 (unit->abfd, buf);
762 return bfd_get_signed_16 (unit->abfd, buf);
769 switch (unit->addr_size)
772 return bfd_get_64 (unit->abfd, buf);
774 return bfd_get_32 (unit->abfd, buf);
776 return bfd_get_16 (unit->abfd, buf);
783 /* Lookup an abbrev_info structure in the abbrev hash table. */
785 static struct abbrev_info *
786 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
788 unsigned int hash_number;
789 struct abbrev_info *abbrev;
791 hash_number = number % ABBREV_HASH_SIZE;
792 abbrev = abbrevs[hash_number];
796 if (abbrev->number == number)
799 abbrev = abbrev->next;
805 /* In DWARF version 2, the description of the debugging information is
806 stored in a separate .debug_abbrev section. Before we read any
807 dies from a section we read in all abbreviations and install them
810 static struct abbrev_info**
811 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
813 struct abbrev_info **abbrevs;
814 bfd_byte *abbrev_ptr;
815 struct abbrev_info *cur_abbrev;
816 unsigned int abbrev_number, bytes_read, abbrev_name;
817 unsigned int abbrev_form, hash_number;
820 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
822 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
825 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
826 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
830 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
831 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
832 abbrev_ptr += bytes_read;
834 /* Loop until we reach an abbrev number of 0. */
835 while (abbrev_number)
837 amt = sizeof (struct abbrev_info);
838 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
839 if (cur_abbrev == NULL)
842 /* Read in abbrev header. */
843 cur_abbrev->number = abbrev_number;
844 cur_abbrev->tag = (enum dwarf_tag)
845 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
846 abbrev_ptr += bytes_read;
847 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
850 /* Now read in declarations. */
851 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
852 abbrev_ptr += bytes_read;
853 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
854 abbrev_ptr += bytes_read;
858 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
860 struct attr_abbrev *tmp;
862 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
863 amt *= sizeof (struct attr_abbrev);
864 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
869 for (i = 0; i < ABBREV_HASH_SIZE; i++)
871 struct abbrev_info *abbrev = abbrevs[i];
875 free (abbrev->attrs);
876 abbrev = abbrev->next;
881 cur_abbrev->attrs = tmp;
884 cur_abbrev->attrs[cur_abbrev->num_attrs].name
885 = (enum dwarf_attribute) abbrev_name;
886 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
887 = (enum dwarf_form) abbrev_form;
888 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
889 abbrev_ptr += bytes_read;
890 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
891 abbrev_ptr += bytes_read;
894 hash_number = abbrev_number % ABBREV_HASH_SIZE;
895 cur_abbrev->next = abbrevs[hash_number];
896 abbrevs[hash_number] = cur_abbrev;
898 /* Get next abbreviation.
899 Under Irix6 the abbreviations for a compilation unit are not
900 always properly terminated with an abbrev number of 0.
901 Exit loop if we encounter an abbreviation which we have
902 already read (which means we are about to read the abbreviations
903 for the next compile unit) or if the end of the abbreviation
905 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
906 >= stash->dwarf_abbrev_size)
908 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
909 abbrev_ptr += bytes_read;
910 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
917 /* Returns true if the form is one which has a string value. */
919 static inline bfd_boolean
920 is_str_attr (enum dwarf_form form)
922 return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
925 /* Read an attribute value described by an attribute form. */
928 read_attribute_value (struct attribute *attr,
930 struct comp_unit *unit,
933 bfd *abfd = unit->abfd;
934 unsigned int bytes_read;
935 struct dwarf_block *blk;
938 attr->form = (enum dwarf_form) form;
942 case DW_FORM_ref_addr:
943 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
945 if (unit->version == 3 || unit->version == 4)
947 if (unit->offset_size == 4)
948 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
950 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
951 info_ptr += unit->offset_size;
956 attr->u.val = read_address (unit, info_ptr);
957 info_ptr += unit->addr_size;
959 case DW_FORM_GNU_ref_alt:
960 case DW_FORM_sec_offset:
961 if (unit->offset_size == 4)
962 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
964 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
965 info_ptr += unit->offset_size;
968 amt = sizeof (struct dwarf_block);
969 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
972 blk->size = read_2_bytes (abfd, info_ptr);
974 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
975 info_ptr += blk->size;
979 amt = sizeof (struct dwarf_block);
980 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
983 blk->size = read_4_bytes (abfd, info_ptr);
985 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
986 info_ptr += blk->size;
990 attr->u.val = read_2_bytes (abfd, info_ptr);
994 attr->u.val = read_4_bytes (abfd, info_ptr);
998 attr->u.val = read_8_bytes (abfd, info_ptr);
1001 case DW_FORM_string:
1002 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
1003 info_ptr += bytes_read;
1006 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
1007 info_ptr += bytes_read;
1009 case DW_FORM_GNU_strp_alt:
1010 attr->u.str = read_alt_indirect_string (unit, info_ptr, &bytes_read);
1011 info_ptr += bytes_read;
1013 case DW_FORM_exprloc:
1015 amt = sizeof (struct dwarf_block);
1016 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1019 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1020 info_ptr += bytes_read;
1021 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
1022 info_ptr += blk->size;
1025 case DW_FORM_block1:
1026 amt = sizeof (struct dwarf_block);
1027 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1030 blk->size = read_1_byte (abfd, info_ptr);
1032 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
1033 info_ptr += blk->size;
1037 attr->u.val = read_1_byte (abfd, info_ptr);
1041 attr->u.val = read_1_byte (abfd, info_ptr);
1044 case DW_FORM_flag_present:
1048 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
1049 info_ptr += bytes_read;
1052 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1053 info_ptr += bytes_read;
1056 attr->u.val = read_1_byte (abfd, info_ptr);
1060 attr->u.val = read_2_bytes (abfd, info_ptr);
1064 attr->u.val = read_4_bytes (abfd, info_ptr);
1068 attr->u.val = read_8_bytes (abfd, info_ptr);
1071 case DW_FORM_ref_sig8:
1072 attr->u.val = read_8_bytes (abfd, info_ptr);
1075 case DW_FORM_ref_udata:
1076 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1077 info_ptr += bytes_read;
1079 case DW_FORM_indirect:
1080 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1081 info_ptr += bytes_read;
1082 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
1085 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1087 bfd_set_error (bfd_error_bad_value);
1093 /* Read an attribute described by an abbreviated attribute. */
1096 read_attribute (struct attribute *attr,
1097 struct attr_abbrev *abbrev,
1098 struct comp_unit *unit,
1101 attr->name = abbrev->name;
1102 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
1106 /* Source line information table routines. */
1108 #define FILE_ALLOC_CHUNK 5
1109 #define DIR_ALLOC_CHUNK 5
1113 struct line_info* prev_line;
1117 unsigned int column;
1118 unsigned int discriminator;
1119 unsigned char op_index;
1120 unsigned char end_sequence; /* End of (sequential) code sequence. */
1131 struct line_sequence
1134 struct line_sequence* prev_sequence;
1135 struct line_info* last_line; /* Largest VMA. */
1138 struct line_info_table
1141 unsigned int num_files;
1142 unsigned int num_dirs;
1143 unsigned int num_sequences;
1146 struct fileinfo* files;
1147 struct line_sequence* sequences;
1148 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1151 /* Remember some information about each function. If the function is
1152 inlined (DW_TAG_inlined_subroutine) it may have two additional
1153 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1154 source code location where this function was inlined. */
1158 /* Pointer to previous function in list of all functions. */
1159 struct funcinfo *prev_func;
1160 /* Pointer to function one scope higher. */
1161 struct funcinfo *caller_func;
1162 /* Source location file name where caller_func inlines this func. */
1164 /* Source location line number where caller_func inlines this func. */
1166 /* Source location file name. */
1168 /* Source location line number. */
1172 struct arange arange;
1173 /* Where the symbol is defined. */
1179 /* Pointer to previous variable in list of all variables */
1180 struct varinfo *prev_var;
1181 /* Source location file name */
1183 /* Source location line number */
1188 /* Where the symbol is defined */
1190 /* Is this a stack variable? */
1191 unsigned int stack: 1;
1194 /* Return TRUE if NEW_LINE should sort after LINE. */
1196 static inline bfd_boolean
1197 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1199 return (new_line->address > line->address
1200 || (new_line->address == line->address
1201 && (new_line->op_index > line->op_index
1202 || (new_line->op_index == line->op_index
1203 && new_line->end_sequence < line->end_sequence))));
1207 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1208 that the list is sorted. Note that the line_info list is sorted from
1209 highest to lowest VMA (with possible duplicates); that is,
1210 line_info->prev_line always accesses an equal or smaller VMA. */
1213 add_line_info (struct line_info_table *table,
1215 unsigned char op_index,
1218 unsigned int column,
1219 unsigned int discriminator,
1222 bfd_size_type amt = sizeof (struct line_info);
1223 struct line_sequence* seq = table->sequences;
1224 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1229 /* Set member data of 'info'. */
1230 info->prev_line = NULL;
1231 info->address = address;
1232 info->op_index = op_index;
1234 info->column = column;
1235 info->discriminator = discriminator;
1236 info->end_sequence = end_sequence;
1238 if (filename && filename[0])
1240 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1241 if (info->filename == NULL)
1243 strcpy (info->filename, filename);
1246 info->filename = NULL;
1248 /* Find the correct location for 'info'. Normally we will receive
1249 new line_info data 1) in order and 2) with increasing VMAs.
1250 However some compilers break the rules (cf. decode_line_info) and
1251 so we include some heuristics for quickly finding the correct
1252 location for 'info'. In particular, these heuristics optimize for
1253 the common case in which the VMA sequence that we receive is a
1254 list of locally sorted VMAs such as
1255 p...z a...j (where a < j < p < z)
1257 Note: table->lcl_head is used to head an *actual* or *possible*
1258 sub-sequence within the list (such as a...j) that is not directly
1259 headed by table->last_line
1261 Note: we may receive duplicate entries from 'decode_line_info'. */
1264 && seq->last_line->address == address
1265 && seq->last_line->op_index == op_index
1266 && seq->last_line->end_sequence == end_sequence)
1268 /* We only keep the last entry with the same address and end
1269 sequence. See PR ld/4986. */
1270 if (table->lcl_head == seq->last_line)
1271 table->lcl_head = info;
1272 info->prev_line = seq->last_line->prev_line;
1273 seq->last_line = info;
1275 else if (!seq || seq->last_line->end_sequence)
1277 /* Start a new line sequence. */
1278 amt = sizeof (struct line_sequence);
1279 seq = (struct line_sequence *) bfd_malloc (amt);
1282 seq->low_pc = address;
1283 seq->prev_sequence = table->sequences;
1284 seq->last_line = info;
1285 table->lcl_head = info;
1286 table->sequences = seq;
1287 table->num_sequences++;
1289 else if (new_line_sorts_after (info, seq->last_line))
1291 /* Normal case: add 'info' to the beginning of the current sequence. */
1292 info->prev_line = seq->last_line;
1293 seq->last_line = info;
1295 /* lcl_head: initialize to head a *possible* sequence at the end. */
1296 if (!table->lcl_head)
1297 table->lcl_head = info;
1299 else if (!new_line_sorts_after (info, table->lcl_head)
1300 && (!table->lcl_head->prev_line
1301 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1303 /* Abnormal but easy: lcl_head is the head of 'info'. */
1304 info->prev_line = table->lcl_head->prev_line;
1305 table->lcl_head->prev_line = info;
1309 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1310 are valid heads for 'info'. Reset 'lcl_head'. */
1311 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1312 struct line_info* li1 = li2->prev_line;
1316 if (!new_line_sorts_after (info, li2)
1317 && new_line_sorts_after (info, li1))
1320 li2 = li1; /* always non-NULL */
1321 li1 = li1->prev_line;
1323 table->lcl_head = li2;
1324 info->prev_line = table->lcl_head->prev_line;
1325 table->lcl_head->prev_line = info;
1326 if (address < seq->low_pc)
1327 seq->low_pc = address;
1332 /* Extract a fully qualified filename from a line info table.
1333 The returned string has been malloc'ed and it is the caller's
1334 responsibility to free it. */
1337 concat_filename (struct line_info_table *table, unsigned int file)
1341 if (file - 1 >= table->num_files)
1343 /* FILE == 0 means unknown. */
1345 (*_bfd_error_handler)
1346 (_("Dwarf Error: mangled line number section (bad file number)."));
1347 return strdup ("<unknown>");
1350 filename = table->files[file - 1].name;
1352 if (!IS_ABSOLUTE_PATH (filename))
1354 char *dir_name = NULL;
1355 char *subdir_name = NULL;
1359 if (table->files[file - 1].dir)
1360 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1362 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1363 dir_name = table->comp_dir;
1367 dir_name = subdir_name;
1372 return strdup (filename);
1374 len = strlen (dir_name) + strlen (filename) + 2;
1378 len += strlen (subdir_name) + 1;
1379 name = (char *) bfd_malloc (len);
1381 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1385 name = (char *) bfd_malloc (len);
1387 sprintf (name, "%s/%s", dir_name, filename);
1393 return strdup (filename);
1397 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1398 bfd_vma low_pc, bfd_vma high_pc)
1400 struct arange *arange;
1402 /* Ignore empty ranges. */
1403 if (low_pc == high_pc)
1406 /* If the first arange is empty, use it. */
1407 if (first_arange->high == 0)
1409 first_arange->low = low_pc;
1410 first_arange->high = high_pc;
1414 /* Next see if we can cheaply extend an existing range. */
1415 arange = first_arange;
1418 if (low_pc == arange->high)
1420 arange->high = high_pc;
1423 if (high_pc == arange->low)
1425 arange->low = low_pc;
1428 arange = arange->next;
1432 /* Need to allocate a new arange and insert it into the arange list.
1433 Order isn't significant, so just insert after the first arange. */
1434 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1437 arange->low = low_pc;
1438 arange->high = high_pc;
1439 arange->next = first_arange->next;
1440 first_arange->next = arange;
1444 /* Compare function for line sequences. */
1447 compare_sequences (const void* a, const void* b)
1449 const struct line_sequence* seq1 = a;
1450 const struct line_sequence* seq2 = b;
1452 /* Sort by low_pc as the primary key. */
1453 if (seq1->low_pc < seq2->low_pc)
1455 if (seq1->low_pc > seq2->low_pc)
1458 /* If low_pc values are equal, sort in reverse order of
1459 high_pc, so that the largest region comes first. */
1460 if (seq1->last_line->address < seq2->last_line->address)
1462 if (seq1->last_line->address > seq2->last_line->address)
1465 if (seq1->last_line->op_index < seq2->last_line->op_index)
1467 if (seq1->last_line->op_index > seq2->last_line->op_index)
1473 /* Sort the line sequences for quick lookup. */
1476 sort_line_sequences (struct line_info_table* table)
1479 struct line_sequence* sequences;
1480 struct line_sequence* seq;
1482 unsigned int num_sequences = table->num_sequences;
1483 bfd_vma last_high_pc;
1485 if (num_sequences == 0)
1488 /* Allocate space for an array of sequences. */
1489 amt = sizeof (struct line_sequence) * num_sequences;
1490 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1491 if (sequences == NULL)
1494 /* Copy the linked list into the array, freeing the original nodes. */
1495 seq = table->sequences;
1496 for (n = 0; n < num_sequences; n++)
1498 struct line_sequence* last_seq = seq;
1501 sequences[n].low_pc = seq->low_pc;
1502 sequences[n].prev_sequence = NULL;
1503 sequences[n].last_line = seq->last_line;
1504 seq = seq->prev_sequence;
1507 BFD_ASSERT (seq == NULL);
1509 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1511 /* Make the list binary-searchable by trimming overlapping entries
1512 and removing nested entries. */
1514 last_high_pc = sequences[0].last_line->address;
1515 for (n = 1; n < table->num_sequences; n++)
1517 if (sequences[n].low_pc < last_high_pc)
1519 if (sequences[n].last_line->address <= last_high_pc)
1520 /* Skip nested entries. */
1523 /* Trim overlapping entries. */
1524 sequences[n].low_pc = last_high_pc;
1526 last_high_pc = sequences[n].last_line->address;
1527 if (n > num_sequences)
1529 /* Close up the gap. */
1530 sequences[num_sequences].low_pc = sequences[n].low_pc;
1531 sequences[num_sequences].last_line = sequences[n].last_line;
1536 table->sequences = sequences;
1537 table->num_sequences = num_sequences;
1541 /* Decode the line number information for UNIT. */
1543 static struct line_info_table*
1544 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1546 bfd *abfd = unit->abfd;
1547 struct line_info_table* table;
1550 struct line_head lh;
1551 unsigned int i, bytes_read, offset_size;
1552 char *cur_file, *cur_dir;
1553 unsigned char op_code, extended_op, adj_opcode;
1554 unsigned int exop_len;
1557 if (! read_section (abfd, &stash->debug_sections[debug_line],
1558 stash->syms, unit->line_offset,
1559 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1562 amt = sizeof (struct line_info_table);
1563 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1567 table->comp_dir = unit->comp_dir;
1569 table->num_files = 0;
1570 table->files = NULL;
1572 table->num_dirs = 0;
1575 table->num_sequences = 0;
1576 table->sequences = NULL;
1578 table->lcl_head = NULL;
1580 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1582 /* Read in the prologue. */
1583 lh.total_length = read_4_bytes (abfd, line_ptr);
1586 if (lh.total_length == 0xffffffff)
1588 lh.total_length = read_8_bytes (abfd, line_ptr);
1592 else if (lh.total_length == 0 && unit->addr_size == 8)
1594 /* Handle (non-standard) 64-bit DWARF2 formats. */
1595 lh.total_length = read_4_bytes (abfd, line_ptr);
1599 line_end = line_ptr + lh.total_length;
1600 lh.version = read_2_bytes (abfd, line_ptr);
1601 if (lh.version < 2 || lh.version > 4)
1603 (*_bfd_error_handler)
1604 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1605 bfd_set_error (bfd_error_bad_value);
1609 if (offset_size == 4)
1610 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1612 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1613 line_ptr += offset_size;
1614 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1616 if (lh.version >= 4)
1618 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr);
1622 lh.maximum_ops_per_insn = 1;
1623 if (lh.maximum_ops_per_insn == 0)
1625 (*_bfd_error_handler)
1626 (_("Dwarf Error: Invalid maximum operations per instruction."));
1627 bfd_set_error (bfd_error_bad_value);
1630 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1632 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1634 lh.line_range = read_1_byte (abfd, line_ptr);
1636 lh.opcode_base = read_1_byte (abfd, line_ptr);
1638 amt = lh.opcode_base * sizeof (unsigned char);
1639 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1641 lh.standard_opcode_lengths[0] = 1;
1643 for (i = 1; i < lh.opcode_base; ++i)
1645 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1649 /* Read directory table. */
1650 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1652 line_ptr += bytes_read;
1654 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1658 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1659 amt *= sizeof (char *);
1661 tmp = (char **) bfd_realloc (table->dirs, amt);
1667 table->dirs[table->num_dirs++] = cur_dir;
1670 line_ptr += bytes_read;
1672 /* Read file name table. */
1673 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1675 line_ptr += bytes_read;
1677 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1679 struct fileinfo *tmp;
1681 amt = table->num_files + FILE_ALLOC_CHUNK;
1682 amt *= sizeof (struct fileinfo);
1684 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1690 table->files[table->num_files].name = cur_file;
1691 table->files[table->num_files].dir =
1692 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1693 line_ptr += bytes_read;
1694 table->files[table->num_files].time =
1695 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1696 line_ptr += bytes_read;
1697 table->files[table->num_files].size =
1698 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1699 line_ptr += bytes_read;
1703 line_ptr += bytes_read;
1705 /* Read the statement sequences until there's nothing left. */
1706 while (line_ptr < line_end)
1708 /* State machine registers. */
1709 bfd_vma address = 0;
1710 unsigned char op_index = 0;
1711 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1712 unsigned int line = 1;
1713 unsigned int column = 0;
1714 unsigned int discriminator = 0;
1715 int is_stmt = lh.default_is_stmt;
1716 int end_sequence = 0;
1717 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1718 compilers generate address sequences that are wildly out of
1719 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1720 for ia64-Linux). Thus, to determine the low and high
1721 address, we must compare on every DW_LNS_copy, etc. */
1722 bfd_vma low_pc = (bfd_vma) -1;
1723 bfd_vma high_pc = 0;
1725 /* Decode the table. */
1726 while (! end_sequence)
1728 op_code = read_1_byte (abfd, line_ptr);
1731 if (op_code >= lh.opcode_base)
1733 /* Special operand. */
1734 adj_opcode = op_code - lh.opcode_base;
1735 if (lh.maximum_ops_per_insn == 1)
1736 address += (adj_opcode / lh.line_range
1737 * lh.minimum_instruction_length);
1740 address += ((op_index + adj_opcode / lh.line_range)
1741 / lh.maximum_ops_per_insn
1742 * lh.minimum_instruction_length);
1743 op_index = ((op_index + adj_opcode / lh.line_range)
1744 % lh.maximum_ops_per_insn);
1746 line += lh.line_base + (adj_opcode % lh.line_range);
1747 /* Append row to matrix using current values. */
1748 if (!add_line_info (table, address, op_index, filename,
1749 line, column, discriminator, 0))
1752 if (address < low_pc)
1754 if (address > high_pc)
1757 else switch (op_code)
1759 case DW_LNS_extended_op:
1760 exop_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1761 line_ptr += bytes_read;
1762 extended_op = read_1_byte (abfd, line_ptr);
1765 switch (extended_op)
1767 case DW_LNE_end_sequence:
1769 if (!add_line_info (table, address, op_index, filename, line,
1770 column, discriminator, end_sequence))
1773 if (address < low_pc)
1775 if (address > high_pc)
1777 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
1780 case DW_LNE_set_address:
1781 address = read_address (unit, line_ptr);
1783 line_ptr += unit->addr_size;
1785 case DW_LNE_define_file:
1786 cur_file = read_string (abfd, line_ptr, &bytes_read);
1787 line_ptr += bytes_read;
1788 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1790 struct fileinfo *tmp;
1792 amt = table->num_files + FILE_ALLOC_CHUNK;
1793 amt *= sizeof (struct fileinfo);
1794 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1799 table->files[table->num_files].name = cur_file;
1800 table->files[table->num_files].dir =
1801 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1802 line_ptr += bytes_read;
1803 table->files[table->num_files].time =
1804 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1805 line_ptr += bytes_read;
1806 table->files[table->num_files].size =
1807 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1808 line_ptr += bytes_read;
1811 case DW_LNE_set_discriminator:
1813 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1814 line_ptr += bytes_read;
1816 case DW_LNE_HP_source_file_correlation:
1817 line_ptr += exop_len - 1;
1820 (*_bfd_error_handler)
1821 (_("Dwarf Error: mangled line number section."));
1822 bfd_set_error (bfd_error_bad_value);
1824 if (filename != NULL)
1830 if (!add_line_info (table, address, op_index,
1831 filename, line, column, discriminator, 0))
1834 if (address < low_pc)
1836 if (address > high_pc)
1839 case DW_LNS_advance_pc:
1840 if (lh.maximum_ops_per_insn == 1)
1841 address += (lh.minimum_instruction_length
1842 * read_unsigned_leb128 (abfd, line_ptr,
1846 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
1848 address = ((op_index + adjust) / lh.maximum_ops_per_insn
1849 * lh.minimum_instruction_length);
1850 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1852 line_ptr += bytes_read;
1854 case DW_LNS_advance_line:
1855 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1856 line_ptr += bytes_read;
1858 case DW_LNS_set_file:
1862 /* The file and directory tables are 0
1863 based, the references are 1 based. */
1864 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1865 line_ptr += bytes_read;
1868 filename = concat_filename (table, file);
1871 case DW_LNS_set_column:
1872 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1873 line_ptr += bytes_read;
1875 case DW_LNS_negate_stmt:
1876 is_stmt = (!is_stmt);
1878 case DW_LNS_set_basic_block:
1880 case DW_LNS_const_add_pc:
1881 if (lh.maximum_ops_per_insn == 1)
1882 address += (lh.minimum_instruction_length
1883 * ((255 - lh.opcode_base) / lh.line_range));
1886 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
1887 address += (lh.minimum_instruction_length
1888 * ((op_index + adjust)
1889 / lh.maximum_ops_per_insn));
1890 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1893 case DW_LNS_fixed_advance_pc:
1894 address += read_2_bytes (abfd, line_ptr);
1899 /* Unknown standard opcode, ignore it. */
1900 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1902 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1903 line_ptr += bytes_read;
1913 if (sort_line_sequences (table))
1917 if (table->sequences != NULL)
1918 free (table->sequences);
1919 if (table->files != NULL)
1920 free (table->files);
1921 if (table->dirs != NULL)
1926 /* If ADDR is within TABLE set the output parameters and return the
1927 range of addresses covered by the entry used to fill them out.
1928 Otherwise set * FILENAME_PTR to NULL and return 0.
1929 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
1930 are pointers to the objects to be filled in. */
1933 lookup_address_in_line_info_table (struct line_info_table *table,
1935 const char **filename_ptr,
1936 unsigned int *linenumber_ptr,
1937 unsigned int *discriminator_ptr)
1939 struct line_sequence *seq = NULL;
1940 struct line_info *each_line;
1943 /* Binary search the array of sequences. */
1945 high = table->num_sequences;
1948 mid = (low + high) / 2;
1949 seq = &table->sequences[mid];
1950 if (addr < seq->low_pc)
1952 else if (addr >= seq->last_line->address)
1958 if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
1960 /* Note: seq->last_line should be a descendingly sorted list. */
1961 for (each_line = seq->last_line;
1963 each_line = each_line->prev_line)
1964 if (addr >= each_line->address)
1968 && !(each_line->end_sequence || each_line == seq->last_line))
1970 *filename_ptr = each_line->filename;
1971 *linenumber_ptr = each_line->line;
1972 if (discriminator_ptr)
1973 *discriminator_ptr = each_line->discriminator;
1974 return seq->last_line->address - seq->low_pc;
1978 *filename_ptr = NULL;
1982 /* Read in the .debug_ranges section for future reference. */
1985 read_debug_ranges (struct comp_unit *unit)
1987 struct dwarf2_debug *stash = unit->stash;
1988 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
1990 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
1993 /* Function table functions. */
1995 /* If ADDR is within UNIT's function tables, set FUNCTIONNAME_PTR, and return
1996 TRUE. Note that we need to find the function that has the smallest range
1997 that contains ADDR, to handle inlined functions without depending upon
1998 them being ordered in TABLE by increasing range. */
2001 lookup_address_in_function_table (struct comp_unit *unit,
2003 struct funcinfo **function_ptr,
2004 const char **functionname_ptr)
2006 struct funcinfo* each_func;
2007 struct funcinfo* best_fit = NULL;
2008 bfd_vma best_fit_len = 0;
2009 struct arange *arange;
2011 for (each_func = unit->function_table;
2013 each_func = each_func->prev_func)
2015 for (arange = &each_func->arange;
2017 arange = arange->next)
2019 if (addr >= arange->low && addr < arange->high)
2022 || arange->high - arange->low < best_fit_len)
2024 best_fit = each_func;
2025 best_fit_len = arange->high - arange->low;
2033 *functionname_ptr = best_fit->name;
2034 *function_ptr = best_fit;
2043 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2044 and LINENUMBER_PTR, and return TRUE. */
2047 lookup_symbol_in_function_table (struct comp_unit *unit,
2050 const char **filename_ptr,
2051 unsigned int *linenumber_ptr)
2053 struct funcinfo* each_func;
2054 struct funcinfo* best_fit = NULL;
2055 bfd_vma best_fit_len = 0;
2056 struct arange *arange;
2057 const char *name = bfd_asymbol_name (sym);
2058 asection *sec = bfd_get_section (sym);
2060 for (each_func = unit->function_table;
2062 each_func = each_func->prev_func)
2064 for (arange = &each_func->arange;
2066 arange = arange->next)
2068 if ((!each_func->sec || each_func->sec == sec)
2069 && addr >= arange->low
2070 && addr < arange->high
2072 && strcmp (name, each_func->name) == 0
2074 || arange->high - arange->low < best_fit_len))
2076 best_fit = each_func;
2077 best_fit_len = arange->high - arange->low;
2084 best_fit->sec = sec;
2085 *filename_ptr = best_fit->file;
2086 *linenumber_ptr = best_fit->line;
2093 /* Variable table functions. */
2095 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2096 LINENUMBER_PTR, and return TRUE. */
2099 lookup_symbol_in_variable_table (struct comp_unit *unit,
2102 const char **filename_ptr,
2103 unsigned int *linenumber_ptr)
2105 const char *name = bfd_asymbol_name (sym);
2106 asection *sec = bfd_get_section (sym);
2107 struct varinfo* each;
2109 for (each = unit->variable_table; each; each = each->prev_var)
2110 if (each->stack == 0
2111 && each->file != NULL
2112 && each->name != NULL
2113 && each->addr == addr
2114 && (!each->sec || each->sec == sec)
2115 && strcmp (name, each->name) == 0)
2121 *filename_ptr = each->file;
2122 *linenumber_ptr = each->line;
2130 find_abstract_instance_name (struct comp_unit *unit,
2131 struct attribute *attr_ptr)
2133 bfd *abfd = unit->abfd;
2135 unsigned int abbrev_number, bytes_read, i;
2136 struct abbrev_info *abbrev;
2137 bfd_uint64_t die_ref = attr_ptr->u.val;
2138 struct attribute attr;
2141 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2142 is an offset from the .debug_info section, not the current CU. */
2143 if (attr_ptr->form == DW_FORM_ref_addr)
2145 /* We only support DW_FORM_ref_addr within the same file, so
2146 any relocations should be resolved already. */
2150 info_ptr = unit->sec_info_ptr + die_ref;
2152 /* Now find the CU containing this pointer. */
2153 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2157 /* Check other CUs to see if they contain the abbrev. */
2158 struct comp_unit * u;
2160 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2161 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2165 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2166 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2171 /* else FIXME: What do we do now ? */
2174 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2176 info_ptr = read_alt_indirect_ref (unit, die_ref);
2177 if (info_ptr == NULL)
2179 (*_bfd_error_handler)
2180 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2181 bfd_set_error (bfd_error_bad_value);
2184 /* FIXME: Do we need to locate the correct CU, in a similar
2185 fashion to the code in the DW_FORM_ref_addr case above ? */
2188 info_ptr = unit->info_ptr_unit + die_ref;
2190 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2191 info_ptr += bytes_read;
2195 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2198 (*_bfd_error_handler)
2199 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2200 bfd_set_error (bfd_error_bad_value);
2204 for (i = 0; i < abbrev->num_attrs; ++i)
2206 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2208 if (info_ptr == NULL)
2213 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2215 if (name == NULL && is_str_attr (attr.form))
2218 case DW_AT_specification:
2219 name = find_abstract_instance_name (unit, &attr);
2221 case DW_AT_linkage_name:
2222 case DW_AT_MIPS_linkage_name:
2223 /* PR 16949: Corrupt debug info can place
2224 non-string forms into these attributes. */
2225 if (is_str_attr (attr.form))
2238 read_rangelist (struct comp_unit *unit, struct arange *arange,
2239 bfd_uint64_t offset)
2241 bfd_byte *ranges_ptr;
2242 bfd_vma base_address = unit->base_address;
2244 if (! unit->stash->dwarf_ranges_buffer)
2246 if (! read_debug_ranges (unit))
2249 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2256 low_pc = read_address (unit, ranges_ptr);
2257 ranges_ptr += unit->addr_size;
2258 high_pc = read_address (unit, ranges_ptr);
2259 ranges_ptr += unit->addr_size;
2261 if (low_pc == 0 && high_pc == 0)
2263 if (low_pc == -1UL && high_pc != -1UL)
2264 base_address = high_pc;
2267 if (!arange_add (unit, arange,
2268 base_address + low_pc, base_address + high_pc))
2275 /* DWARF2 Compilation unit functions. */
2277 /* Scan over each die in a comp. unit looking for functions to add
2278 to the function table and variables to the variable table. */
2281 scan_unit_for_symbols (struct comp_unit *unit)
2283 bfd *abfd = unit->abfd;
2284 bfd_byte *info_ptr = unit->first_child_die_ptr;
2285 int nesting_level = 1;
2286 struct funcinfo **nested_funcs;
2287 int nested_funcs_size;
2289 /* Maintain a stack of in-scope functions and inlined functions, which we
2290 can use to set the caller_func field. */
2291 nested_funcs_size = 32;
2292 nested_funcs = (struct funcinfo **)
2293 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2294 if (nested_funcs == NULL)
2296 nested_funcs[nesting_level] = 0;
2298 while (nesting_level)
2300 unsigned int abbrev_number, bytes_read, i;
2301 struct abbrev_info *abbrev;
2302 struct attribute attr;
2303 struct funcinfo *func;
2304 struct varinfo *var;
2306 bfd_vma high_pc = 0;
2307 bfd_boolean high_pc_relative = FALSE;
2309 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2310 info_ptr += bytes_read;
2312 if (! abbrev_number)
2318 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2321 (*_bfd_error_handler)
2322 (_("Dwarf Error: Could not find abbrev number %u."),
2324 bfd_set_error (bfd_error_bad_value);
2329 if (abbrev->tag == DW_TAG_subprogram
2330 || abbrev->tag == DW_TAG_entry_point
2331 || abbrev->tag == DW_TAG_inlined_subroutine)
2333 bfd_size_type amt = sizeof (struct funcinfo);
2334 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2337 func->tag = abbrev->tag;
2338 func->prev_func = unit->function_table;
2339 unit->function_table = func;
2340 BFD_ASSERT (!unit->cached);
2342 if (func->tag == DW_TAG_inlined_subroutine)
2343 for (i = nesting_level - 1; i >= 1; i--)
2344 if (nested_funcs[i])
2346 func->caller_func = nested_funcs[i];
2349 nested_funcs[nesting_level] = func;
2354 if (abbrev->tag == DW_TAG_variable)
2356 bfd_size_type amt = sizeof (struct varinfo);
2357 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2360 var->tag = abbrev->tag;
2362 var->prev_var = unit->variable_table;
2363 unit->variable_table = var;
2364 BFD_ASSERT (!unit->cached);
2367 /* No inline function in scope at this nesting level. */
2368 nested_funcs[nesting_level] = 0;
2371 for (i = 0; i < abbrev->num_attrs; ++i)
2373 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2374 if (info_ptr == NULL)
2381 case DW_AT_call_file:
2382 func->caller_file = concat_filename (unit->line_table,
2386 case DW_AT_call_line:
2387 func->caller_line = attr.u.val;
2390 case DW_AT_abstract_origin:
2391 case DW_AT_specification:
2392 func->name = find_abstract_instance_name (unit, &attr);
2396 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2398 if (func->name == NULL && is_str_attr (attr.form))
2399 func->name = attr.u.str;
2402 case DW_AT_linkage_name:
2403 case DW_AT_MIPS_linkage_name:
2404 /* PR 16949: Corrupt debug info can place
2405 non-string forms into these attributes. */
2406 if (is_str_attr (attr.form))
2407 func->name = attr.u.str;
2411 low_pc = attr.u.val;
2415 high_pc = attr.u.val;
2416 high_pc_relative = attr.form != DW_FORM_addr;
2420 if (!read_rangelist (unit, &func->arange, attr.u.val))
2424 case DW_AT_decl_file:
2425 func->file = concat_filename (unit->line_table,
2429 case DW_AT_decl_line:
2430 func->line = attr.u.val;
2442 var->name = attr.u.str;
2445 case DW_AT_decl_file:
2446 var->file = concat_filename (unit->line_table,
2450 case DW_AT_decl_line:
2451 var->line = attr.u.val;
2454 case DW_AT_external:
2455 if (attr.u.val != 0)
2459 case DW_AT_location:
2463 case DW_FORM_block1:
2464 case DW_FORM_block2:
2465 case DW_FORM_block4:
2466 case DW_FORM_exprloc:
2467 if (*attr.u.blk->data == DW_OP_addr)
2471 /* Verify that DW_OP_addr is the only opcode in the
2472 location, in which case the block size will be 1
2473 plus the address size. */
2474 /* ??? For TLS variables, gcc can emit
2475 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2476 which we don't handle here yet. */
2477 if (attr.u.blk->size == unit->addr_size + 1U)
2478 var->addr = bfd_get (unit->addr_size * 8,
2480 attr.u.blk->data + 1);
2495 if (high_pc_relative)
2498 if (func && high_pc != 0)
2500 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2504 if (abbrev->has_children)
2508 if (nesting_level >= nested_funcs_size)
2510 struct funcinfo **tmp;
2512 nested_funcs_size *= 2;
2513 tmp = (struct funcinfo **)
2514 bfd_realloc (nested_funcs,
2515 nested_funcs_size * sizeof (struct funcinfo *));
2520 nested_funcs[nesting_level] = 0;
2524 free (nested_funcs);
2528 free (nested_funcs);
2532 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2533 includes the compilation unit header that proceeds the DIE's, but
2534 does not include the length field that precedes each compilation
2535 unit header. END_PTR points one past the end of this comp unit.
2536 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2538 This routine does not read the whole compilation unit; only enough
2539 to get to the line number information for the compilation unit. */
2541 static struct comp_unit *
2542 parse_comp_unit (struct dwarf2_debug *stash,
2543 bfd_vma unit_length,
2544 bfd_byte *info_ptr_unit,
2545 unsigned int offset_size)
2547 struct comp_unit* unit;
2548 unsigned int version;
2549 bfd_uint64_t abbrev_offset = 0;
2550 unsigned int addr_size;
2551 struct abbrev_info** abbrevs;
2552 unsigned int abbrev_number, bytes_read, i;
2553 struct abbrev_info *abbrev;
2554 struct attribute attr;
2555 bfd_byte *info_ptr = stash->info_ptr;
2556 bfd_byte *end_ptr = info_ptr + unit_length;
2559 bfd_vma high_pc = 0;
2560 bfd *abfd = stash->bfd_ptr;
2561 bfd_boolean high_pc_relative = FALSE;
2563 version = read_2_bytes (abfd, info_ptr);
2565 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2566 if (offset_size == 4)
2567 abbrev_offset = read_4_bytes (abfd, info_ptr);
2569 abbrev_offset = read_8_bytes (abfd, info_ptr);
2570 info_ptr += offset_size;
2571 addr_size = read_1_byte (abfd, info_ptr);
2574 if (version != 2 && version != 3 && version != 4)
2576 (*_bfd_error_handler)
2577 (_("Dwarf Error: found dwarf version '%u', this reader"
2578 " only handles version 2, 3 and 4 information."), version);
2579 bfd_set_error (bfd_error_bad_value);
2583 if (addr_size > sizeof (bfd_vma))
2585 (*_bfd_error_handler)
2586 (_("Dwarf Error: found address size '%u', this reader"
2587 " can not handle sizes greater than '%u'."),
2589 (unsigned int) sizeof (bfd_vma));
2590 bfd_set_error (bfd_error_bad_value);
2594 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2596 (*_bfd_error_handler)
2597 ("Dwarf Error: found address size '%u', this reader"
2598 " can only handle address sizes '2', '4' and '8'.", addr_size);
2599 bfd_set_error (bfd_error_bad_value);
2603 /* Read the abbrevs for this compilation unit into a table. */
2604 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2608 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2609 info_ptr += bytes_read;
2610 if (! abbrev_number)
2612 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2614 bfd_set_error (bfd_error_bad_value);
2618 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2621 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2623 bfd_set_error (bfd_error_bad_value);
2627 amt = sizeof (struct comp_unit);
2628 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2632 unit->version = version;
2633 unit->addr_size = addr_size;
2634 unit->offset_size = offset_size;
2635 unit->abbrevs = abbrevs;
2636 unit->end_ptr = end_ptr;
2637 unit->stash = stash;
2638 unit->info_ptr_unit = info_ptr_unit;
2639 unit->sec_info_ptr = stash->sec_info_ptr;
2641 for (i = 0; i < abbrev->num_attrs; ++i)
2643 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2644 if (info_ptr == NULL)
2647 /* Store the data if it is of an attribute we want to keep in a
2648 partial symbol table. */
2651 case DW_AT_stmt_list:
2653 unit->line_offset = attr.u.val;
2657 unit->name = attr.u.str;
2661 low_pc = attr.u.val;
2662 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2663 this is the base address to use when reading location
2664 lists or range lists. */
2665 if (abbrev->tag == DW_TAG_compile_unit)
2666 unit->base_address = low_pc;
2670 high_pc = attr.u.val;
2671 high_pc_relative = attr.form != DW_FORM_addr;
2675 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2679 case DW_AT_comp_dir:
2681 char *comp_dir = attr.u.str;
2684 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2685 directory, get rid of it. */
2686 char *cp = strchr (comp_dir, ':');
2688 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2691 unit->comp_dir = comp_dir;
2699 if (high_pc_relative)
2703 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2707 unit->first_child_die_ptr = info_ptr;
2711 /* Return TRUE if UNIT may contain the address given by ADDR. When
2712 there are functions written entirely with inline asm statements, the
2713 range info in the compilation unit header may not be correct. We
2714 need to consult the line info table to see if a compilation unit
2715 really contains the given address. */
2718 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2720 struct arange *arange;
2725 arange = &unit->arange;
2728 if (addr >= arange->low && addr < arange->high)
2730 arange = arange->next;
2737 /* If UNIT contains ADDR, set the output parameters to the values for
2738 the line containing ADDR. The output parameters, FILENAME_PTR,
2739 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2742 Returns the range of addresses covered by the entry that was used
2743 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2746 comp_unit_find_nearest_line (struct comp_unit *unit,
2748 const char **filename_ptr,
2749 const char **functionname_ptr,
2750 unsigned int *linenumber_ptr,
2751 unsigned int *discriminator_ptr,
2752 struct dwarf2_debug *stash)
2755 struct funcinfo *function;
2760 if (! unit->line_table)
2762 if (! unit->stmtlist)
2768 unit->line_table = decode_line_info (unit, stash);
2770 if (! unit->line_table)
2776 if (unit->first_child_die_ptr < unit->end_ptr
2777 && ! scan_unit_for_symbols (unit))
2785 func_p = lookup_address_in_function_table (unit, addr,
2786 &function, functionname_ptr);
2787 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2788 stash->inliner_chain = function;
2790 return lookup_address_in_line_info_table (unit->line_table, addr,
2796 /* Check to see if line info is already decoded in a comp_unit.
2797 If not, decode it. Returns TRUE if no errors were encountered;
2801 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2802 struct dwarf2_debug *stash)
2807 if (! unit->line_table)
2809 if (! unit->stmtlist)
2815 unit->line_table = decode_line_info (unit, stash);
2817 if (! unit->line_table)
2823 if (unit->first_child_die_ptr < unit->end_ptr
2824 && ! scan_unit_for_symbols (unit))
2834 /* If UNIT contains SYM at ADDR, set the output parameters to the
2835 values for the line containing SYM. The output parameters,
2836 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2839 Return TRUE if UNIT contains SYM, and no errors were encountered;
2843 comp_unit_find_line (struct comp_unit *unit,
2846 const char **filename_ptr,
2847 unsigned int *linenumber_ptr,
2848 struct dwarf2_debug *stash)
2850 if (!comp_unit_maybe_decode_line_info (unit, stash))
2853 if (sym->flags & BSF_FUNCTION)
2854 return lookup_symbol_in_function_table (unit, sym, addr,
2858 return lookup_symbol_in_variable_table (unit, sym, addr,
2863 static struct funcinfo *
2864 reverse_funcinfo_list (struct funcinfo *head)
2866 struct funcinfo *rhead;
2867 struct funcinfo *temp;
2869 for (rhead = NULL; head; head = temp)
2871 temp = head->prev_func;
2872 head->prev_func = rhead;
2878 static struct varinfo *
2879 reverse_varinfo_list (struct varinfo *head)
2881 struct varinfo *rhead;
2882 struct varinfo *temp;
2884 for (rhead = NULL; head; head = temp)
2886 temp = head->prev_var;
2887 head->prev_var = rhead;
2893 /* Extract all interesting funcinfos and varinfos of a compilation
2894 unit into hash tables for faster lookup. Returns TRUE if no
2895 errors were enountered; FALSE otherwise. */
2898 comp_unit_hash_info (struct dwarf2_debug *stash,
2899 struct comp_unit *unit,
2900 struct info_hash_table *funcinfo_hash_table,
2901 struct info_hash_table *varinfo_hash_table)
2903 struct funcinfo* each_func;
2904 struct varinfo* each_var;
2905 bfd_boolean okay = TRUE;
2907 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2909 if (!comp_unit_maybe_decode_line_info (unit, stash))
2912 BFD_ASSERT (!unit->cached);
2914 /* To preserve the original search order, we went to visit the function
2915 infos in the reversed order of the list. However, making the list
2916 bi-directional use quite a bit of extra memory. So we reverse
2917 the list first, traverse the list in the now reversed order and
2918 finally reverse the list again to get back the original order. */
2919 unit->function_table = reverse_funcinfo_list (unit->function_table);
2920 for (each_func = unit->function_table;
2922 each_func = each_func->prev_func)
2924 /* Skip nameless functions. */
2925 if (each_func->name)
2926 /* There is no need to copy name string into hash table as
2927 name string is either in the dwarf string buffer or
2928 info in the stash. */
2929 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2930 (void*) each_func, FALSE);
2932 unit->function_table = reverse_funcinfo_list (unit->function_table);
2936 /* We do the same for variable infos. */
2937 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2938 for (each_var = unit->variable_table;
2940 each_var = each_var->prev_var)
2942 /* Skip stack vars and vars with no files or names. */
2943 if (each_var->stack == 0
2944 && each_var->file != NULL
2945 && each_var->name != NULL)
2946 /* There is no need to copy name string into hash table as
2947 name string is either in the dwarf string buffer or
2948 info in the stash. */
2949 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2950 (void*) each_var, FALSE);
2953 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2954 unit->cached = TRUE;
2958 /* Locate a section in a BFD containing debugging info. The search starts
2959 from the section after AFTER_SEC, or from the first section in the BFD if
2960 AFTER_SEC is NULL. The search works by examining the names of the
2961 sections. There are three permissiable names. The first two are given
2962 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
2963 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
2964 This is a variation on the .debug_info section which has a checksum
2965 describing the contents appended onto the name. This allows the linker to
2966 identify and discard duplicate debugging sections for different
2967 compilation units. */
2968 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2971 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
2972 asection *after_sec)
2977 if (after_sec == NULL)
2979 look = debug_sections[debug_info].uncompressed_name;
2980 msec = bfd_get_section_by_name (abfd, look);
2984 look = debug_sections[debug_info].compressed_name;
2987 msec = bfd_get_section_by_name (abfd, look);
2992 for (msec = abfd->sections; msec != NULL; msec = msec->next)
2993 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2999 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3001 look = debug_sections[debug_info].uncompressed_name;
3002 if (strcmp (msec->name, look) == 0)
3005 look = debug_sections[debug_info].compressed_name;
3006 if (look != NULL && strcmp (msec->name, look) == 0)
3009 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3016 /* Transfer VMAs from object file to separate debug file. */
3019 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3023 for (s = orig_bfd->sections, d = debug_bfd->sections;
3024 s != NULL && d != NULL;
3025 s = s->next, d = d->next)
3027 if ((d->flags & SEC_DEBUGGING) != 0)
3029 /* ??? Assumes 1-1 correspondence between sections in the
3031 if (strcmp (s->name, d->name) == 0)
3033 d->output_section = s->output_section;
3034 d->output_offset = s->output_offset;
3040 /* Unset vmas for adjusted sections in STASH. */
3043 unset_sections (struct dwarf2_debug *stash)
3046 struct adjusted_section *p;
3048 i = stash->adjusted_section_count;
3049 p = stash->adjusted_sections;
3050 for (; i > 0; i--, p++)
3051 p->section->vma = 0;
3054 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3055 relocatable object file. VMAs are normally all zero in relocatable
3056 object files, so if we want to distinguish locations in sections by
3057 address we need to set VMAs so the sections do not overlap. We
3058 also set VMA on .debug_info so that when we have multiple
3059 .debug_info sections (or the linkonce variant) they also do not
3060 overlap. The multiple .debug_info sections make up a single
3061 logical section. ??? We should probably do the same for other
3065 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3068 struct adjusted_section *p;
3070 const char *debug_info_name;
3072 if (stash->adjusted_section_count != 0)
3074 i = stash->adjusted_section_count;
3075 p = stash->adjusted_sections;
3076 for (; i > 0; i--, p++)
3077 p->section->vma = p->adj_vma;
3081 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3088 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3092 if ((sect->output_section != NULL
3093 && sect->output_section != sect
3094 && (sect->flags & SEC_DEBUGGING) == 0)
3098 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3099 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3101 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3107 if (abfd == stash->bfd_ptr)
3109 abfd = stash->bfd_ptr;
3113 stash->adjusted_section_count = -1;
3116 bfd_vma last_vma = 0, last_dwarf = 0;
3117 bfd_size_type amt = i * sizeof (struct adjusted_section);
3119 p = (struct adjusted_section *) bfd_malloc (amt);
3123 stash->adjusted_sections = p;
3124 stash->adjusted_section_count = i;
3131 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3136 if ((sect->output_section != NULL
3137 && sect->output_section != sect
3138 && (sect->flags & SEC_DEBUGGING) == 0)
3142 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3143 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3145 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3149 sz = sect->rawsize ? sect->rawsize : sect->size;
3153 BFD_ASSERT (sect->alignment_power == 0);
3154 sect->vma = last_dwarf;
3159 /* Align the new address to the current section
3161 last_vma = ((last_vma
3162 + ~((bfd_vma) -1 << sect->alignment_power))
3163 & ((bfd_vma) -1 << sect->alignment_power));
3164 sect->vma = last_vma;
3169 p->adj_vma = sect->vma;
3172 if (abfd == stash->bfd_ptr)
3174 abfd = stash->bfd_ptr;
3178 if (orig_bfd != stash->bfd_ptr)
3179 set_debug_vma (orig_bfd, stash->bfd_ptr);
3184 /* Look up a funcinfo by name using the given info hash table. If found,
3185 also update the locations pointed to by filename_ptr and linenumber_ptr.
3187 This function returns TRUE if a funcinfo that matches the given symbol
3188 and address is found with any error; otherwise it returns FALSE. */
3191 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3194 const char **filename_ptr,
3195 unsigned int *linenumber_ptr)
3197 struct funcinfo* each_func;
3198 struct funcinfo* best_fit = NULL;
3199 bfd_vma best_fit_len = 0;
3200 struct info_list_node *node;
3201 struct arange *arange;
3202 const char *name = bfd_asymbol_name (sym);
3203 asection *sec = bfd_get_section (sym);
3205 for (node = lookup_info_hash_table (hash_table, name);
3209 each_func = (struct funcinfo *) node->info;
3210 for (arange = &each_func->arange;
3212 arange = arange->next)
3214 if ((!each_func->sec || each_func->sec == sec)
3215 && addr >= arange->low
3216 && addr < arange->high
3218 || arange->high - arange->low < best_fit_len))
3220 best_fit = each_func;
3221 best_fit_len = arange->high - arange->low;
3228 best_fit->sec = sec;
3229 *filename_ptr = best_fit->file;
3230 *linenumber_ptr = best_fit->line;
3237 /* Look up a varinfo by name using the given info hash table. If found,
3238 also update the locations pointed to by filename_ptr and linenumber_ptr.
3240 This function returns TRUE if a varinfo that matches the given symbol
3241 and address is found with any error; otherwise it returns FALSE. */
3244 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3247 const char **filename_ptr,
3248 unsigned int *linenumber_ptr)
3250 const char *name = bfd_asymbol_name (sym);
3251 asection *sec = bfd_get_section (sym);
3252 struct varinfo* each;
3253 struct info_list_node *node;
3255 for (node = lookup_info_hash_table (hash_table, name);
3259 each = (struct varinfo *) node->info;
3260 if (each->addr == addr
3261 && (!each->sec || each->sec == sec))
3264 *filename_ptr = each->file;
3265 *linenumber_ptr = each->line;
3273 /* Update the funcinfo and varinfo info hash tables if they are
3274 not up to date. Returns TRUE if there is no error; otherwise
3275 returns FALSE and disable the info hash tables. */
3278 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3280 struct comp_unit *each;
3282 /* Exit if hash tables are up-to-date. */
3283 if (stash->all_comp_units == stash->hash_units_head)
3286 if (stash->hash_units_head)
3287 each = stash->hash_units_head->prev_unit;
3289 each = stash->last_comp_unit;
3293 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3294 stash->varinfo_hash_table))
3296 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3299 each = each->prev_unit;
3302 stash->hash_units_head = stash->all_comp_units;
3306 /* Check consistency of info hash tables. This is for debugging only. */
3308 static void ATTRIBUTE_UNUSED
3309 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3311 struct comp_unit *each_unit;
3312 struct funcinfo *each_func;
3313 struct varinfo *each_var;
3314 struct info_list_node *node;
3317 for (each_unit = stash->all_comp_units;
3319 each_unit = each_unit->next_unit)
3321 for (each_func = each_unit->function_table;
3323 each_func = each_func->prev_func)
3325 if (!each_func->name)
3327 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3331 while (node && !found)
3333 found = node->info == each_func;
3339 for (each_var = each_unit->variable_table;
3341 each_var = each_var->prev_var)
3343 if (!each_var->name || !each_var->file || each_var->stack)
3345 node = lookup_info_hash_table (stash->varinfo_hash_table,
3349 while (node && !found)
3351 found = node->info == each_var;
3359 /* Check to see if we want to enable the info hash tables, which consume
3360 quite a bit of memory. Currently we only check the number times
3361 bfd_dwarf2_find_line is called. In the future, we may also want to
3362 take the number of symbols into account. */
3365 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3367 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3369 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3372 /* FIXME: Maybe we should check the reduce_memory_overheads
3373 and optimize fields in the bfd_link_info structure ? */
3375 /* Create hash tables. */
3376 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3377 stash->varinfo_hash_table = create_info_hash_table (abfd);
3378 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3380 /* Turn off info hashes if any allocation above fails. */
3381 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3384 /* We need a forced update so that the info hash tables will
3385 be created even though there is no compilation unit. That
3386 happens if STASH_INFO_HASH_TRIGGER is 0. */
3387 stash_maybe_update_info_hash_tables (stash);
3388 stash->info_hash_status = STASH_INFO_HASH_ON;
3391 /* Find the file and line associated with a symbol and address using the
3392 info hash tables of a stash. If there is a match, the function returns
3393 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3394 otherwise it returns FALSE. */
3397 stash_find_line_fast (struct dwarf2_debug *stash,
3400 const char **filename_ptr,
3401 unsigned int *linenumber_ptr)
3403 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3405 if (sym->flags & BSF_FUNCTION)
3406 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3407 filename_ptr, linenumber_ptr);
3408 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3409 filename_ptr, linenumber_ptr);
3412 /* Save current section VMAs. */
3415 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3420 if (abfd->section_count == 0)
3422 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3423 if (stash->sec_vma == NULL)
3425 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3427 if (s->output_section != NULL)
3428 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3430 stash->sec_vma[i] = s->vma;
3435 /* Compare current section VMAs against those at the time the stash
3436 was created. If find_nearest_line is used in linker warnings or
3437 errors early in the link process, the debug info stash will be
3438 invalid for later calls. This is because we relocate debug info
3439 sections, so the stashed section contents depend on symbol values,
3440 which in turn depend on section VMAs. */
3443 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3448 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3452 if (s->output_section != NULL)
3453 vma = s->output_section->vma + s->output_offset;
3456 if (vma != stash->sec_vma[i])
3462 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3463 If DEBUG_BFD is not specified, we read debug information from ABFD
3464 or its gnu_debuglink. The results will be stored in PINFO.
3465 The function returns TRUE iff debug information is ready. */
3468 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3469 const struct dwarf_debug_section *debug_sections,
3472 bfd_boolean do_place)
3474 bfd_size_type amt = sizeof (struct dwarf2_debug);
3475 bfd_size_type total_size;
3477 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3481 if (section_vma_same (abfd, stash))
3483 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3484 memset (stash, 0, amt);
3488 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3492 stash->debug_sections = debug_sections;
3493 stash->syms = symbols;
3494 if (!save_section_vma (abfd, stash))
3499 if (debug_bfd == NULL)
3502 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3503 if (msec == NULL && abfd == debug_bfd)
3505 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3507 if (debug_filename == NULL)
3508 /* No dwarf2 info, and no gnu_debuglink to follow.
3509 Note that at this point the stash has been allocated, but
3510 contains zeros. This lets future calls to this function
3511 fail more quickly. */
3514 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3515 || ! bfd_check_format (debug_bfd, bfd_object)
3516 || (msec = find_debug_info (debug_bfd,
3517 debug_sections, NULL)) == NULL
3518 || !bfd_generic_link_read_symbols (debug_bfd))
3521 bfd_close (debug_bfd);
3522 /* FIXME: Should we report our failure to follow the debuglink ? */
3523 free (debug_filename);
3527 symbols = bfd_get_outsymbols (debug_bfd);
3528 stash->syms = symbols;
3529 stash->close_on_cleanup = TRUE;
3531 stash->bfd_ptr = debug_bfd;
3534 && !place_sections (abfd, stash))
3537 /* There can be more than one DWARF2 info section in a BFD these
3538 days. First handle the easy case when there's only one. If
3539 there's more than one, try case two: none of the sections is
3540 compressed. In that case, read them all in and produce one
3541 large stash. We do this in two passes - in the first pass we
3542 just accumulate the section sizes, and in the second pass we
3543 read in the section's contents. (The allows us to avoid
3544 reallocing the data as we add sections to the stash.) If
3545 some or all sections are compressed, then do things the slow
3546 way, with a bunch of reallocs. */
3548 if (! find_debug_info (debug_bfd, debug_sections, msec))
3550 /* Case 1: only one info section. */
3551 total_size = msec->size;
3552 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3554 &stash->info_ptr_memory, &total_size))
3559 /* Case 2: multiple sections. */
3560 for (total_size = 0;
3562 msec = find_debug_info (debug_bfd, debug_sections, msec))
3563 total_size += msec->size;
3565 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3566 if (stash->info_ptr_memory == NULL)
3570 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3572 msec = find_debug_info (debug_bfd, debug_sections, msec))
3580 if (!(bfd_simple_get_relocated_section_contents
3581 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3589 stash->info_ptr = stash->info_ptr_memory;
3590 stash->info_ptr_end = stash->info_ptr + total_size;
3591 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
3592 stash->sec_info_ptr = stash->info_ptr;
3596 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3597 then find the nearest source code location corresponding to
3598 the address SECTION + OFFSET.
3599 Returns TRUE if the line is found without error and fills in
3600 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3601 NULL the FUNCTIONNAME_PTR is also filled in.
3602 SYMBOLS contains the symbol table for ABFD.
3603 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3604 ADDR_SIZE is the number of bytes in the initial .debug_info length
3605 field and in the abbreviation offset, or zero to indicate that the
3606 default value should be used. */
3609 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3614 const char **filename_ptr,
3615 const char **functionname_ptr,
3616 unsigned int *linenumber_ptr,
3617 unsigned int *discriminator_ptr,
3618 const struct dwarf_debug_section *debug_sections,
3619 unsigned int addr_size,
3622 /* Read each compilation unit from the section .debug_info, and check
3623 to see if it contains the address we are searching for. If yes,
3624 lookup the address, and return the line number info. If no, go
3625 on to the next compilation unit.
3627 We keep a list of all the previously read compilation units, and
3628 a pointer to the next un-read compilation unit. Check the
3629 previously read units before reading more. */
3630 struct dwarf2_debug *stash;
3631 /* What address are we looking for? */
3633 struct comp_unit* each;
3634 bfd_boolean found = FALSE;
3635 bfd_boolean do_line;
3637 *filename_ptr = NULL;
3638 if (functionname_ptr != NULL)
3639 *functionname_ptr = NULL;
3640 *linenumber_ptr = 0;
3641 if (discriminator_ptr)
3642 *discriminator_ptr = 0;
3644 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
3646 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
3649 stash = (struct dwarf2_debug *) *pinfo;
3651 do_line = symbol != NULL;
3654 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
3655 section = bfd_get_section (symbol);
3656 addr = symbol->value;
3660 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
3664 if (section->output_section)
3665 addr += section->output_section->vma + section->output_offset;
3667 addr += section->vma;
3669 /* A null info_ptr indicates that there is no dwarf2 info
3670 (or that an error occured while setting up the stash). */
3671 if (! stash->info_ptr)
3674 stash->inliner_chain = NULL;
3676 /* Check the previously read comp. units first. */
3679 /* The info hash tables use quite a bit of memory. We may not want to
3680 always use them. We use some heuristics to decide if and when to
3682 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3683 stash_maybe_enable_info_hash_tables (abfd, stash);
3685 /* Keep info hash table up to date if they are available. Note that we
3686 may disable the hash tables if there is any error duing update. */
3687 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3688 stash_maybe_update_info_hash_tables (stash);
3690 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3692 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3699 /* Check the previously read comp. units first. */
3700 for (each = stash->all_comp_units; each; each = each->next_unit)
3701 if ((symbol->flags & BSF_FUNCTION) == 0
3702 || each->arange.high == 0
3703 || comp_unit_contains_address (each, addr))
3705 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3706 linenumber_ptr, stash);
3714 bfd_vma min_range = (bfd_vma) -1;
3715 const char * local_filename = NULL;
3716 const char * local_functionname = NULL;
3717 unsigned int local_linenumber = 0;
3718 unsigned int local_discriminator = 0;
3720 for (each = stash->all_comp_units; each; each = each->next_unit)
3722 bfd_vma range = (bfd_vma) -1;
3724 found = ((each->arange.high == 0
3725 || comp_unit_contains_address (each, addr))
3726 && (range = comp_unit_find_nearest_line (each, addr,
3728 & local_functionname,
3730 & local_discriminator,
3734 /* PRs 15935 15994: Bogus debug information may have provided us
3735 with an erroneous match. We attempt to counter this by
3736 selecting the match that has the smallest address range
3737 associated with it. (We are assuming that corrupt debug info
3738 will tend to result in extra large address ranges rather than
3739 extra small ranges).
3741 This does mean that we scan through all of the CUs associated
3742 with the bfd each time this function is called. But this does
3743 have the benefit of producing consistent results every time the
3744 function is called. */
3745 if (range <= min_range)
3747 if (filename_ptr && local_filename)
3748 * filename_ptr = local_filename;
3749 if (functionname_ptr && local_functionname)
3750 * functionname_ptr = local_functionname;
3751 if (discriminator_ptr && local_discriminator)
3752 * discriminator_ptr = local_discriminator;
3753 if (local_linenumber)
3754 * linenumber_ptr = local_linenumber;
3760 if (* linenumber_ptr)
3767 /* The DWARF2 spec says that the initial length field, and the
3768 offset of the abbreviation table, should both be 4-byte values.
3769 However, some compilers do things differently. */
3772 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3774 /* Read each remaining comp. units checking each as they are read. */
3775 while (stash->info_ptr < stash->info_ptr_end)
3778 unsigned int offset_size = addr_size;
3779 bfd_byte *info_ptr_unit = stash->info_ptr;
3781 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
3782 /* A 0xffffff length is the DWARF3 way of indicating
3783 we use 64-bit offsets, instead of 32-bit offsets. */
3784 if (length == 0xffffffff)
3787 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3788 stash->info_ptr += 12;
3790 /* A zero length is the IRIX way of indicating 64-bit offsets,
3791 mostly because the 64-bit length will generally fit in 32
3792 bits, and the endianness helps. */
3793 else if (length == 0)
3796 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3797 stash->info_ptr += 8;
3799 /* In the absence of the hints above, we assume 32-bit DWARF2
3800 offsets even for targets with 64-bit addresses, because:
3801 a) most of the time these targets will not have generated
3802 more than 2Gb of debug info and so will not need 64-bit
3805 b) if they do use 64-bit offsets but they are not using
3806 the size hints that are tested for above then they are
3807 not conforming to the DWARF3 standard anyway. */
3808 else if (addr_size == 8)
3811 stash->info_ptr += 4;
3814 stash->info_ptr += 4;
3818 each = parse_comp_unit (stash, length, info_ptr_unit,
3821 /* The dwarf information is damaged, don't trust it any
3824 stash->info_ptr += length;
3826 if (stash->all_comp_units)
3827 stash->all_comp_units->prev_unit = each;
3829 stash->last_comp_unit = each;
3831 each->next_unit = stash->all_comp_units;
3832 stash->all_comp_units = each;
3834 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3835 compilation units. If we don't have them (i.e.,
3836 unit->high == 0), we need to consult the line info table
3837 to see if a compilation unit contains the given
3840 found = (((symbol->flags & BSF_FUNCTION) == 0
3841 || each->arange.high == 0
3842 || comp_unit_contains_address (each, addr))
3843 && comp_unit_find_line (each, symbol, addr,
3848 found = ((each->arange.high == 0
3849 || comp_unit_contains_address (each, addr))
3850 && comp_unit_find_nearest_line (each, addr,
3857 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3858 == stash->sec->size)
3860 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
3862 stash->sec_info_ptr = stash->info_ptr;
3871 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3872 unset_sections (stash);
3878 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3879 const char **filename_ptr,
3880 const char **functionname_ptr,
3881 unsigned int *linenumber_ptr,
3884 struct dwarf2_debug *stash;
3886 stash = (struct dwarf2_debug *) *pinfo;
3889 struct funcinfo *func = stash->inliner_chain;
3891 if (func && func->caller_func)
3893 *filename_ptr = func->caller_file;
3894 *functionname_ptr = func->caller_func->name;
3895 *linenumber_ptr = func->caller_line;
3896 stash->inliner_chain = func->caller_func;
3905 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
3907 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3908 struct comp_unit *each;
3910 if (abfd == NULL || stash == NULL)
3913 for (each = stash->all_comp_units; each; each = each->next_unit)
3915 struct abbrev_info **abbrevs = each->abbrevs;
3916 struct funcinfo *function_table = each->function_table;
3917 struct varinfo *variable_table = each->variable_table;
3920 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3922 struct abbrev_info *abbrev = abbrevs[i];
3926 free (abbrev->attrs);
3927 abbrev = abbrev->next;
3931 if (each->line_table)
3933 free (each->line_table->dirs);
3934 free (each->line_table->files);
3937 while (function_table)
3939 if (function_table->file)
3941 free (function_table->file);
3942 function_table->file = NULL;
3945 if (function_table->caller_file)
3947 free (function_table->caller_file);
3948 function_table->caller_file = NULL;
3950 function_table = function_table->prev_func;
3953 while (variable_table)
3955 if (variable_table->file)
3957 free (variable_table->file);
3958 variable_table->file = NULL;
3961 variable_table = variable_table->prev_var;
3965 if (stash->dwarf_abbrev_buffer)
3966 free (stash->dwarf_abbrev_buffer);
3967 if (stash->dwarf_line_buffer)
3968 free (stash->dwarf_line_buffer);
3969 if (stash->dwarf_str_buffer)
3970 free (stash->dwarf_str_buffer);
3971 if (stash->dwarf_ranges_buffer)
3972 free (stash->dwarf_ranges_buffer);
3973 if (stash->info_ptr_memory)
3974 free (stash->info_ptr_memory);
3975 if (stash->close_on_cleanup)
3976 bfd_close (stash->bfd_ptr);
3977 if (stash->alt_dwarf_str_buffer)
3978 free (stash->alt_dwarf_str_buffer);
3979 if (stash->alt_dwarf_info_buffer)
3980 free (stash->alt_dwarf_info_buffer);
3982 free (stash->sec_vma);
3983 if (stash->adjusted_sections)
3984 free (stash->adjusted_sections);
3985 if (stash->alt_bfd_ptr)
3986 bfd_close (stash->alt_bfd_ptr);