2 Copyright (C) 1994-2017 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 original bfd for which debug was loaded. This is what
104 we use to compare and so check that the cached debug data is still
105 valid - it saves having to possibly dereference the gnu_debuglink each
109 /* Pointer to the bfd, section and address of the beginning of the
110 section. The bfd might be different than expected because of
111 gnu_debuglink sections. */
114 bfd_byte *sec_info_ptr;
116 /* Support for alternate debug info sections created by the DWZ utility:
117 This includes a pointer to an alternate bfd which contains *extra*,
118 possibly duplicate debug sections, and pointers to the loaded
119 .debug_str and .debug_info sections from this bfd. */
121 bfd_byte * alt_dwarf_str_buffer;
122 bfd_size_type alt_dwarf_str_size;
123 bfd_byte * alt_dwarf_info_buffer;
124 bfd_size_type alt_dwarf_info_size;
126 /* A pointer to the memory block allocated for info_ptr. Neither
127 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
128 beginning of the malloc block. This is used only to free the
130 bfd_byte *info_ptr_memory;
132 /* Pointer to the symbol table. */
135 /* Pointer to the .debug_abbrev section loaded into memory. */
136 bfd_byte *dwarf_abbrev_buffer;
138 /* Length of the loaded .debug_abbrev section. */
139 bfd_size_type dwarf_abbrev_size;
141 /* Buffer for decode_line_info. */
142 bfd_byte *dwarf_line_buffer;
144 /* Length of the loaded .debug_line section. */
145 bfd_size_type dwarf_line_size;
147 /* Pointer to the .debug_str section loaded into memory. */
148 bfd_byte *dwarf_str_buffer;
150 /* Length of the loaded .debug_str section. */
151 bfd_size_type dwarf_str_size;
153 /* Pointer to the .debug_ranges section loaded into memory. */
154 bfd_byte *dwarf_ranges_buffer;
156 /* Length of the loaded .debug_ranges section. */
157 bfd_size_type dwarf_ranges_size;
159 /* If the most recent call to bfd_find_nearest_line was given an
160 address in an inlined function, preserve a pointer into the
161 calling chain for subsequent calls to bfd_find_inliner_info to
163 struct funcinfo *inliner_chain;
165 /* Section VMAs at the time the stash was built. */
168 /* Number of sections whose VMA we must adjust. */
169 int adjusted_section_count;
171 /* Array of sections with adjusted VMA. */
172 struct adjusted_section *adjusted_sections;
174 /* Number of times find_line is called. This is used in
175 the heuristic for enabling the info hash tables. */
178 #define STASH_INFO_HASH_TRIGGER 100
180 /* Hash table mapping symbol names to function infos. */
181 struct info_hash_table *funcinfo_hash_table;
183 /* Hash table mapping symbol names to variable infos. */
184 struct info_hash_table *varinfo_hash_table;
186 /* Head of comp_unit list in the last hash table update. */
187 struct comp_unit *hash_units_head;
189 /* Status of info hash. */
190 int info_hash_status;
191 #define STASH_INFO_HASH_OFF 0
192 #define STASH_INFO_HASH_ON 1
193 #define STASH_INFO_HASH_DISABLED 2
195 /* True if we opened bfd_ptr. */
196 bfd_boolean close_on_cleanup;
206 /* A minimal decoding of DWARF2 compilation units. We only decode
207 what's needed to get to the line number information. */
211 /* Chain the previously read compilation units. */
212 struct comp_unit *next_unit;
214 /* Likewise, chain the compilation unit read after this one.
215 The comp units are stored in reversed reading order. */
216 struct comp_unit *prev_unit;
218 /* Keep the bfd convenient (for memory allocation). */
221 /* The lowest and highest addresses contained in this compilation
222 unit as specified in the compilation unit header. */
223 struct arange arange;
225 /* The DW_AT_name attribute (for error messages). */
228 /* The abbrev hash table. */
229 struct abbrev_info **abbrevs;
231 /* DW_AT_language. */
234 /* Note that an error was found by comp_unit_find_nearest_line. */
237 /* The DW_AT_comp_dir attribute. */
240 /* TRUE if there is a line number table associated with this comp. unit. */
243 /* Pointer to the current comp_unit so that we can find a given entry
245 bfd_byte *info_ptr_unit;
247 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
248 bfd_byte *sec_info_ptr;
250 /* The offset into .debug_line of the line number table. */
251 unsigned long line_offset;
253 /* Pointer to the first child die for the comp unit. */
254 bfd_byte *first_child_die_ptr;
256 /* The end of the comp unit. */
259 /* The decoded line number, NULL if not yet decoded. */
260 struct line_info_table *line_table;
262 /* A list of the functions found in this comp. unit. */
263 struct funcinfo *function_table;
265 /* A table of function information references searchable by address. */
266 struct lookup_funcinfo *lookup_funcinfo_table;
268 /* Number of functions in the function_table and sorted_function_table. */
269 bfd_size_type number_of_functions;
271 /* A list of the variables found in this comp. unit. */
272 struct varinfo *variable_table;
274 /* Pointer to dwarf2_debug structure. */
275 struct dwarf2_debug *stash;
277 /* DWARF format version for this unit - from unit header. */
280 /* Address size for this unit - from unit header. */
281 unsigned char addr_size;
283 /* Offset size for this unit - from unit header. */
284 unsigned char offset_size;
286 /* Base address for this unit - from DW_AT_low_pc attribute of
287 DW_TAG_compile_unit DIE */
288 bfd_vma base_address;
290 /* TRUE if symbols are cached in hash table for faster lookup by name. */
294 /* This data structure holds the information of an abbrev. */
297 unsigned int number; /* Number identifying abbrev. */
298 enum dwarf_tag tag; /* DWARF tag. */
299 int has_children; /* Boolean. */
300 unsigned int num_attrs; /* Number of attributes. */
301 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
302 struct abbrev_info *next; /* Next in chain. */
307 enum dwarf_attribute name;
308 enum dwarf_form form;
311 /* Map of uncompressed DWARF debug section name to compressed one. It
312 is terminated by NULL uncompressed_name. */
314 const struct dwarf_debug_section dwarf_debug_sections[] =
316 { ".debug_abbrev", ".zdebug_abbrev" },
317 { ".debug_aranges", ".zdebug_aranges" },
318 { ".debug_frame", ".zdebug_frame" },
319 { ".debug_info", ".zdebug_info" },
320 { ".debug_info", ".zdebug_info" },
321 { ".debug_line", ".zdebug_line" },
322 { ".debug_loc", ".zdebug_loc" },
323 { ".debug_macinfo", ".zdebug_macinfo" },
324 { ".debug_macro", ".zdebug_macro" },
325 { ".debug_pubnames", ".zdebug_pubnames" },
326 { ".debug_pubtypes", ".zdebug_pubtypes" },
327 { ".debug_ranges", ".zdebug_ranges" },
328 { ".debug_static_func", ".zdebug_static_func" },
329 { ".debug_static_vars", ".zdebug_static_vars" },
330 { ".debug_str", ".zdebug_str", },
331 { ".debug_str", ".zdebug_str", },
332 { ".debug_types", ".zdebug_types" },
333 /* GNU DWARF 1 extensions */
334 { ".debug_sfnames", ".zdebug_sfnames" },
335 { ".debug_srcinfo", ".zebug_srcinfo" },
336 /* SGI/MIPS DWARF 2 extensions */
337 { ".debug_funcnames", ".zdebug_funcnames" },
338 { ".debug_typenames", ".zdebug_typenames" },
339 { ".debug_varnames", ".zdebug_varnames" },
340 { ".debug_weaknames", ".zdebug_weaknames" },
344 /* NB/ Numbers in this enum must match up with indicies
345 into the dwarf_debug_sections[] array above. */
346 enum dwarf_debug_section_enum
373 #ifndef ABBREV_HASH_SIZE
374 #define ABBREV_HASH_SIZE 121
376 #ifndef ATTR_ALLOC_CHUNK
377 #define ATTR_ALLOC_CHUNK 4
380 /* Variable and function hash tables. This is used to speed up look-up
381 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
382 In order to share code between variable and function infos, we use
383 a list of untyped pointer for all variable/function info associated with
384 a symbol. We waste a bit of memory for list with one node but that
385 simplifies the code. */
387 struct info_list_node
389 struct info_list_node *next;
393 /* Info hash entry. */
394 struct info_hash_entry
396 struct bfd_hash_entry root;
397 struct info_list_node *head;
400 struct info_hash_table
402 struct bfd_hash_table base;
405 /* Function to create a new entry in info hash table. */
407 static struct bfd_hash_entry *
408 info_hash_table_newfunc (struct bfd_hash_entry *entry,
409 struct bfd_hash_table *table,
412 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
414 /* Allocate the structure if it has not already been allocated by a
418 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
424 /* Call the allocation method of the base class. */
425 ret = ((struct info_hash_entry *)
426 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
428 /* Initialize the local fields here. */
432 return (struct bfd_hash_entry *) ret;
435 /* Function to create a new info hash table. It returns a pointer to the
436 newly created table or NULL if there is any error. We need abfd
437 solely for memory allocation. */
439 static struct info_hash_table *
440 create_info_hash_table (bfd *abfd)
442 struct info_hash_table *hash_table;
444 hash_table = ((struct info_hash_table *)
445 bfd_alloc (abfd, sizeof (struct info_hash_table)));
449 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
450 sizeof (struct info_hash_entry)))
452 bfd_release (abfd, hash_table);
459 /* Insert an info entry into an info hash table. We do not check of
460 duplicate entries. Also, the caller need to guarantee that the
461 right type of info in inserted as info is passed as a void* pointer.
462 This function returns true if there is no error. */
465 insert_info_hash_table (struct info_hash_table *hash_table,
470 struct info_hash_entry *entry;
471 struct info_list_node *node;
473 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
478 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
484 node->next = entry->head;
490 /* Look up an info entry list from an info hash table. Return NULL
493 static struct info_list_node *
494 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
496 struct info_hash_entry *entry;
498 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
500 return entry ? entry->head : NULL;
503 /* Read a section into its appropriate place in the dwarf2_debug
504 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
505 not NULL, use bfd_simple_get_relocated_section_contents to read the
506 section contents, otherwise use bfd_get_section_contents. Fail if
507 the located section does not contain at least OFFSET bytes. */
510 read_section (bfd * abfd,
511 const struct dwarf_debug_section *sec,
514 bfd_byte ** section_buffer,
515 bfd_size_type * section_size)
518 const char *section_name = sec->uncompressed_name;
520 /* The section may have already been read. */
521 if (*section_buffer == NULL)
523 msec = bfd_get_section_by_name (abfd, section_name);
526 section_name = sec->compressed_name;
527 if (section_name != NULL)
528 msec = bfd_get_section_by_name (abfd, section_name);
532 _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
533 sec->uncompressed_name);
534 bfd_set_error (bfd_error_bad_value);
538 *section_size = msec->rawsize ? msec->rawsize : msec->size;
542 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
543 if (! *section_buffer)
548 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
549 if (! *section_buffer)
551 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
557 /* It is possible to get a bad value for the offset into the section
558 that the client wants. Validate it here to avoid trouble later. */
559 if (offset != 0 && offset >= *section_size)
561 /* xgettext: c-format */
562 _bfd_error_handler (_("Dwarf Error: Offset (%lu)"
563 " greater than or equal to %s size (%lu)."),
564 (long) offset, section_name, *section_size);
565 bfd_set_error (bfd_error_bad_value);
572 /* Read dwarf information from a buffer. */
575 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
579 return bfd_get_8 (abfd, buf);
583 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
587 return bfd_get_signed_8 (abfd, buf);
591 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
595 return bfd_get_16 (abfd, buf);
599 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
603 return bfd_get_32 (abfd, buf);
607 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
611 return bfd_get_64 (abfd, buf);
615 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
618 unsigned int size ATTRIBUTE_UNUSED)
620 if (buf + size > end)
625 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
626 Returns the number of characters in the string, *including* the NUL byte,
627 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
628 at or beyond BUF_END will not be read. Returns NULL if there was a
629 problem, or if the string is empty. */
632 read_string (bfd * abfd ATTRIBUTE_UNUSED,
635 unsigned int * bytes_read_ptr)
641 * bytes_read_ptr = 0;
647 * bytes_read_ptr = 1;
651 while (buf < buf_end)
654 * bytes_read_ptr = buf - str;
658 * bytes_read_ptr = buf - str;
662 /* Reads an offset from BUF and then locates the string at this offset
663 inside the debug string section. Returns a pointer to the string.
664 Returns the number of bytes read from BUF, *not* the length of the string,
665 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
666 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
667 a problem, or if the string is empty. Does not check for NUL termination
671 read_indirect_string (struct comp_unit * unit,
674 unsigned int * bytes_read_ptr)
677 struct dwarf2_debug *stash = unit->stash;
680 if (buf + unit->offset_size > buf_end)
682 * bytes_read_ptr = 0;
686 if (unit->offset_size == 4)
687 offset = read_4_bytes (unit->abfd, buf, buf_end);
689 offset = read_8_bytes (unit->abfd, buf, buf_end);
691 *bytes_read_ptr = unit->offset_size;
693 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
695 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
698 if (offset >= stash->dwarf_str_size)
700 str = (char *) stash->dwarf_str_buffer + offset;
706 /* Like read_indirect_string but uses a .debug_str located in
707 an alternate file pointed to by the .gnu_debugaltlink section.
708 Used to impement DW_FORM_GNU_strp_alt. */
711 read_alt_indirect_string (struct comp_unit * unit,
714 unsigned int * bytes_read_ptr)
717 struct dwarf2_debug *stash = unit->stash;
720 if (buf + unit->offset_size > buf_end)
722 * bytes_read_ptr = 0;
726 if (unit->offset_size == 4)
727 offset = read_4_bytes (unit->abfd, buf, buf_end);
729 offset = read_8_bytes (unit->abfd, buf, buf_end);
731 *bytes_read_ptr = unit->offset_size;
733 if (stash->alt_bfd_ptr == NULL)
736 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
738 if (debug_filename == NULL)
741 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
742 || ! bfd_check_format (debug_bfd, bfd_object))
745 bfd_close (debug_bfd);
747 /* FIXME: Should we report our failure to follow the debuglink ? */
748 free (debug_filename);
751 stash->alt_bfd_ptr = debug_bfd;
754 if (! read_section (unit->stash->alt_bfd_ptr,
755 stash->debug_sections + debug_str_alt,
756 NULL, /* FIXME: Do we need to load alternate symbols ? */
758 &stash->alt_dwarf_str_buffer,
759 &stash->alt_dwarf_str_size))
762 if (offset >= stash->alt_dwarf_str_size)
764 str = (char *) stash->alt_dwarf_str_buffer + offset;
771 /* Resolve an alternate reference from UNIT at OFFSET.
772 Returns a pointer into the loaded alternate CU upon success
773 or NULL upon failure. */
776 read_alt_indirect_ref (struct comp_unit * unit,
779 struct dwarf2_debug *stash = unit->stash;
781 if (stash->alt_bfd_ptr == NULL)
784 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
786 if (debug_filename == NULL)
789 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
790 || ! bfd_check_format (debug_bfd, bfd_object))
793 bfd_close (debug_bfd);
795 /* FIXME: Should we report our failure to follow the debuglink ? */
796 free (debug_filename);
799 stash->alt_bfd_ptr = debug_bfd;
802 if (! read_section (unit->stash->alt_bfd_ptr,
803 stash->debug_sections + debug_info_alt,
804 NULL, /* FIXME: Do we need to load alternate symbols ? */
806 &stash->alt_dwarf_info_buffer,
807 &stash->alt_dwarf_info_size))
810 if (offset >= stash->alt_dwarf_info_size)
812 return stash->alt_dwarf_info_buffer + offset;
816 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
820 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
821 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
823 if (buf + unit->addr_size > buf_end)
828 switch (unit->addr_size)
831 return bfd_get_signed_64 (unit->abfd, buf);
833 return bfd_get_signed_32 (unit->abfd, buf);
835 return bfd_get_signed_16 (unit->abfd, buf);
842 switch (unit->addr_size)
845 return bfd_get_64 (unit->abfd, buf);
847 return bfd_get_32 (unit->abfd, buf);
849 return bfd_get_16 (unit->abfd, buf);
856 /* Lookup an abbrev_info structure in the abbrev hash table. */
858 static struct abbrev_info *
859 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
861 unsigned int hash_number;
862 struct abbrev_info *abbrev;
864 hash_number = number % ABBREV_HASH_SIZE;
865 abbrev = abbrevs[hash_number];
869 if (abbrev->number == number)
872 abbrev = abbrev->next;
878 /* In DWARF version 2, the description of the debugging information is
879 stored in a separate .debug_abbrev section. Before we read any
880 dies from a section we read in all abbreviations and install them
883 static struct abbrev_info**
884 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
886 struct abbrev_info **abbrevs;
887 bfd_byte *abbrev_ptr;
888 bfd_byte *abbrev_end;
889 struct abbrev_info *cur_abbrev;
890 unsigned int abbrev_number, bytes_read, abbrev_name;
891 unsigned int abbrev_form, hash_number;
894 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
896 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
899 if (offset >= stash->dwarf_abbrev_size)
902 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
903 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
907 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
908 abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
909 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
910 abbrev_ptr += bytes_read;
912 /* Loop until we reach an abbrev number of 0. */
913 while (abbrev_number)
915 amt = sizeof (struct abbrev_info);
916 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
917 if (cur_abbrev == NULL)
920 /* Read in abbrev header. */
921 cur_abbrev->number = abbrev_number;
922 cur_abbrev->tag = (enum dwarf_tag)
923 _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
925 abbrev_ptr += bytes_read;
926 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
929 /* Now read in declarations. */
930 abbrev_name = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
932 abbrev_ptr += bytes_read;
933 abbrev_form = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
935 abbrev_ptr += bytes_read;
939 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
941 struct attr_abbrev *tmp;
943 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
944 amt *= sizeof (struct attr_abbrev);
945 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
950 for (i = 0; i < ABBREV_HASH_SIZE; i++)
952 struct abbrev_info *abbrev = abbrevs[i];
956 free (abbrev->attrs);
957 abbrev = abbrev->next;
962 cur_abbrev->attrs = tmp;
965 cur_abbrev->attrs[cur_abbrev->num_attrs].name
966 = (enum dwarf_attribute) abbrev_name;
967 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
968 = (enum dwarf_form) abbrev_form;
969 abbrev_name = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
971 abbrev_ptr += bytes_read;
972 abbrev_form = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
974 abbrev_ptr += bytes_read;
977 hash_number = abbrev_number % ABBREV_HASH_SIZE;
978 cur_abbrev->next = abbrevs[hash_number];
979 abbrevs[hash_number] = cur_abbrev;
981 /* Get next abbreviation.
982 Under Irix6 the abbreviations for a compilation unit are not
983 always properly terminated with an abbrev number of 0.
984 Exit loop if we encounter an abbreviation which we have
985 already read (which means we are about to read the abbreviations
986 for the next compile unit) or if the end of the abbreviation
988 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
989 >= stash->dwarf_abbrev_size)
991 abbrev_number = _bfd_safe_read_leb128 (abfd, abbrev_ptr,
992 &bytes_read, FALSE, abbrev_end);
993 abbrev_ptr += bytes_read;
994 if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
1001 /* Returns true if the form is one which has a string value. */
1003 static inline bfd_boolean
1004 is_str_attr (enum dwarf_form form)
1006 return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
1009 /* Read and fill in the value of attribute ATTR as described by FORM.
1010 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1011 Returns an updated INFO_PTR taking into account the amount of data read. */
1014 read_attribute_value (struct attribute * attr,
1016 struct comp_unit * unit,
1017 bfd_byte * info_ptr,
1018 bfd_byte * info_ptr_end)
1020 bfd *abfd = unit->abfd;
1021 unsigned int bytes_read;
1022 struct dwarf_block *blk;
1025 if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
1027 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1028 bfd_set_error (bfd_error_bad_value);
1032 attr->form = (enum dwarf_form) form;
1036 case DW_FORM_ref_addr:
1037 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1039 if (unit->version == 3 || unit->version == 4)
1041 if (unit->offset_size == 4)
1042 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1044 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1045 info_ptr += unit->offset_size;
1050 attr->u.val = read_address (unit, info_ptr, info_ptr_end);
1051 info_ptr += unit->addr_size;
1053 case DW_FORM_GNU_ref_alt:
1054 case DW_FORM_sec_offset:
1055 if (unit->offset_size == 4)
1056 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1058 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1059 info_ptr += unit->offset_size;
1061 case DW_FORM_block2:
1062 amt = sizeof (struct dwarf_block);
1063 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1066 blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
1068 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1069 info_ptr += blk->size;
1072 case DW_FORM_block4:
1073 amt = sizeof (struct dwarf_block);
1074 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1077 blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
1079 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1080 info_ptr += blk->size;
1084 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1088 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1092 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1095 case DW_FORM_string:
1096 attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
1097 info_ptr += bytes_read;
1100 attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1101 info_ptr += bytes_read;
1103 case DW_FORM_GNU_strp_alt:
1104 attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1105 info_ptr += bytes_read;
1107 case DW_FORM_exprloc:
1109 amt = sizeof (struct dwarf_block);
1110 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1113 blk->size = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1114 FALSE, info_ptr_end);
1115 info_ptr += bytes_read;
1116 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1117 info_ptr += blk->size;
1120 case DW_FORM_block1:
1121 amt = sizeof (struct dwarf_block);
1122 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1125 blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
1127 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1128 info_ptr += blk->size;
1132 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1136 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1139 case DW_FORM_flag_present:
1143 attr->u.sval = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1144 TRUE, info_ptr_end);
1145 info_ptr += bytes_read;
1148 attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1149 FALSE, info_ptr_end);
1150 info_ptr += bytes_read;
1153 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1157 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1161 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1165 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1168 case DW_FORM_ref_sig8:
1169 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1172 case DW_FORM_ref_udata:
1173 attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1174 FALSE, info_ptr_end);
1175 info_ptr += bytes_read;
1177 case DW_FORM_indirect:
1178 form = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1179 FALSE, info_ptr_end);
1180 info_ptr += bytes_read;
1181 info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
1184 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1186 bfd_set_error (bfd_error_bad_value);
1192 /* Read an attribute described by an abbreviated attribute. */
1195 read_attribute (struct attribute * attr,
1196 struct attr_abbrev * abbrev,
1197 struct comp_unit * unit,
1198 bfd_byte * info_ptr,
1199 bfd_byte * info_ptr_end)
1201 attr->name = abbrev->name;
1202 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
1206 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1210 non_mangled (int lang)
1220 case DW_LANG_Cobol74:
1221 case DW_LANG_Cobol85:
1222 case DW_LANG_Fortran77:
1223 case DW_LANG_Pascal83:
1233 /* Source line information table routines. */
1235 #define FILE_ALLOC_CHUNK 5
1236 #define DIR_ALLOC_CHUNK 5
1240 struct line_info * prev_line;
1244 unsigned int column;
1245 unsigned int discriminator;
1246 unsigned char op_index;
1247 unsigned char end_sequence; /* End of (sequential) code sequence. */
1258 struct line_sequence
1261 struct line_sequence* prev_sequence;
1262 struct line_info* last_line; /* Largest VMA. */
1263 struct line_info** line_info_lookup;
1264 bfd_size_type num_lines;
1267 struct line_info_table
1270 unsigned int num_files;
1271 unsigned int num_dirs;
1272 unsigned int num_sequences;
1275 struct fileinfo* files;
1276 struct line_sequence* sequences;
1277 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1280 /* Remember some information about each function. If the function is
1281 inlined (DW_TAG_inlined_subroutine) it may have two additional
1282 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1283 source code location where this function was inlined. */
1287 /* Pointer to previous function in list of all functions. */
1288 struct funcinfo * prev_func;
1289 /* Pointer to function one scope higher. */
1290 struct funcinfo * caller_func;
1291 /* Source location file name where caller_func inlines this func. */
1293 /* Source location file name. */
1295 /* Source location line number where caller_func inlines this func. */
1297 /* Source location line number. */
1300 bfd_boolean is_linkage;
1302 struct arange arange;
1303 /* Where the symbol is defined. */
1307 struct lookup_funcinfo
1309 /* Function information corresponding to this lookup table entry. */
1310 struct funcinfo * funcinfo;
1312 /* The lowest address for this specific function. */
1315 /* The highest address of this function before the lookup table is sorted.
1316 The highest address of all prior functions after the lookup table is
1317 sorted, which is used for binary search. */
1323 /* Pointer to previous variable in list of all variables */
1324 struct varinfo *prev_var;
1325 /* Source location file name */
1327 /* Source location line number */
1332 /* Where the symbol is defined */
1334 /* Is this a stack variable? */
1335 unsigned int stack: 1;
1338 /* Return TRUE if NEW_LINE should sort after LINE. */
1340 static inline bfd_boolean
1341 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1343 return (new_line->address > line->address
1344 || (new_line->address == line->address
1345 && (new_line->op_index > line->op_index
1346 || (new_line->op_index == line->op_index
1347 && new_line->end_sequence < line->end_sequence))));
1351 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1352 that the list is sorted. Note that the line_info list is sorted from
1353 highest to lowest VMA (with possible duplicates); that is,
1354 line_info->prev_line always accesses an equal or smaller VMA. */
1357 add_line_info (struct line_info_table *table,
1359 unsigned char op_index,
1362 unsigned int column,
1363 unsigned int discriminator,
1366 bfd_size_type amt = sizeof (struct line_info);
1367 struct line_sequence* seq = table->sequences;
1368 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1373 /* Set member data of 'info'. */
1374 info->prev_line = NULL;
1375 info->address = address;
1376 info->op_index = op_index;
1378 info->column = column;
1379 info->discriminator = discriminator;
1380 info->end_sequence = end_sequence;
1382 if (filename && filename[0])
1384 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1385 if (info->filename == NULL)
1387 strcpy (info->filename, filename);
1390 info->filename = NULL;
1392 /* Find the correct location for 'info'. Normally we will receive
1393 new line_info data 1) in order and 2) with increasing VMAs.
1394 However some compilers break the rules (cf. decode_line_info) and
1395 so we include some heuristics for quickly finding the correct
1396 location for 'info'. In particular, these heuristics optimize for
1397 the common case in which the VMA sequence that we receive is a
1398 list of locally sorted VMAs such as
1399 p...z a...j (where a < j < p < z)
1401 Note: table->lcl_head is used to head an *actual* or *possible*
1402 sub-sequence within the list (such as a...j) that is not directly
1403 headed by table->last_line
1405 Note: we may receive duplicate entries from 'decode_line_info'. */
1408 && seq->last_line->address == address
1409 && seq->last_line->op_index == op_index
1410 && seq->last_line->end_sequence == end_sequence)
1412 /* We only keep the last entry with the same address and end
1413 sequence. See PR ld/4986. */
1414 if (table->lcl_head == seq->last_line)
1415 table->lcl_head = info;
1416 info->prev_line = seq->last_line->prev_line;
1417 seq->last_line = info;
1419 else if (!seq || seq->last_line->end_sequence)
1421 /* Start a new line sequence. */
1422 amt = sizeof (struct line_sequence);
1423 seq = (struct line_sequence *) bfd_malloc (amt);
1426 seq->low_pc = address;
1427 seq->prev_sequence = table->sequences;
1428 seq->last_line = info;
1429 table->lcl_head = info;
1430 table->sequences = seq;
1431 table->num_sequences++;
1433 else if (new_line_sorts_after (info, seq->last_line))
1435 /* Normal case: add 'info' to the beginning of the current sequence. */
1436 info->prev_line = seq->last_line;
1437 seq->last_line = info;
1439 /* lcl_head: initialize to head a *possible* sequence at the end. */
1440 if (!table->lcl_head)
1441 table->lcl_head = info;
1443 else if (!new_line_sorts_after (info, table->lcl_head)
1444 && (!table->lcl_head->prev_line
1445 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1447 /* Abnormal but easy: lcl_head is the head of 'info'. */
1448 info->prev_line = table->lcl_head->prev_line;
1449 table->lcl_head->prev_line = info;
1453 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1454 are valid heads for 'info'. Reset 'lcl_head'. */
1455 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1456 struct line_info* li1 = li2->prev_line;
1460 if (!new_line_sorts_after (info, li2)
1461 && new_line_sorts_after (info, li1))
1464 li2 = li1; /* always non-NULL */
1465 li1 = li1->prev_line;
1467 table->lcl_head = li2;
1468 info->prev_line = table->lcl_head->prev_line;
1469 table->lcl_head->prev_line = info;
1470 if (address < seq->low_pc)
1471 seq->low_pc = address;
1476 /* Extract a fully qualified filename from a line info table.
1477 The returned string has been malloc'ed and it is the caller's
1478 responsibility to free it. */
1481 concat_filename (struct line_info_table *table, unsigned int file)
1485 if (file - 1 >= table->num_files)
1487 /* FILE == 0 means unknown. */
1490 (_("Dwarf Error: mangled line number section (bad file number)."));
1491 return strdup ("<unknown>");
1494 filename = table->files[file - 1].name;
1496 if (!IS_ABSOLUTE_PATH (filename))
1498 char *dir_name = NULL;
1499 char *subdir_name = NULL;
1503 if (table->files[file - 1].dir
1504 /* PR 17512: file: 0317e960. */
1505 && table->files[file - 1].dir <= table->num_dirs
1506 /* PR 17512: file: 7f3d2e4b. */
1507 && table->dirs != NULL)
1508 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1510 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1511 dir_name = table->comp_dir;
1515 dir_name = subdir_name;
1520 return strdup (filename);
1522 len = strlen (dir_name) + strlen (filename) + 2;
1526 len += strlen (subdir_name) + 1;
1527 name = (char *) bfd_malloc (len);
1529 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1533 name = (char *) bfd_malloc (len);
1535 sprintf (name, "%s/%s", dir_name, filename);
1541 return strdup (filename);
1545 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1546 bfd_vma low_pc, bfd_vma high_pc)
1548 struct arange *arange;
1550 /* Ignore empty ranges. */
1551 if (low_pc == high_pc)
1554 /* If the first arange is empty, use it. */
1555 if (first_arange->high == 0)
1557 first_arange->low = low_pc;
1558 first_arange->high = high_pc;
1562 /* Next see if we can cheaply extend an existing range. */
1563 arange = first_arange;
1566 if (low_pc == arange->high)
1568 arange->high = high_pc;
1571 if (high_pc == arange->low)
1573 arange->low = low_pc;
1576 arange = arange->next;
1580 /* Need to allocate a new arange and insert it into the arange list.
1581 Order isn't significant, so just insert after the first arange. */
1582 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1585 arange->low = low_pc;
1586 arange->high = high_pc;
1587 arange->next = first_arange->next;
1588 first_arange->next = arange;
1592 /* Compare function for line sequences. */
1595 compare_sequences (const void* a, const void* b)
1597 const struct line_sequence* seq1 = a;
1598 const struct line_sequence* seq2 = b;
1600 /* Sort by low_pc as the primary key. */
1601 if (seq1->low_pc < seq2->low_pc)
1603 if (seq1->low_pc > seq2->low_pc)
1606 /* If low_pc values are equal, sort in reverse order of
1607 high_pc, so that the largest region comes first. */
1608 if (seq1->last_line->address < seq2->last_line->address)
1610 if (seq1->last_line->address > seq2->last_line->address)
1613 if (seq1->last_line->op_index < seq2->last_line->op_index)
1615 if (seq1->last_line->op_index > seq2->last_line->op_index)
1621 /* Construct the line information table for quick lookup. */
1624 build_line_info_table (struct line_info_table * table,
1625 struct line_sequence * seq)
1628 struct line_info** line_info_lookup;
1629 struct line_info* each_line;
1630 unsigned int num_lines;
1631 unsigned int line_index;
1633 if (seq->line_info_lookup != NULL)
1636 /* Count the number of line information entries. We could do this while
1637 scanning the debug information, but some entries may be added via
1638 lcl_head without having a sequence handy to increment the number of
1641 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1647 /* Allocate space for the line information lookup table. */
1648 amt = sizeof (struct line_info*) * num_lines;
1649 line_info_lookup = (struct line_info**) bfd_alloc (table->abfd, amt);
1650 if (line_info_lookup == NULL)
1653 /* Create the line information lookup table. */
1654 line_index = num_lines;
1655 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1656 line_info_lookup[--line_index] = each_line;
1658 BFD_ASSERT (line_index == 0);
1660 seq->num_lines = num_lines;
1661 seq->line_info_lookup = line_info_lookup;
1666 /* Sort the line sequences for quick lookup. */
1669 sort_line_sequences (struct line_info_table* table)
1672 struct line_sequence* sequences;
1673 struct line_sequence* seq;
1675 unsigned int num_sequences = table->num_sequences;
1676 bfd_vma last_high_pc;
1678 if (num_sequences == 0)
1681 /* Allocate space for an array of sequences. */
1682 amt = sizeof (struct line_sequence) * num_sequences;
1683 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1684 if (sequences == NULL)
1687 /* Copy the linked list into the array, freeing the original nodes. */
1688 seq = table->sequences;
1689 for (n = 0; n < num_sequences; n++)
1691 struct line_sequence* last_seq = seq;
1694 sequences[n].low_pc = seq->low_pc;
1695 sequences[n].prev_sequence = NULL;
1696 sequences[n].last_line = seq->last_line;
1697 sequences[n].line_info_lookup = NULL;
1698 sequences[n].num_lines = 0;
1699 seq = seq->prev_sequence;
1702 BFD_ASSERT (seq == NULL);
1704 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1706 /* Make the list binary-searchable by trimming overlapping entries
1707 and removing nested entries. */
1709 last_high_pc = sequences[0].last_line->address;
1710 for (n = 1; n < table->num_sequences; n++)
1712 if (sequences[n].low_pc < last_high_pc)
1714 if (sequences[n].last_line->address <= last_high_pc)
1715 /* Skip nested entries. */
1718 /* Trim overlapping entries. */
1719 sequences[n].low_pc = last_high_pc;
1721 last_high_pc = sequences[n].last_line->address;
1722 if (n > num_sequences)
1724 /* Close up the gap. */
1725 sequences[num_sequences].low_pc = sequences[n].low_pc;
1726 sequences[num_sequences].last_line = sequences[n].last_line;
1731 table->sequences = sequences;
1732 table->num_sequences = num_sequences;
1736 /* Decode the line number information for UNIT. */
1738 static struct line_info_table*
1739 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1741 bfd *abfd = unit->abfd;
1742 struct line_info_table* table;
1745 struct line_head lh;
1746 unsigned int i, bytes_read, offset_size;
1747 char *cur_file, *cur_dir;
1748 unsigned char op_code, extended_op, adj_opcode;
1749 unsigned int exop_len;
1752 if (! read_section (abfd, &stash->debug_sections[debug_line],
1753 stash->syms, unit->line_offset,
1754 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1757 amt = sizeof (struct line_info_table);
1758 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1762 table->comp_dir = unit->comp_dir;
1764 table->num_files = 0;
1765 table->files = NULL;
1767 table->num_dirs = 0;
1770 table->num_sequences = 0;
1771 table->sequences = NULL;
1773 table->lcl_head = NULL;
1775 if (stash->dwarf_line_size < 16)
1778 (_("Dwarf Error: Line info section is too small (%ld)"),
1779 (long) stash->dwarf_line_size);
1780 bfd_set_error (bfd_error_bad_value);
1783 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1784 line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
1786 /* Read in the prologue. */
1787 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1790 if (lh.total_length == 0xffffffff)
1792 lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
1796 else if (lh.total_length == 0 && unit->addr_size == 8)
1798 /* Handle (non-standard) 64-bit DWARF2 formats. */
1799 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1804 if (lh.total_length > stash->dwarf_line_size)
1807 /* xgettext: c-format */
1808 (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
1809 (long) lh.total_length, (long) stash->dwarf_line_size);
1810 bfd_set_error (bfd_error_bad_value);
1814 line_end = line_ptr + lh.total_length;
1816 lh.version = read_2_bytes (abfd, line_ptr, line_end);
1817 if (lh.version < 2 || lh.version > 4)
1820 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1821 bfd_set_error (bfd_error_bad_value);
1826 if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
1829 (_("Dwarf Error: Ran out of room reading prologue"));
1830 bfd_set_error (bfd_error_bad_value);
1834 if (offset_size == 4)
1835 lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
1837 lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
1838 line_ptr += offset_size;
1840 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
1843 if (lh.version >= 4)
1845 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
1849 lh.maximum_ops_per_insn = 1;
1851 if (lh.maximum_ops_per_insn == 0)
1854 (_("Dwarf Error: Invalid maximum operations per instruction."));
1855 bfd_set_error (bfd_error_bad_value);
1859 lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
1862 lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
1865 lh.line_range = read_1_byte (abfd, line_ptr, line_end);
1868 lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
1871 if (line_ptr + (lh.opcode_base - 1) >= line_end)
1873 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
1874 bfd_set_error (bfd_error_bad_value);
1878 amt = lh.opcode_base * sizeof (unsigned char);
1879 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1881 lh.standard_opcode_lengths[0] = 1;
1883 for (i = 1; i < lh.opcode_base; ++i)
1885 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
1889 /* Read directory table. */
1890 while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1892 line_ptr += bytes_read;
1894 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1898 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1899 amt *= sizeof (char *);
1901 tmp = (char **) bfd_realloc (table->dirs, amt);
1907 table->dirs[table->num_dirs++] = cur_dir;
1910 line_ptr += bytes_read;
1912 /* Read file name table. */
1913 while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1915 line_ptr += bytes_read;
1917 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1919 struct fileinfo *tmp;
1921 amt = table->num_files + FILE_ALLOC_CHUNK;
1922 amt *= sizeof (struct fileinfo);
1924 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1930 table->files[table->num_files].name = cur_file;
1931 table->files[table->num_files].dir =
1932 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1933 line_ptr += bytes_read;
1934 table->files[table->num_files].time
1935 = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1936 line_ptr += bytes_read;
1937 table->files[table->num_files].size
1938 = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1939 line_ptr += bytes_read;
1943 line_ptr += bytes_read;
1945 /* Read the statement sequences until there's nothing left. */
1946 while (line_ptr < line_end)
1948 /* State machine registers. */
1949 bfd_vma address = 0;
1950 unsigned char op_index = 0;
1951 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1952 unsigned int line = 1;
1953 unsigned int column = 0;
1954 unsigned int discriminator = 0;
1955 int is_stmt = lh.default_is_stmt;
1956 int end_sequence = 0;
1957 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1958 compilers generate address sequences that are wildly out of
1959 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1960 for ia64-Linux). Thus, to determine the low and high
1961 address, we must compare on every DW_LNS_copy, etc. */
1962 bfd_vma low_pc = (bfd_vma) -1;
1963 bfd_vma high_pc = 0;
1965 /* Decode the table. */
1966 while (! end_sequence)
1968 op_code = read_1_byte (abfd, line_ptr, line_end);
1971 if (op_code >= lh.opcode_base)
1973 /* Special operand. */
1974 adj_opcode = op_code - lh.opcode_base;
1975 if (lh.line_range == 0)
1977 if (lh.maximum_ops_per_insn == 1)
1978 address += (adj_opcode / lh.line_range
1979 * lh.minimum_instruction_length);
1982 address += ((op_index + adj_opcode / lh.line_range)
1983 / lh.maximum_ops_per_insn
1984 * lh.minimum_instruction_length);
1985 op_index = ((op_index + adj_opcode / lh.line_range)
1986 % lh.maximum_ops_per_insn);
1988 line += lh.line_base + (adj_opcode % lh.line_range);
1989 /* Append row to matrix using current values. */
1990 if (!add_line_info (table, address, op_index, filename,
1991 line, column, discriminator, 0))
1994 if (address < low_pc)
1996 if (address > high_pc)
1999 else switch (op_code)
2001 case DW_LNS_extended_op:
2002 exop_len = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2004 line_ptr += bytes_read;
2005 extended_op = read_1_byte (abfd, line_ptr, line_end);
2008 switch (extended_op)
2010 case DW_LNE_end_sequence:
2012 if (!add_line_info (table, address, op_index, filename, line,
2013 column, discriminator, end_sequence))
2016 if (address < low_pc)
2018 if (address > high_pc)
2020 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2023 case DW_LNE_set_address:
2024 address = read_address (unit, line_ptr, line_end);
2026 line_ptr += unit->addr_size;
2028 case DW_LNE_define_file:
2029 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
2030 line_ptr += bytes_read;
2031 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
2033 struct fileinfo *tmp;
2035 amt = table->num_files + FILE_ALLOC_CHUNK;
2036 amt *= sizeof (struct fileinfo);
2037 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
2042 table->files[table->num_files].name = cur_file;
2043 table->files[table->num_files].dir =
2044 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2046 line_ptr += bytes_read;
2047 table->files[table->num_files].time =
2048 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2050 line_ptr += bytes_read;
2051 table->files[table->num_files].size =
2052 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2054 line_ptr += bytes_read;
2057 case DW_LNE_set_discriminator:
2059 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2061 line_ptr += bytes_read;
2063 case DW_LNE_HP_source_file_correlation:
2064 line_ptr += exop_len - 1;
2068 (_("Dwarf Error: mangled line number section."));
2069 bfd_set_error (bfd_error_bad_value);
2071 if (filename != NULL)
2077 if (!add_line_info (table, address, op_index,
2078 filename, line, column, discriminator, 0))
2081 if (address < low_pc)
2083 if (address > high_pc)
2086 case DW_LNS_advance_pc:
2087 if (lh.maximum_ops_per_insn == 1)
2088 address += (lh.minimum_instruction_length
2089 * _bfd_safe_read_leb128 (abfd, line_ptr,
2094 bfd_vma adjust = _bfd_safe_read_leb128 (abfd, line_ptr,
2097 address = ((op_index + adjust) / lh.maximum_ops_per_insn
2098 * lh.minimum_instruction_length);
2099 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2101 line_ptr += bytes_read;
2103 case DW_LNS_advance_line:
2104 line += _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2106 line_ptr += bytes_read;
2108 case DW_LNS_set_file:
2112 /* The file and directory tables are 0
2113 based, the references are 1 based. */
2114 file = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2116 line_ptr += bytes_read;
2119 filename = concat_filename (table, file);
2122 case DW_LNS_set_column:
2123 column = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2125 line_ptr += bytes_read;
2127 case DW_LNS_negate_stmt:
2128 is_stmt = (!is_stmt);
2130 case DW_LNS_set_basic_block:
2132 case DW_LNS_const_add_pc:
2133 if (lh.maximum_ops_per_insn == 1)
2134 address += (lh.minimum_instruction_length
2135 * ((255 - lh.opcode_base) / lh.line_range));
2138 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
2139 address += (lh.minimum_instruction_length
2140 * ((op_index + adjust)
2141 / lh.maximum_ops_per_insn));
2142 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2145 case DW_LNS_fixed_advance_pc:
2146 address += read_2_bytes (abfd, line_ptr, line_end);
2151 /* Unknown standard opcode, ignore it. */
2152 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
2154 (void) _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2156 line_ptr += bytes_read;
2166 if (sort_line_sequences (table))
2170 if (table->sequences != NULL)
2171 free (table->sequences);
2172 if (table->files != NULL)
2173 free (table->files);
2174 if (table->dirs != NULL)
2179 /* If ADDR is within TABLE set the output parameters and return the
2180 range of addresses covered by the entry used to fill them out.
2181 Otherwise set * FILENAME_PTR to NULL and return 0.
2182 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2183 are pointers to the objects to be filled in. */
2186 lookup_address_in_line_info_table (struct line_info_table *table,
2188 const char **filename_ptr,
2189 unsigned int *linenumber_ptr,
2190 unsigned int *discriminator_ptr)
2192 struct line_sequence *seq = NULL;
2193 struct line_info *info;
2196 /* Binary search the array of sequences. */
2198 high = table->num_sequences;
2201 mid = (low + high) / 2;
2202 seq = &table->sequences[mid];
2203 if (addr < seq->low_pc)
2205 else if (addr >= seq->last_line->address)
2211 /* Check for a valid sequence. */
2212 if (!seq || addr < seq->low_pc || addr >= seq->last_line->address)
2215 if (!build_line_info_table (table, seq))
2218 /* Binary search the array of line information. */
2220 high = seq->num_lines;
2224 mid = (low + high) / 2;
2225 info = seq->line_info_lookup[mid];
2226 if (addr < info->address)
2228 else if (addr >= seq->line_info_lookup[mid + 1]->address)
2234 /* Check for a valid line information entry. */
2236 && addr >= info->address
2237 && addr < seq->line_info_lookup[mid + 1]->address
2238 && !(info->end_sequence || info == seq->last_line))
2240 *filename_ptr = info->filename;
2241 *linenumber_ptr = info->line;
2242 if (discriminator_ptr)
2243 *discriminator_ptr = info->discriminator;
2244 return seq->last_line->address - seq->low_pc;
2248 *filename_ptr = NULL;
2252 /* Read in the .debug_ranges section for future reference. */
2255 read_debug_ranges (struct comp_unit * unit)
2257 struct dwarf2_debug * stash = unit->stash;
2259 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
2261 &stash->dwarf_ranges_buffer,
2262 &stash->dwarf_ranges_size);
2265 /* Function table functions. */
2268 compare_lookup_funcinfos (const void * a, const void * b)
2270 const struct lookup_funcinfo * lookup1 = a;
2271 const struct lookup_funcinfo * lookup2 = b;
2273 if (lookup1->low_addr < lookup2->low_addr)
2275 if (lookup1->low_addr > lookup2->low_addr)
2277 if (lookup1->high_addr < lookup2->high_addr)
2279 if (lookup1->high_addr > lookup2->high_addr)
2286 build_lookup_funcinfo_table (struct comp_unit * unit)
2288 struct lookup_funcinfo *lookup_funcinfo_table = unit->lookup_funcinfo_table;
2289 unsigned int number_of_functions = unit->number_of_functions;
2290 struct funcinfo *each;
2291 struct lookup_funcinfo *entry;
2293 struct arange *range;
2294 bfd_vma low_addr, high_addr;
2296 if (lookup_funcinfo_table || number_of_functions == 0)
2299 /* Create the function info lookup table. */
2300 lookup_funcinfo_table = (struct lookup_funcinfo *)
2301 bfd_malloc (number_of_functions * sizeof (struct lookup_funcinfo));
2302 if (lookup_funcinfo_table == NULL)
2305 /* Populate the function info lookup table. */
2306 func_index = number_of_functions;
2307 for (each = unit->function_table; each; each = each->prev_func)
2309 entry = &lookup_funcinfo_table[--func_index];
2310 entry->funcinfo = each;
2312 /* Calculate the lowest and highest address for this function entry. */
2313 low_addr = entry->funcinfo->arange.low;
2314 high_addr = entry->funcinfo->arange.high;
2316 for (range = entry->funcinfo->arange.next; range; range = range->next)
2318 if (range->low < low_addr)
2319 low_addr = range->low;
2320 if (range->high > high_addr)
2321 high_addr = range->high;
2324 entry->low_addr = low_addr;
2325 entry->high_addr = high_addr;
2328 BFD_ASSERT (func_index == 0);
2330 /* Sort the function by address. */
2331 qsort (lookup_funcinfo_table,
2332 number_of_functions,
2333 sizeof (struct lookup_funcinfo),
2334 compare_lookup_funcinfos);
2336 /* Calculate the high watermark for each function in the lookup table. */
2337 high_addr = lookup_funcinfo_table[0].high_addr;
2338 for (func_index = 1; func_index < number_of_functions; func_index++)
2340 entry = &lookup_funcinfo_table[func_index];
2341 if (entry->high_addr > high_addr)
2342 high_addr = entry->high_addr;
2344 entry->high_addr = high_addr;
2347 unit->lookup_funcinfo_table = lookup_funcinfo_table;
2351 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2352 TRUE. Note that we need to find the function that has the smallest range
2353 that contains ADDR, to handle inlined functions without depending upon
2354 them being ordered in TABLE by increasing range. */
2357 lookup_address_in_function_table (struct comp_unit *unit,
2359 struct funcinfo **function_ptr)
2361 unsigned int number_of_functions = unit->number_of_functions;
2362 struct lookup_funcinfo* lookup_funcinfo = NULL;
2363 struct funcinfo* funcinfo = NULL;
2364 struct funcinfo* best_fit = NULL;
2365 bfd_vma best_fit_len = 0;
2366 bfd_size_type low, high, mid, first;
2367 struct arange *arange;
2369 if (number_of_functions == 0)
2372 if (!build_lookup_funcinfo_table (unit))
2375 if (unit->lookup_funcinfo_table[number_of_functions - 1].high_addr < addr)
2378 /* Find the first function in the lookup table which may contain the
2379 specified address. */
2381 high = number_of_functions;
2385 mid = (low + high) / 2;
2386 lookup_funcinfo = &unit->lookup_funcinfo_table[mid];
2387 if (addr < lookup_funcinfo->low_addr)
2389 else if (addr >= lookup_funcinfo->high_addr)
2395 /* Find the 'best' match for the address. The prior algorithm defined the
2396 best match as the function with the smallest address range containing
2397 the specified address. This definition should probably be changed to the
2398 innermost inline routine containing the address, but right now we want
2399 to get the same results we did before. */
2400 while (first < number_of_functions)
2402 if (addr < unit->lookup_funcinfo_table[first].low_addr)
2404 funcinfo = unit->lookup_funcinfo_table[first].funcinfo;
2406 for (arange = &funcinfo->arange; arange; arange = arange->next)
2408 if (addr < arange->low || addr >= arange->high)
2412 || arange->high - arange->low < best_fit_len
2413 /* The following comparison is designed to return the same
2414 match as the previous algorithm for routines which have the
2415 same best fit length. */
2416 || (arange->high - arange->low == best_fit_len
2417 && funcinfo > best_fit))
2419 best_fit = funcinfo;
2420 best_fit_len = arange->high - arange->low;
2430 *function_ptr = best_fit;
2434 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2435 and LINENUMBER_PTR, and return TRUE. */
2438 lookup_symbol_in_function_table (struct comp_unit *unit,
2441 const char **filename_ptr,
2442 unsigned int *linenumber_ptr)
2444 struct funcinfo* each_func;
2445 struct funcinfo* best_fit = NULL;
2446 bfd_vma best_fit_len = 0;
2447 struct arange *arange;
2448 const char *name = bfd_asymbol_name (sym);
2449 asection *sec = bfd_get_section (sym);
2451 for (each_func = unit->function_table;
2453 each_func = each_func->prev_func)
2455 for (arange = &each_func->arange;
2457 arange = arange->next)
2459 if ((!each_func->sec || each_func->sec == sec)
2460 && addr >= arange->low
2461 && addr < arange->high
2463 && strcmp (name, each_func->name) == 0
2465 || arange->high - arange->low < best_fit_len))
2467 best_fit = each_func;
2468 best_fit_len = arange->high - arange->low;
2475 best_fit->sec = sec;
2476 *filename_ptr = best_fit->file;
2477 *linenumber_ptr = best_fit->line;
2484 /* Variable table functions. */
2486 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2487 LINENUMBER_PTR, and return TRUE. */
2490 lookup_symbol_in_variable_table (struct comp_unit *unit,
2493 const char **filename_ptr,
2494 unsigned int *linenumber_ptr)
2496 const char *name = bfd_asymbol_name (sym);
2497 asection *sec = bfd_get_section (sym);
2498 struct varinfo* each;
2500 for (each = unit->variable_table; each; each = each->prev_var)
2501 if (each->stack == 0
2502 && each->file != NULL
2503 && each->name != NULL
2504 && each->addr == addr
2505 && (!each->sec || each->sec == sec)
2506 && strcmp (name, each->name) == 0)
2512 *filename_ptr = each->file;
2513 *linenumber_ptr = each->line;
2521 find_abstract_instance_name (struct comp_unit *unit,
2522 struct attribute *attr_ptr,
2523 bfd_boolean *is_linkage)
2525 bfd *abfd = unit->abfd;
2527 bfd_byte *info_ptr_end;
2528 unsigned int abbrev_number, bytes_read, i;
2529 struct abbrev_info *abbrev;
2530 bfd_uint64_t die_ref = attr_ptr->u.val;
2531 struct attribute attr;
2534 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2535 is an offset from the .debug_info section, not the current CU. */
2536 if (attr_ptr->form == DW_FORM_ref_addr)
2538 /* We only support DW_FORM_ref_addr within the same file, so
2539 any relocations should be resolved already. */
2543 info_ptr = unit->sec_info_ptr + die_ref;
2544 info_ptr_end = unit->end_ptr;
2546 /* Now find the CU containing this pointer. */
2547 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2551 /* Check other CUs to see if they contain the abbrev. */
2552 struct comp_unit * u;
2554 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2555 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2559 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2560 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2565 /* else FIXME: What do we do now ? */
2568 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2570 info_ptr = read_alt_indirect_ref (unit, die_ref);
2571 if (info_ptr == NULL)
2574 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2575 bfd_set_error (bfd_error_bad_value);
2578 info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
2580 /* FIXME: Do we need to locate the correct CU, in a similar
2581 fashion to the code in the DW_FORM_ref_addr case above ? */
2585 info_ptr = unit->info_ptr_unit + die_ref;
2586 info_ptr_end = unit->end_ptr;
2589 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
2590 FALSE, info_ptr_end);
2591 info_ptr += bytes_read;
2595 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2599 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2600 bfd_set_error (bfd_error_bad_value);
2604 for (i = 0; i < abbrev->num_attrs; ++i)
2606 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2607 info_ptr, info_ptr_end);
2608 if (info_ptr == NULL)
2613 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2615 if (name == NULL && is_str_attr (attr.form))
2618 if (non_mangled (unit->lang))
2622 case DW_AT_specification:
2623 name = find_abstract_instance_name (unit, &attr, is_linkage);
2625 case DW_AT_linkage_name:
2626 case DW_AT_MIPS_linkage_name:
2627 /* PR 16949: Corrupt debug info can place
2628 non-string forms into these attributes. */
2629 if (is_str_attr (attr.form))
2645 read_rangelist (struct comp_unit *unit, struct arange *arange,
2646 bfd_uint64_t offset)
2648 bfd_byte *ranges_ptr;
2649 bfd_byte *ranges_end;
2650 bfd_vma base_address = unit->base_address;
2652 if (! unit->stash->dwarf_ranges_buffer)
2654 if (! read_debug_ranges (unit))
2658 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2659 if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
2661 ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
2668 /* PR 17512: file: 62cada7d. */
2669 if (ranges_ptr + 2 * unit->addr_size > ranges_end)
2672 low_pc = read_address (unit, ranges_ptr, ranges_end);
2673 ranges_ptr += unit->addr_size;
2674 high_pc = read_address (unit, ranges_ptr, ranges_end);
2675 ranges_ptr += unit->addr_size;
2677 if (low_pc == 0 && high_pc == 0)
2679 if (low_pc == -1UL && high_pc != -1UL)
2680 base_address = high_pc;
2683 if (!arange_add (unit, arange,
2684 base_address + low_pc, base_address + high_pc))
2691 /* DWARF2 Compilation unit functions. */
2693 /* Scan over each die in a comp. unit looking for functions to add
2694 to the function table and variables to the variable table. */
2697 scan_unit_for_symbols (struct comp_unit *unit)
2699 bfd *abfd = unit->abfd;
2700 bfd_byte *info_ptr = unit->first_child_die_ptr;
2701 bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
2702 int nesting_level = 1;
2703 struct funcinfo **nested_funcs;
2704 int nested_funcs_size;
2706 /* Maintain a stack of in-scope functions and inlined functions, which we
2707 can use to set the caller_func field. */
2708 nested_funcs_size = 32;
2709 nested_funcs = (struct funcinfo **)
2710 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2711 if (nested_funcs == NULL)
2713 nested_funcs[nesting_level] = 0;
2715 while (nesting_level)
2717 unsigned int abbrev_number, bytes_read, i;
2718 struct abbrev_info *abbrev;
2719 struct attribute attr;
2720 struct funcinfo *func;
2721 struct varinfo *var;
2723 bfd_vma high_pc = 0;
2724 bfd_boolean high_pc_relative = FALSE;
2726 /* PR 17512: file: 9f405d9d. */
2727 if (info_ptr >= info_ptr_end)
2730 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
2731 FALSE, info_ptr_end);
2732 info_ptr += bytes_read;
2734 if (! abbrev_number)
2740 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2744 (_("Dwarf Error: Could not find abbrev number %u."),
2746 bfd_set_error (bfd_error_bad_value);
2751 if (abbrev->tag == DW_TAG_subprogram
2752 || abbrev->tag == DW_TAG_entry_point
2753 || abbrev->tag == DW_TAG_inlined_subroutine)
2755 bfd_size_type amt = sizeof (struct funcinfo);
2756 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2759 func->tag = abbrev->tag;
2760 func->prev_func = unit->function_table;
2761 unit->function_table = func;
2762 unit->number_of_functions++;
2763 BFD_ASSERT (!unit->cached);
2765 if (func->tag == DW_TAG_inlined_subroutine)
2766 for (i = nesting_level - 1; i >= 1; i--)
2767 if (nested_funcs[i])
2769 func->caller_func = nested_funcs[i];
2772 nested_funcs[nesting_level] = func;
2777 if (abbrev->tag == DW_TAG_variable)
2779 bfd_size_type amt = sizeof (struct varinfo);
2780 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2783 var->tag = abbrev->tag;
2785 var->prev_var = unit->variable_table;
2786 unit->variable_table = var;
2787 BFD_ASSERT (!unit->cached);
2790 /* No inline function in scope at this nesting level. */
2791 nested_funcs[nesting_level] = 0;
2794 for (i = 0; i < abbrev->num_attrs; ++i)
2796 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
2797 if (info_ptr == NULL)
2804 case DW_AT_call_file:
2805 func->caller_file = concat_filename (unit->line_table,
2809 case DW_AT_call_line:
2810 func->caller_line = attr.u.val;
2813 case DW_AT_abstract_origin:
2814 case DW_AT_specification:
2815 func->name = find_abstract_instance_name (unit, &attr,
2820 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2822 if (func->name == NULL && is_str_attr (attr.form))
2824 func->name = attr.u.str;
2825 if (non_mangled (unit->lang))
2826 func->is_linkage = TRUE;
2830 case DW_AT_linkage_name:
2831 case DW_AT_MIPS_linkage_name:
2832 /* PR 16949: Corrupt debug info can place
2833 non-string forms into these attributes. */
2834 if (is_str_attr (attr.form))
2836 func->name = attr.u.str;
2837 func->is_linkage = TRUE;
2842 low_pc = attr.u.val;
2846 high_pc = attr.u.val;
2847 high_pc_relative = attr.form != DW_FORM_addr;
2851 if (!read_rangelist (unit, &func->arange, attr.u.val))
2855 case DW_AT_decl_file:
2856 func->file = concat_filename (unit->line_table,
2860 case DW_AT_decl_line:
2861 func->line = attr.u.val;
2873 var->name = attr.u.str;
2876 case DW_AT_decl_file:
2877 var->file = concat_filename (unit->line_table,
2881 case DW_AT_decl_line:
2882 var->line = attr.u.val;
2885 case DW_AT_external:
2886 if (attr.u.val != 0)
2890 case DW_AT_location:
2894 case DW_FORM_block1:
2895 case DW_FORM_block2:
2896 case DW_FORM_block4:
2897 case DW_FORM_exprloc:
2898 if (*attr.u.blk->data == DW_OP_addr)
2902 /* Verify that DW_OP_addr is the only opcode in the
2903 location, in which case the block size will be 1
2904 plus the address size. */
2905 /* ??? For TLS variables, gcc can emit
2906 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2907 which we don't handle here yet. */
2908 if (attr.u.blk->size == unit->addr_size + 1U)
2909 var->addr = bfd_get (unit->addr_size * 8,
2911 attr.u.blk->data + 1);
2926 if (high_pc_relative)
2929 if (func && high_pc != 0)
2931 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2935 if (abbrev->has_children)
2939 if (nesting_level >= nested_funcs_size)
2941 struct funcinfo **tmp;
2943 nested_funcs_size *= 2;
2944 tmp = (struct funcinfo **)
2945 bfd_realloc (nested_funcs,
2946 nested_funcs_size * sizeof (struct funcinfo *));
2951 nested_funcs[nesting_level] = 0;
2955 free (nested_funcs);
2959 free (nested_funcs);
2963 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2964 includes the compilation unit header that proceeds the DIE's, but
2965 does not include the length field that precedes each compilation
2966 unit header. END_PTR points one past the end of this comp unit.
2967 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2969 This routine does not read the whole compilation unit; only enough
2970 to get to the line number information for the compilation unit. */
2972 static struct comp_unit *
2973 parse_comp_unit (struct dwarf2_debug *stash,
2974 bfd_vma unit_length,
2975 bfd_byte *info_ptr_unit,
2976 unsigned int offset_size)
2978 struct comp_unit* unit;
2979 unsigned int version;
2980 bfd_uint64_t abbrev_offset = 0;
2981 unsigned int addr_size;
2982 struct abbrev_info** abbrevs;
2983 unsigned int abbrev_number, bytes_read, i;
2984 struct abbrev_info *abbrev;
2985 struct attribute attr;
2986 bfd_byte *info_ptr = stash->info_ptr;
2987 bfd_byte *end_ptr = info_ptr + unit_length;
2990 bfd_vma high_pc = 0;
2991 bfd *abfd = stash->bfd_ptr;
2992 bfd_boolean high_pc_relative = FALSE;
2994 version = read_2_bytes (abfd, info_ptr, end_ptr);
2996 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2997 if (offset_size == 4)
2998 abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
3000 abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
3001 info_ptr += offset_size;
3002 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
3005 if (version != 2 && version != 3 && version != 4)
3007 /* PR 19872: A version number of 0 probably means that there is padding
3008 at the end of the .debug_info section. Gold puts it there when
3009 performing an incremental link, for example. So do not generate
3010 an error, just return a NULL. */
3014 (_("Dwarf Error: found dwarf version '%u', this reader"
3015 " only handles version 2, 3 and 4 information."), version);
3016 bfd_set_error (bfd_error_bad_value);
3021 if (addr_size > sizeof (bfd_vma))
3024 /* xgettext: c-format */
3025 (_("Dwarf Error: found address size '%u', this reader"
3026 " can not handle sizes greater than '%u'."),
3028 (unsigned int) sizeof (bfd_vma));
3029 bfd_set_error (bfd_error_bad_value);
3033 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
3036 ("Dwarf Error: found address size '%u', this reader"
3037 " can only handle address sizes '2', '4' and '8'.", addr_size);
3038 bfd_set_error (bfd_error_bad_value);
3042 /* Read the abbrevs for this compilation unit into a table. */
3043 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
3047 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
3049 info_ptr += bytes_read;
3050 if (! abbrev_number)
3052 /* PR 19872: An abbrev number of 0 probably means that there is padding
3053 at the end of the .debug_abbrev section. Gold puts it there when
3054 performing an incremental link, for example. So do not generate
3055 an error, just return a NULL. */
3059 abbrev = lookup_abbrev (abbrev_number, abbrevs);
3062 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3064 bfd_set_error (bfd_error_bad_value);
3068 amt = sizeof (struct comp_unit);
3069 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
3073 unit->version = version;
3074 unit->addr_size = addr_size;
3075 unit->offset_size = offset_size;
3076 unit->abbrevs = abbrevs;
3077 unit->end_ptr = end_ptr;
3078 unit->stash = stash;
3079 unit->info_ptr_unit = info_ptr_unit;
3080 unit->sec_info_ptr = stash->sec_info_ptr;
3082 for (i = 0; i < abbrev->num_attrs; ++i)
3084 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
3085 if (info_ptr == NULL)
3088 /* Store the data if it is of an attribute we want to keep in a
3089 partial symbol table. */
3092 case DW_AT_stmt_list:
3094 unit->line_offset = attr.u.val;
3098 unit->name = attr.u.str;
3102 low_pc = attr.u.val;
3103 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3104 this is the base address to use when reading location
3105 lists or range lists. */
3106 if (abbrev->tag == DW_TAG_compile_unit)
3107 unit->base_address = low_pc;
3111 high_pc = attr.u.val;
3112 high_pc_relative = attr.form != DW_FORM_addr;
3116 if (!read_rangelist (unit, &unit->arange, attr.u.val))
3120 case DW_AT_comp_dir:
3122 char *comp_dir = attr.u.str;
3124 /* PR 17512: file: 1fe726be. */
3125 if (! is_str_attr (attr.form))
3128 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3134 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3135 directory, get rid of it. */
3136 char *cp = strchr (comp_dir, ':');
3138 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
3141 unit->comp_dir = comp_dir;
3145 case DW_AT_language:
3146 unit->lang = attr.u.val;
3153 if (high_pc_relative)
3157 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
3161 unit->first_child_die_ptr = info_ptr;
3165 /* Return TRUE if UNIT may contain the address given by ADDR. When
3166 there are functions written entirely with inline asm statements, the
3167 range info in the compilation unit header may not be correct. We
3168 need to consult the line info table to see if a compilation unit
3169 really contains the given address. */
3172 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
3174 struct arange *arange;
3179 arange = &unit->arange;
3182 if (addr >= arange->low && addr < arange->high)
3184 arange = arange->next;
3191 /* If UNIT contains ADDR, set the output parameters to the values for
3192 the line containing ADDR. The output parameters, FILENAME_PTR,
3193 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3196 Returns the range of addresses covered by the entry that was used
3197 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3200 comp_unit_find_nearest_line (struct comp_unit *unit,
3202 const char **filename_ptr,
3203 struct funcinfo **function_ptr,
3204 unsigned int *linenumber_ptr,
3205 unsigned int *discriminator_ptr,
3206 struct dwarf2_debug *stash)
3213 if (! unit->line_table)
3215 if (! unit->stmtlist)
3221 unit->line_table = decode_line_info (unit, stash);
3223 if (! unit->line_table)
3229 if (unit->first_child_die_ptr < unit->end_ptr
3230 && ! scan_unit_for_symbols (unit))
3237 *function_ptr = NULL;
3238 func_p = lookup_address_in_function_table (unit, addr, function_ptr);
3239 if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
3240 stash->inliner_chain = *function_ptr;
3242 return lookup_address_in_line_info_table (unit->line_table, addr,
3248 /* Check to see if line info is already decoded in a comp_unit.
3249 If not, decode it. Returns TRUE if no errors were encountered;
3253 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
3254 struct dwarf2_debug *stash)
3259 if (! unit->line_table)
3261 if (! unit->stmtlist)
3267 unit->line_table = decode_line_info (unit, stash);
3269 if (! unit->line_table)
3275 if (unit->first_child_die_ptr < unit->end_ptr
3276 && ! scan_unit_for_symbols (unit))
3286 /* If UNIT contains SYM at ADDR, set the output parameters to the
3287 values for the line containing SYM. The output parameters,
3288 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3291 Return TRUE if UNIT contains SYM, and no errors were encountered;
3295 comp_unit_find_line (struct comp_unit *unit,
3298 const char **filename_ptr,
3299 unsigned int *linenumber_ptr,
3300 struct dwarf2_debug *stash)
3302 if (!comp_unit_maybe_decode_line_info (unit, stash))
3305 if (sym->flags & BSF_FUNCTION)
3306 return lookup_symbol_in_function_table (unit, sym, addr,
3310 return lookup_symbol_in_variable_table (unit, sym, addr,
3315 static struct funcinfo *
3316 reverse_funcinfo_list (struct funcinfo *head)
3318 struct funcinfo *rhead;
3319 struct funcinfo *temp;
3321 for (rhead = NULL; head; head = temp)
3323 temp = head->prev_func;
3324 head->prev_func = rhead;
3330 static struct varinfo *
3331 reverse_varinfo_list (struct varinfo *head)
3333 struct varinfo *rhead;
3334 struct varinfo *temp;
3336 for (rhead = NULL; head; head = temp)
3338 temp = head->prev_var;
3339 head->prev_var = rhead;
3345 /* Extract all interesting funcinfos and varinfos of a compilation
3346 unit into hash tables for faster lookup. Returns TRUE if no
3347 errors were enountered; FALSE otherwise. */
3350 comp_unit_hash_info (struct dwarf2_debug *stash,
3351 struct comp_unit *unit,
3352 struct info_hash_table *funcinfo_hash_table,
3353 struct info_hash_table *varinfo_hash_table)
3355 struct funcinfo* each_func;
3356 struct varinfo* each_var;
3357 bfd_boolean okay = TRUE;
3359 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
3361 if (!comp_unit_maybe_decode_line_info (unit, stash))
3364 BFD_ASSERT (!unit->cached);
3366 /* To preserve the original search order, we went to visit the function
3367 infos in the reversed order of the list. However, making the list
3368 bi-directional use quite a bit of extra memory. So we reverse
3369 the list first, traverse the list in the now reversed order and
3370 finally reverse the list again to get back the original order. */
3371 unit->function_table = reverse_funcinfo_list (unit->function_table);
3372 for (each_func = unit->function_table;
3374 each_func = each_func->prev_func)
3376 /* Skip nameless functions. */
3377 if (each_func->name)
3378 /* There is no need to copy name string into hash table as
3379 name string is either in the dwarf string buffer or
3380 info in the stash. */
3381 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
3382 (void*) each_func, FALSE);
3384 unit->function_table = reverse_funcinfo_list (unit->function_table);
3388 /* We do the same for variable infos. */
3389 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3390 for (each_var = unit->variable_table;
3392 each_var = each_var->prev_var)
3394 /* Skip stack vars and vars with no files or names. */
3395 if (each_var->stack == 0
3396 && each_var->file != NULL
3397 && each_var->name != NULL)
3398 /* There is no need to copy name string into hash table as
3399 name string is either in the dwarf string buffer or
3400 info in the stash. */
3401 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
3402 (void*) each_var, FALSE);
3405 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3406 unit->cached = TRUE;
3410 /* Locate a section in a BFD containing debugging info. The search starts
3411 from the section after AFTER_SEC, or from the first section in the BFD if
3412 AFTER_SEC is NULL. The search works by examining the names of the
3413 sections. There are three permissiable names. The first two are given
3414 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3415 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3416 This is a variation on the .debug_info section which has a checksum
3417 describing the contents appended onto the name. This allows the linker to
3418 identify and discard duplicate debugging sections for different
3419 compilation units. */
3420 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3423 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
3424 asection *after_sec)
3429 if (after_sec == NULL)
3431 look = debug_sections[debug_info].uncompressed_name;
3432 msec = bfd_get_section_by_name (abfd, look);
3436 look = debug_sections[debug_info].compressed_name;
3439 msec = bfd_get_section_by_name (abfd, look);
3444 for (msec = abfd->sections; msec != NULL; msec = msec->next)
3445 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3451 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3453 look = debug_sections[debug_info].uncompressed_name;
3454 if (strcmp (msec->name, look) == 0)
3457 look = debug_sections[debug_info].compressed_name;
3458 if (look != NULL && strcmp (msec->name, look) == 0)
3461 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3468 /* Transfer VMAs from object file to separate debug file. */
3471 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3475 for (s = orig_bfd->sections, d = debug_bfd->sections;
3476 s != NULL && d != NULL;
3477 s = s->next, d = d->next)
3479 if ((d->flags & SEC_DEBUGGING) != 0)
3481 /* ??? Assumes 1-1 correspondence between sections in the
3483 if (strcmp (s->name, d->name) == 0)
3485 d->output_section = s->output_section;
3486 d->output_offset = s->output_offset;
3492 /* Unset vmas for adjusted sections in STASH. */
3495 unset_sections (struct dwarf2_debug *stash)
3498 struct adjusted_section *p;
3500 i = stash->adjusted_section_count;
3501 p = stash->adjusted_sections;
3502 for (; i > 0; i--, p++)
3503 p->section->vma = 0;
3506 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3507 relocatable object file. VMAs are normally all zero in relocatable
3508 object files, so if we want to distinguish locations in sections by
3509 address we need to set VMAs so the sections do not overlap. We
3510 also set VMA on .debug_info so that when we have multiple
3511 .debug_info sections (or the linkonce variant) they also do not
3512 overlap. The multiple .debug_info sections make up a single
3513 logical section. ??? We should probably do the same for other
3517 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3520 struct adjusted_section *p;
3522 const char *debug_info_name;
3524 if (stash->adjusted_section_count != 0)
3526 i = stash->adjusted_section_count;
3527 p = stash->adjusted_sections;
3528 for (; i > 0; i--, p++)
3529 p->section->vma = p->adj_vma;
3533 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3540 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3544 if ((sect->output_section != NULL
3545 && sect->output_section != sect
3546 && (sect->flags & SEC_DEBUGGING) == 0)
3550 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3551 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3553 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3559 if (abfd == stash->bfd_ptr)
3561 abfd = stash->bfd_ptr;
3565 stash->adjusted_section_count = -1;
3568 bfd_vma last_vma = 0, last_dwarf = 0;
3569 bfd_size_type amt = i * sizeof (struct adjusted_section);
3571 p = (struct adjusted_section *) bfd_malloc (amt);
3575 stash->adjusted_sections = p;
3576 stash->adjusted_section_count = i;
3583 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3588 if ((sect->output_section != NULL
3589 && sect->output_section != sect
3590 && (sect->flags & SEC_DEBUGGING) == 0)
3594 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3595 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3597 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3601 sz = sect->rawsize ? sect->rawsize : sect->size;
3605 BFD_ASSERT (sect->alignment_power == 0);
3606 sect->vma = last_dwarf;
3611 /* Align the new address to the current section
3613 last_vma = ((last_vma
3614 + ~(-((bfd_vma) 1 << sect->alignment_power)))
3615 & (-((bfd_vma) 1 << sect->alignment_power)));
3616 sect->vma = last_vma;
3621 p->adj_vma = sect->vma;
3624 if (abfd == stash->bfd_ptr)
3626 abfd = stash->bfd_ptr;
3630 if (orig_bfd != stash->bfd_ptr)
3631 set_debug_vma (orig_bfd, stash->bfd_ptr);
3636 /* Look up a funcinfo by name using the given info hash table. If found,
3637 also update the locations pointed to by filename_ptr and linenumber_ptr.
3639 This function returns TRUE if a funcinfo that matches the given symbol
3640 and address is found with any error; otherwise it returns FALSE. */
3643 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3646 const char **filename_ptr,
3647 unsigned int *linenumber_ptr)
3649 struct funcinfo* each_func;
3650 struct funcinfo* best_fit = NULL;
3651 bfd_vma best_fit_len = 0;
3652 struct info_list_node *node;
3653 struct arange *arange;
3654 const char *name = bfd_asymbol_name (sym);
3655 asection *sec = bfd_get_section (sym);
3657 for (node = lookup_info_hash_table (hash_table, name);
3661 each_func = (struct funcinfo *) node->info;
3662 for (arange = &each_func->arange;
3664 arange = arange->next)
3666 if ((!each_func->sec || each_func->sec == sec)
3667 && addr >= arange->low
3668 && addr < arange->high
3670 || arange->high - arange->low < best_fit_len))
3672 best_fit = each_func;
3673 best_fit_len = arange->high - arange->low;
3680 best_fit->sec = sec;
3681 *filename_ptr = best_fit->file;
3682 *linenumber_ptr = best_fit->line;
3689 /* Look up a varinfo by name using the given info hash table. If found,
3690 also update the locations pointed to by filename_ptr and linenumber_ptr.
3692 This function returns TRUE if a varinfo that matches the given symbol
3693 and address is found with any error; otherwise it returns FALSE. */
3696 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3699 const char **filename_ptr,
3700 unsigned int *linenumber_ptr)
3702 const char *name = bfd_asymbol_name (sym);
3703 asection *sec = bfd_get_section (sym);
3704 struct varinfo* each;
3705 struct info_list_node *node;
3707 for (node = lookup_info_hash_table (hash_table, name);
3711 each = (struct varinfo *) node->info;
3712 if (each->addr == addr
3713 && (!each->sec || each->sec == sec))
3716 *filename_ptr = each->file;
3717 *linenumber_ptr = each->line;
3725 /* Update the funcinfo and varinfo info hash tables if they are
3726 not up to date. Returns TRUE if there is no error; otherwise
3727 returns FALSE and disable the info hash tables. */
3730 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3732 struct comp_unit *each;
3734 /* Exit if hash tables are up-to-date. */
3735 if (stash->all_comp_units == stash->hash_units_head)
3738 if (stash->hash_units_head)
3739 each = stash->hash_units_head->prev_unit;
3741 each = stash->last_comp_unit;
3745 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3746 stash->varinfo_hash_table))
3748 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3751 each = each->prev_unit;
3754 stash->hash_units_head = stash->all_comp_units;
3758 /* Check consistency of info hash tables. This is for debugging only. */
3760 static void ATTRIBUTE_UNUSED
3761 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3763 struct comp_unit *each_unit;
3764 struct funcinfo *each_func;
3765 struct varinfo *each_var;
3766 struct info_list_node *node;
3769 for (each_unit = stash->all_comp_units;
3771 each_unit = each_unit->next_unit)
3773 for (each_func = each_unit->function_table;
3775 each_func = each_func->prev_func)
3777 if (!each_func->name)
3779 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3783 while (node && !found)
3785 found = node->info == each_func;
3791 for (each_var = each_unit->variable_table;
3793 each_var = each_var->prev_var)
3795 if (!each_var->name || !each_var->file || each_var->stack)
3797 node = lookup_info_hash_table (stash->varinfo_hash_table,
3801 while (node && !found)
3803 found = node->info == each_var;
3811 /* Check to see if we want to enable the info hash tables, which consume
3812 quite a bit of memory. Currently we only check the number times
3813 bfd_dwarf2_find_line is called. In the future, we may also want to
3814 take the number of symbols into account. */
3817 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3819 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3821 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3824 /* FIXME: Maybe we should check the reduce_memory_overheads
3825 and optimize fields in the bfd_link_info structure ? */
3827 /* Create hash tables. */
3828 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3829 stash->varinfo_hash_table = create_info_hash_table (abfd);
3830 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3832 /* Turn off info hashes if any allocation above fails. */
3833 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3836 /* We need a forced update so that the info hash tables will
3837 be created even though there is no compilation unit. That
3838 happens if STASH_INFO_HASH_TRIGGER is 0. */
3839 stash_maybe_update_info_hash_tables (stash);
3840 stash->info_hash_status = STASH_INFO_HASH_ON;
3843 /* Find the file and line associated with a symbol and address using the
3844 info hash tables of a stash. If there is a match, the function returns
3845 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3846 otherwise it returns FALSE. */
3849 stash_find_line_fast (struct dwarf2_debug *stash,
3852 const char **filename_ptr,
3853 unsigned int *linenumber_ptr)
3855 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3857 if (sym->flags & BSF_FUNCTION)
3858 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3859 filename_ptr, linenumber_ptr);
3860 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3861 filename_ptr, linenumber_ptr);
3864 /* Save current section VMAs. */
3867 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3872 if (abfd->section_count == 0)
3874 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3875 if (stash->sec_vma == NULL)
3877 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3879 if (s->output_section != NULL)
3880 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3882 stash->sec_vma[i] = s->vma;
3887 /* Compare current section VMAs against those at the time the stash
3888 was created. If find_nearest_line is used in linker warnings or
3889 errors early in the link process, the debug info stash will be
3890 invalid for later calls. This is because we relocate debug info
3891 sections, so the stashed section contents depend on symbol values,
3892 which in turn depend on section VMAs. */
3895 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3900 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3904 if (s->output_section != NULL)
3905 vma = s->output_section->vma + s->output_offset;
3908 if (vma != stash->sec_vma[i])
3914 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3915 If DEBUG_BFD is not specified, we read debug information from ABFD
3916 or its gnu_debuglink. The results will be stored in PINFO.
3917 The function returns TRUE iff debug information is ready. */
3920 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3921 const struct dwarf_debug_section *debug_sections,
3924 bfd_boolean do_place)
3926 bfd_size_type amt = sizeof (struct dwarf2_debug);
3927 bfd_size_type total_size;
3929 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3933 if (stash->orig_bfd == abfd
3934 && section_vma_same (abfd, stash))
3936 /* Check that we did previously find some debug information
3937 before attempting to make use of it. */
3938 if (stash->bfd_ptr != NULL)
3940 if (do_place && !place_sections (abfd, stash))
3947 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3948 memset (stash, 0, amt);
3952 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3956 stash->orig_bfd = abfd;
3957 stash->debug_sections = debug_sections;
3958 stash->syms = symbols;
3959 if (!save_section_vma (abfd, stash))
3964 if (debug_bfd == NULL)
3967 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3968 if (msec == NULL && abfd == debug_bfd)
3970 char * debug_filename;
3972 debug_filename = bfd_follow_build_id_debuglink (abfd, DEBUGDIR);
3973 if (debug_filename == NULL)
3974 debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3976 if (debug_filename == NULL)
3977 /* No dwarf2 info, and no gnu_debuglink to follow.
3978 Note that at this point the stash has been allocated, but
3979 contains zeros. This lets future calls to this function
3980 fail more quickly. */
3983 /* Set BFD_DECOMPRESS to decompress debug sections. */
3984 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3985 || !(debug_bfd->flags |= BFD_DECOMPRESS,
3986 bfd_check_format (debug_bfd, bfd_object))
3987 || (msec = find_debug_info (debug_bfd,
3988 debug_sections, NULL)) == NULL
3989 || !bfd_generic_link_read_symbols (debug_bfd))
3992 bfd_close (debug_bfd);
3993 /* FIXME: Should we report our failure to follow the debuglink ? */
3994 free (debug_filename);
3998 symbols = bfd_get_outsymbols (debug_bfd);
3999 stash->syms = symbols;
4000 stash->close_on_cleanup = TRUE;
4002 stash->bfd_ptr = debug_bfd;
4005 && !place_sections (abfd, stash))
4008 /* There can be more than one DWARF2 info section in a BFD these
4009 days. First handle the easy case when there's only one. If
4010 there's more than one, try case two: none of the sections is
4011 compressed. In that case, read them all in and produce one
4012 large stash. We do this in two passes - in the first pass we
4013 just accumulate the section sizes, and in the second pass we
4014 read in the section's contents. (The allows us to avoid
4015 reallocing the data as we add sections to the stash.) If
4016 some or all sections are compressed, then do things the slow
4017 way, with a bunch of reallocs. */
4019 if (! find_debug_info (debug_bfd, debug_sections, msec))
4021 /* Case 1: only one info section. */
4022 total_size = msec->size;
4023 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
4025 &stash->info_ptr_memory, &total_size))
4030 /* Case 2: multiple sections. */
4031 for (total_size = 0;
4033 msec = find_debug_info (debug_bfd, debug_sections, msec))
4034 total_size += msec->size;
4036 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
4037 if (stash->info_ptr_memory == NULL)
4041 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
4043 msec = find_debug_info (debug_bfd, debug_sections, msec))
4051 if (!(bfd_simple_get_relocated_section_contents
4052 (debug_bfd, msec, stash->info_ptr_memory + total_size,
4060 stash->info_ptr = stash->info_ptr_memory;
4061 stash->info_ptr_end = stash->info_ptr + total_size;
4062 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
4063 stash->sec_info_ptr = stash->info_ptr;
4067 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4068 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4069 symbol in SYMBOLS and return the difference between the low_pc and
4070 the symbol's address. Returns 0 if no suitable symbol could be found. */
4073 _bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
4075 struct dwarf2_debug *stash;
4076 struct comp_unit * unit;
4078 stash = (struct dwarf2_debug *) *pinfo;
4083 for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
4085 struct funcinfo * func;
4087 if (unit->function_table == NULL)
4089 if (unit->line_table == NULL)
4090 unit->line_table = decode_line_info (unit, stash);
4091 if (unit->line_table != NULL)
4092 scan_unit_for_symbols (unit);
4095 for (func = unit->function_table; func != NULL; func = func->prev_func)
4096 if (func->name && func->arange.low)
4100 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4102 for (psym = symbols; * psym != NULL; psym++)
4104 asymbol * sym = * psym;
4106 if (sym->flags & BSF_FUNCTION
4107 && sym->section != NULL
4108 && strcmp (sym->name, func->name) == 0)
4109 return ((bfd_signed_vma) func->arange.low) -
4110 ((bfd_signed_vma) (sym->value + sym->section->vma));
4118 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4119 then find the nearest source code location corresponding to
4120 the address SECTION + OFFSET.
4121 Returns TRUE if the line is found without error and fills in
4122 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4123 NULL the FUNCTIONNAME_PTR is also filled in.
4124 SYMBOLS contains the symbol table for ABFD.
4125 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4126 ADDR_SIZE is the number of bytes in the initial .debug_info length
4127 field and in the abbreviation offset, or zero to indicate that the
4128 default value should be used. */
4131 _bfd_dwarf2_find_nearest_line (bfd *abfd,
4136 const char **filename_ptr,
4137 const char **functionname_ptr,
4138 unsigned int *linenumber_ptr,
4139 unsigned int *discriminator_ptr,
4140 const struct dwarf_debug_section *debug_sections,
4141 unsigned int addr_size,
4144 /* Read each compilation unit from the section .debug_info, and check
4145 to see if it contains the address we are searching for. If yes,
4146 lookup the address, and return the line number info. If no, go
4147 on to the next compilation unit.
4149 We keep a list of all the previously read compilation units, and
4150 a pointer to the next un-read compilation unit. Check the
4151 previously read units before reading more. */
4152 struct dwarf2_debug *stash;
4153 /* What address are we looking for? */
4155 struct comp_unit* each;
4156 struct funcinfo *function = NULL;
4157 bfd_boolean found = FALSE;
4158 bfd_boolean do_line;
4160 *filename_ptr = NULL;
4161 if (functionname_ptr != NULL)
4162 *functionname_ptr = NULL;
4163 *linenumber_ptr = 0;
4164 if (discriminator_ptr)
4165 *discriminator_ptr = 0;
4167 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
4169 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
4172 stash = (struct dwarf2_debug *) *pinfo;
4174 do_line = symbol != NULL;
4177 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
4178 section = bfd_get_section (symbol);
4179 addr = symbol->value;
4183 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
4186 /* If we have no SYMBOL but the section we're looking at is not a
4187 code section, then take a look through the list of symbols to see
4188 if we have a symbol at the address we're looking for. If we do
4189 then use this to look up line information. This will allow us to
4190 give file and line results for data symbols. We exclude code
4191 symbols here, if we look up a function symbol and then look up the
4192 line information we'll actually return the line number for the
4193 opening '{' rather than the function definition line. This is
4194 because looking up by symbol uses the line table, in which the
4195 first line for a function is usually the opening '{', while
4196 looking up the function by section + offset uses the
4197 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4198 which will be the line of the function name. */
4199 if ((section->flags & SEC_CODE) == 0)
4203 for (tmp = symbols; (*tmp) != NULL; ++tmp)
4204 if ((*tmp)->the_bfd == abfd
4205 && (*tmp)->section == section
4206 && (*tmp)->value == offset
4207 && ((*tmp)->flags & BSF_SECTION_SYM) == 0)
4211 /* For local symbols, keep going in the hope we find a
4213 if ((symbol->flags & BSF_GLOBAL) != 0)
4219 if (section->output_section)
4220 addr += section->output_section->vma + section->output_offset;
4222 addr += section->vma;
4224 /* A null info_ptr indicates that there is no dwarf2 info
4225 (or that an error occured while setting up the stash). */
4226 if (! stash->info_ptr)
4229 stash->inliner_chain = NULL;
4231 /* Check the previously read comp. units first. */
4234 /* The info hash tables use quite a bit of memory. We may not want to
4235 always use them. We use some heuristics to decide if and when to
4237 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
4238 stash_maybe_enable_info_hash_tables (abfd, stash);
4240 /* Keep info hash table up to date if they are available. Note that we
4241 may disable the hash tables if there is any error duing update. */
4242 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4243 stash_maybe_update_info_hash_tables (stash);
4245 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4247 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
4254 /* Check the previously read comp. units first. */
4255 for (each = stash->all_comp_units; each; each = each->next_unit)
4256 if ((symbol->flags & BSF_FUNCTION) == 0
4257 || each->arange.high == 0
4258 || comp_unit_contains_address (each, addr))
4260 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
4261 linenumber_ptr, stash);
4269 bfd_vma min_range = (bfd_vma) -1;
4270 const char * local_filename = NULL;
4271 struct funcinfo *local_function = NULL;
4272 unsigned int local_linenumber = 0;
4273 unsigned int local_discriminator = 0;
4275 for (each = stash->all_comp_units; each; each = each->next_unit)
4277 bfd_vma range = (bfd_vma) -1;
4279 found = ((each->arange.high == 0
4280 || comp_unit_contains_address (each, addr))
4281 && (range = comp_unit_find_nearest_line (each, addr,
4285 & local_discriminator,
4289 /* PRs 15935 15994: Bogus debug information may have provided us
4290 with an erroneous match. We attempt to counter this by
4291 selecting the match that has the smallest address range
4292 associated with it. (We are assuming that corrupt debug info
4293 will tend to result in extra large address ranges rather than
4294 extra small ranges).
4296 This does mean that we scan through all of the CUs associated
4297 with the bfd each time this function is called. But this does
4298 have the benefit of producing consistent results every time the
4299 function is called. */
4300 if (range <= min_range)
4302 if (filename_ptr && local_filename)
4303 * filename_ptr = local_filename;
4305 function = local_function;
4306 if (discriminator_ptr && local_discriminator)
4307 * discriminator_ptr = local_discriminator;
4308 if (local_linenumber)
4309 * linenumber_ptr = local_linenumber;
4315 if (* linenumber_ptr)
4322 /* The DWARF2 spec says that the initial length field, and the
4323 offset of the abbreviation table, should both be 4-byte values.
4324 However, some compilers do things differently. */
4327 BFD_ASSERT (addr_size == 4 || addr_size == 8);
4329 /* Read each remaining comp. units checking each as they are read. */
4330 while (stash->info_ptr < stash->info_ptr_end)
4333 unsigned int offset_size = addr_size;
4334 bfd_byte *info_ptr_unit = stash->info_ptr;
4336 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
4337 /* A 0xffffff length is the DWARF3 way of indicating
4338 we use 64-bit offsets, instead of 32-bit offsets. */
4339 if (length == 0xffffffff)
4342 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4343 stash->info_ptr += 12;
4345 /* A zero length is the IRIX way of indicating 64-bit offsets,
4346 mostly because the 64-bit length will generally fit in 32
4347 bits, and the endianness helps. */
4348 else if (length == 0)
4351 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4352 stash->info_ptr += 8;
4354 /* In the absence of the hints above, we assume 32-bit DWARF2
4355 offsets even for targets with 64-bit addresses, because:
4356 a) most of the time these targets will not have generated
4357 more than 2Gb of debug info and so will not need 64-bit
4360 b) if they do use 64-bit offsets but they are not using
4361 the size hints that are tested for above then they are
4362 not conforming to the DWARF3 standard anyway. */
4363 else if (addr_size == 8)
4366 stash->info_ptr += 4;
4369 stash->info_ptr += 4;
4376 if (stash->info_ptr + length > stash->info_ptr_end)
4379 each = parse_comp_unit (stash, length, info_ptr_unit,
4382 /* The dwarf information is damaged, don't trust it any
4386 new_ptr = stash->info_ptr + length;
4387 /* PR 17512: file: 1500698c. */
4388 if (new_ptr < stash->info_ptr)
4390 /* A corrupt length value - do not trust the info any more. */
4395 stash->info_ptr = new_ptr;
4397 if (stash->all_comp_units)
4398 stash->all_comp_units->prev_unit = each;
4400 stash->last_comp_unit = each;
4402 each->next_unit = stash->all_comp_units;
4403 stash->all_comp_units = each;
4405 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4406 compilation units. If we don't have them (i.e.,
4407 unit->high == 0), we need to consult the line info table
4408 to see if a compilation unit contains the given
4411 found = (((symbol->flags & BSF_FUNCTION) == 0
4412 || each->arange.high == 0
4413 || comp_unit_contains_address (each, addr))
4414 && comp_unit_find_line (each, symbol, addr,
4419 found = ((each->arange.high == 0
4420 || comp_unit_contains_address (each, addr))
4421 && comp_unit_find_nearest_line (each, addr,
4428 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
4429 == stash->sec->size)
4431 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
4433 stash->sec_info_ptr = stash->info_ptr;
4444 if (!function->is_linkage)
4449 fun = _bfd_elf_find_function (abfd, symbols, section, offset,
4450 *filename_ptr ? NULL : filename_ptr,
4452 sec_vma = section->vma;
4453 if (section->output_section != NULL)
4454 sec_vma = section->output_section->vma + section->output_offset;
4456 && fun->value + sec_vma == function->arange.low)
4457 function->name = *functionname_ptr;
4458 /* Even if we didn't find a linkage name, say that we have
4459 to stop a repeated search of symbols. */
4460 function->is_linkage = TRUE;
4462 *functionname_ptr = function->name;
4464 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
4465 unset_sections (stash);
4471 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
4472 const char **filename_ptr,
4473 const char **functionname_ptr,
4474 unsigned int *linenumber_ptr,
4477 struct dwarf2_debug *stash;
4479 stash = (struct dwarf2_debug *) *pinfo;
4482 struct funcinfo *func = stash->inliner_chain;
4484 if (func && func->caller_func)
4486 *filename_ptr = func->caller_file;
4487 *functionname_ptr = func->caller_func->name;
4488 *linenumber_ptr = func->caller_line;
4489 stash->inliner_chain = func->caller_func;
4498 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
4500 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4501 struct comp_unit *each;
4503 if (abfd == NULL || stash == NULL)
4506 for (each = stash->all_comp_units; each; each = each->next_unit)
4508 struct abbrev_info **abbrevs = each->abbrevs;
4509 struct funcinfo *function_table = each->function_table;
4510 struct varinfo *variable_table = each->variable_table;
4513 for (i = 0; i < ABBREV_HASH_SIZE; i++)
4515 struct abbrev_info *abbrev = abbrevs[i];
4519 free (abbrev->attrs);
4520 abbrev = abbrev->next;
4524 if (each->line_table)
4526 free (each->line_table->dirs);
4527 free (each->line_table->files);
4530 while (function_table)
4532 if (function_table->file)
4534 free (function_table->file);
4535 function_table->file = NULL;
4538 if (function_table->caller_file)
4540 free (function_table->caller_file);
4541 function_table->caller_file = NULL;
4543 function_table = function_table->prev_func;
4546 if (each->lookup_funcinfo_table)
4548 free (each->lookup_funcinfo_table);
4549 each->lookup_funcinfo_table = NULL;
4552 while (variable_table)
4554 if (variable_table->file)
4556 free (variable_table->file);
4557 variable_table->file = NULL;
4560 variable_table = variable_table->prev_var;
4564 if (stash->dwarf_abbrev_buffer)
4565 free (stash->dwarf_abbrev_buffer);
4566 if (stash->dwarf_line_buffer)
4567 free (stash->dwarf_line_buffer);
4568 if (stash->dwarf_str_buffer)
4569 free (stash->dwarf_str_buffer);
4570 if (stash->dwarf_ranges_buffer)
4571 free (stash->dwarf_ranges_buffer);
4572 if (stash->info_ptr_memory)
4573 free (stash->info_ptr_memory);
4574 if (stash->close_on_cleanup)
4575 bfd_close (stash->bfd_ptr);
4576 if (stash->alt_dwarf_str_buffer)
4577 free (stash->alt_dwarf_str_buffer);
4578 if (stash->alt_dwarf_info_buffer)
4579 free (stash->alt_dwarf_info_buffer);
4581 free (stash->sec_vma);
4582 if (stash->adjusted_sections)
4583 free (stash->adjusted_sections);
4584 if (stash->alt_bfd_ptr)
4585 bfd_close (stash->alt_bfd_ptr);
4588 /* Find the function to a particular section and offset,
4589 for error reporting. */
4592 _bfd_elf_find_function (bfd *abfd,
4596 const char **filename_ptr,
4597 const char **functionname_ptr)
4599 struct elf_find_function_cache
4601 asection *last_section;
4603 const char *filename;
4604 bfd_size_type func_size;
4607 if (symbols == NULL)
4610 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
4613 cache = elf_tdata (abfd)->elf_find_function_cache;
4616 cache = bfd_zalloc (abfd, sizeof (*cache));
4617 elf_tdata (abfd)->elf_find_function_cache = cache;
4621 if (cache->last_section != section
4622 || cache->func == NULL
4623 || offset < cache->func->value
4624 || offset >= cache->func->value + cache->func_size)
4629 /* ??? Given multiple file symbols, it is impossible to reliably
4630 choose the right file name for global symbols. File symbols are
4631 local symbols, and thus all file symbols must sort before any
4632 global symbols. The ELF spec may be interpreted to say that a
4633 file symbol must sort before other local symbols, but currently
4634 ld -r doesn't do this. So, for ld -r output, it is possible to
4635 make a better choice of file name for local symbols by ignoring
4636 file symbols appearing after a given local symbol. */
4637 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
4638 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4642 state = nothing_seen;
4643 cache->filename = NULL;
4645 cache->func_size = 0;
4646 cache->last_section = section;
4648 for (p = symbols; *p != NULL; p++)
4654 if ((sym->flags & BSF_FILE) != 0)
4657 if (state == symbol_seen)
4658 state = file_after_symbol_seen;
4662 size = bed->maybe_function_sym (sym, section, &code_off);
4664 && code_off <= offset
4665 && (code_off > low_func
4666 || (code_off == low_func
4667 && size > cache->func_size)))
4670 cache->func_size = size;
4671 cache->filename = NULL;
4672 low_func = code_off;
4674 && ((sym->flags & BSF_LOCAL) != 0
4675 || state != file_after_symbol_seen))
4676 cache->filename = bfd_asymbol_name (file);
4678 if (state == nothing_seen)
4679 state = symbol_seen;
4683 if (cache->func == NULL)
4687 *filename_ptr = cache->filename;
4688 if (functionname_ptr)
4689 *functionname_ptr = bfd_asymbol_name (cache->func);