89a3f9b183019fb8d92ba59584b6fb1429d72d55
[binutils-gdb.git] / bfd / dwarf2.c
1 /* DWARF 2 support.
2 Copyright (C) 1994-2017 Free Software Foundation, Inc.
3
4 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
5 (gavin@cygnus.com).
6
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
14
15 This file is part of BFD.
16
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.
21
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.
26
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. */
31
32 #include "sysdep.h"
33 #include "bfd.h"
34 #include "libiberty.h"
35 #include "libbfd.h"
36 #include "elf-bfd.h"
37 #include "dwarf2.h"
38
39 /* The data in the .debug_line statement prologue looks like this. */
40
41 struct line_head
42 {
43 bfd_vma total_length;
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char maximum_ops_per_insn;
48 unsigned char default_is_stmt;
49 int line_base;
50 unsigned char line_range;
51 unsigned char opcode_base;
52 unsigned char *standard_opcode_lengths;
53 };
54
55 /* Attributes have a name and a value. */
56
57 struct attribute
58 {
59 enum dwarf_attribute name;
60 enum dwarf_form form;
61 union
62 {
63 char *str;
64 struct dwarf_block *blk;
65 bfd_uint64_t val;
66 bfd_int64_t sval;
67 }
68 u;
69 };
70
71 /* Blocks are a bunch of untyped bytes. */
72 struct dwarf_block
73 {
74 unsigned int size;
75 bfd_byte *data;
76 };
77
78 struct adjusted_section
79 {
80 asection *section;
81 bfd_vma adj_vma;
82 };
83
84 struct dwarf2_debug
85 {
86 /* A list of all previously read comp_units. */
87 struct comp_unit *all_comp_units;
88
89 /* Last comp unit in list above. */
90 struct comp_unit *last_comp_unit;
91
92 /* Names of the debug sections. */
93 const struct dwarf_debug_section *debug_sections;
94
95 /* The next unread compilation unit within the .debug_info section.
96 Zero indicates that the .debug_info section has not been loaded
97 into a buffer yet. */
98 bfd_byte *info_ptr;
99
100 /* Pointer to the end of the .debug_info section memory buffer. */
101 bfd_byte *info_ptr_end;
102
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
106 time. */
107 bfd *orig_bfd;
108
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. */
112 bfd *bfd_ptr;
113 asection *sec;
114 bfd_byte *sec_info_ptr;
115
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. */
120 bfd * alt_bfd_ptr;
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;
125
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
129 memory later. */
130 bfd_byte *info_ptr_memory;
131
132 /* Pointer to the symbol table. */
133 asymbol **syms;
134
135 /* Pointer to the .debug_abbrev section loaded into memory. */
136 bfd_byte *dwarf_abbrev_buffer;
137
138 /* Length of the loaded .debug_abbrev section. */
139 bfd_size_type dwarf_abbrev_size;
140
141 /* Buffer for decode_line_info. */
142 bfd_byte *dwarf_line_buffer;
143
144 /* Length of the loaded .debug_line section. */
145 bfd_size_type dwarf_line_size;
146
147 /* Pointer to the .debug_str section loaded into memory. */
148 bfd_byte *dwarf_str_buffer;
149
150 /* Length of the loaded .debug_str section. */
151 bfd_size_type dwarf_str_size;
152
153 /* Pointer to the .debug_line_str section loaded into memory. */
154 bfd_byte *dwarf_line_str_buffer;
155
156 /* Length of the loaded .debug_line_str section. */
157 bfd_size_type dwarf_line_str_size;
158
159 /* Pointer to the .debug_ranges section loaded into memory. */
160 bfd_byte *dwarf_ranges_buffer;
161
162 /* Length of the loaded .debug_ranges section. */
163 bfd_size_type dwarf_ranges_size;
164
165 /* If the most recent call to bfd_find_nearest_line was given an
166 address in an inlined function, preserve a pointer into the
167 calling chain for subsequent calls to bfd_find_inliner_info to
168 use. */
169 struct funcinfo *inliner_chain;
170
171 /* Section VMAs at the time the stash was built. */
172 bfd_vma *sec_vma;
173
174 /* Number of sections whose VMA we must adjust. */
175 int adjusted_section_count;
176
177 /* Array of sections with adjusted VMA. */
178 struct adjusted_section *adjusted_sections;
179
180 /* Number of times find_line is called. This is used in
181 the heuristic for enabling the info hash tables. */
182 int info_hash_count;
183
184 #define STASH_INFO_HASH_TRIGGER 100
185
186 /* Hash table mapping symbol names to function infos. */
187 struct info_hash_table *funcinfo_hash_table;
188
189 /* Hash table mapping symbol names to variable infos. */
190 struct info_hash_table *varinfo_hash_table;
191
192 /* Head of comp_unit list in the last hash table update. */
193 struct comp_unit *hash_units_head;
194
195 /* Status of info hash. */
196 int info_hash_status;
197 #define STASH_INFO_HASH_OFF 0
198 #define STASH_INFO_HASH_ON 1
199 #define STASH_INFO_HASH_DISABLED 2
200
201 /* True if we opened bfd_ptr. */
202 bfd_boolean close_on_cleanup;
203 };
204
205 struct arange
206 {
207 struct arange *next;
208 bfd_vma low;
209 bfd_vma high;
210 };
211
212 /* A minimal decoding of DWARF2 compilation units. We only decode
213 what's needed to get to the line number information. */
214
215 struct comp_unit
216 {
217 /* Chain the previously read compilation units. */
218 struct comp_unit *next_unit;
219
220 /* Likewise, chain the compilation unit read after this one.
221 The comp units are stored in reversed reading order. */
222 struct comp_unit *prev_unit;
223
224 /* Keep the bfd convenient (for memory allocation). */
225 bfd *abfd;
226
227 /* The lowest and highest addresses contained in this compilation
228 unit as specified in the compilation unit header. */
229 struct arange arange;
230
231 /* The DW_AT_name attribute (for error messages). */
232 char *name;
233
234 /* The abbrev hash table. */
235 struct abbrev_info **abbrevs;
236
237 /* DW_AT_language. */
238 int lang;
239
240 /* Note that an error was found by comp_unit_find_nearest_line. */
241 int error;
242
243 /* The DW_AT_comp_dir attribute. */
244 char *comp_dir;
245
246 /* TRUE if there is a line number table associated with this comp. unit. */
247 int stmtlist;
248
249 /* Pointer to the current comp_unit so that we can find a given entry
250 by its reference. */
251 bfd_byte *info_ptr_unit;
252
253 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
254 bfd_byte *sec_info_ptr;
255
256 /* The offset into .debug_line of the line number table. */
257 unsigned long line_offset;
258
259 /* Pointer to the first child die for the comp unit. */
260 bfd_byte *first_child_die_ptr;
261
262 /* The end of the comp unit. */
263 bfd_byte *end_ptr;
264
265 /* The decoded line number, NULL if not yet decoded. */
266 struct line_info_table *line_table;
267
268 /* A list of the functions found in this comp. unit. */
269 struct funcinfo *function_table;
270
271 /* A table of function information references searchable by address. */
272 struct lookup_funcinfo *lookup_funcinfo_table;
273
274 /* Number of functions in the function_table and sorted_function_table. */
275 bfd_size_type number_of_functions;
276
277 /* A list of the variables found in this comp. unit. */
278 struct varinfo *variable_table;
279
280 /* Pointer to dwarf2_debug structure. */
281 struct dwarf2_debug *stash;
282
283 /* DWARF format version for this unit - from unit header. */
284 int version;
285
286 /* Address size for this unit - from unit header. */
287 unsigned char addr_size;
288
289 /* Offset size for this unit - from unit header. */
290 unsigned char offset_size;
291
292 /* Base address for this unit - from DW_AT_low_pc attribute of
293 DW_TAG_compile_unit DIE */
294 bfd_vma base_address;
295
296 /* TRUE if symbols are cached in hash table for faster lookup by name. */
297 bfd_boolean cached;
298 };
299
300 /* This data structure holds the information of an abbrev. */
301 struct abbrev_info
302 {
303 unsigned int number; /* Number identifying abbrev. */
304 enum dwarf_tag tag; /* DWARF tag. */
305 int has_children; /* Boolean. */
306 unsigned int num_attrs; /* Number of attributes. */
307 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
308 struct abbrev_info *next; /* Next in chain. */
309 };
310
311 struct attr_abbrev
312 {
313 enum dwarf_attribute name;
314 enum dwarf_form form;
315 bfd_vma implicit_const;
316 };
317
318 /* Map of uncompressed DWARF debug section name to compressed one. It
319 is terminated by NULL uncompressed_name. */
320
321 const struct dwarf_debug_section dwarf_debug_sections[] =
322 {
323 { ".debug_abbrev", ".zdebug_abbrev" },
324 { ".debug_aranges", ".zdebug_aranges" },
325 { ".debug_frame", ".zdebug_frame" },
326 { ".debug_info", ".zdebug_info" },
327 { ".debug_info", ".zdebug_info" },
328 { ".debug_line", ".zdebug_line" },
329 { ".debug_loc", ".zdebug_loc" },
330 { ".debug_macinfo", ".zdebug_macinfo" },
331 { ".debug_macro", ".zdebug_macro" },
332 { ".debug_pubnames", ".zdebug_pubnames" },
333 { ".debug_pubtypes", ".zdebug_pubtypes" },
334 { ".debug_ranges", ".zdebug_ranges" },
335 { ".debug_static_func", ".zdebug_static_func" },
336 { ".debug_static_vars", ".zdebug_static_vars" },
337 { ".debug_str", ".zdebug_str", },
338 { ".debug_str", ".zdebug_str", },
339 { ".debug_line_str", ".zdebug_line_str", },
340 { ".debug_types", ".zdebug_types" },
341 /* GNU DWARF 1 extensions */
342 { ".debug_sfnames", ".zdebug_sfnames" },
343 { ".debug_srcinfo", ".zebug_srcinfo" },
344 /* SGI/MIPS DWARF 2 extensions */
345 { ".debug_funcnames", ".zdebug_funcnames" },
346 { ".debug_typenames", ".zdebug_typenames" },
347 { ".debug_varnames", ".zdebug_varnames" },
348 { ".debug_weaknames", ".zdebug_weaknames" },
349 { NULL, NULL },
350 };
351
352 /* NB/ Numbers in this enum must match up with indicies
353 into the dwarf_debug_sections[] array above. */
354 enum dwarf_debug_section_enum
355 {
356 debug_abbrev = 0,
357 debug_aranges,
358 debug_frame,
359 debug_info,
360 debug_info_alt,
361 debug_line,
362 debug_loc,
363 debug_macinfo,
364 debug_macro,
365 debug_pubnames,
366 debug_pubtypes,
367 debug_ranges,
368 debug_static_func,
369 debug_static_vars,
370 debug_str,
371 debug_str_alt,
372 debug_line_str,
373 debug_types,
374 debug_sfnames,
375 debug_srcinfo,
376 debug_funcnames,
377 debug_typenames,
378 debug_varnames,
379 debug_weaknames,
380 debug_max
381 };
382
383 /* A static assertion. */
384 extern int dwarf_debug_section_assert[ARRAY_SIZE (dwarf_debug_sections)
385 == debug_max + 1 ? 1 : -1];
386
387 #ifndef ABBREV_HASH_SIZE
388 #define ABBREV_HASH_SIZE 121
389 #endif
390 #ifndef ATTR_ALLOC_CHUNK
391 #define ATTR_ALLOC_CHUNK 4
392 #endif
393
394 /* Variable and function hash tables. This is used to speed up look-up
395 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
396 In order to share code between variable and function infos, we use
397 a list of untyped pointer for all variable/function info associated with
398 a symbol. We waste a bit of memory for list with one node but that
399 simplifies the code. */
400
401 struct info_list_node
402 {
403 struct info_list_node *next;
404 void *info;
405 };
406
407 /* Info hash entry. */
408 struct info_hash_entry
409 {
410 struct bfd_hash_entry root;
411 struct info_list_node *head;
412 };
413
414 struct info_hash_table
415 {
416 struct bfd_hash_table base;
417 };
418
419 /* Function to create a new entry in info hash table. */
420
421 static struct bfd_hash_entry *
422 info_hash_table_newfunc (struct bfd_hash_entry *entry,
423 struct bfd_hash_table *table,
424 const char *string)
425 {
426 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
427
428 /* Allocate the structure if it has not already been allocated by a
429 derived class. */
430 if (ret == NULL)
431 {
432 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
433 sizeof (* ret));
434 if (ret == NULL)
435 return NULL;
436 }
437
438 /* Call the allocation method of the base class. */
439 ret = ((struct info_hash_entry *)
440 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
441
442 /* Initialize the local fields here. */
443 if (ret)
444 ret->head = NULL;
445
446 return (struct bfd_hash_entry *) ret;
447 }
448
449 /* Function to create a new info hash table. It returns a pointer to the
450 newly created table or NULL if there is any error. We need abfd
451 solely for memory allocation. */
452
453 static struct info_hash_table *
454 create_info_hash_table (bfd *abfd)
455 {
456 struct info_hash_table *hash_table;
457
458 hash_table = ((struct info_hash_table *)
459 bfd_alloc (abfd, sizeof (struct info_hash_table)));
460 if (!hash_table)
461 return hash_table;
462
463 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
464 sizeof (struct info_hash_entry)))
465 {
466 bfd_release (abfd, hash_table);
467 return NULL;
468 }
469
470 return hash_table;
471 }
472
473 /* Insert an info entry into an info hash table. We do not check of
474 duplicate entries. Also, the caller need to guarantee that the
475 right type of info in inserted as info is passed as a void* pointer.
476 This function returns true if there is no error. */
477
478 static bfd_boolean
479 insert_info_hash_table (struct info_hash_table *hash_table,
480 const char *key,
481 void *info,
482 bfd_boolean copy_p)
483 {
484 struct info_hash_entry *entry;
485 struct info_list_node *node;
486
487 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
488 key, TRUE, copy_p);
489 if (!entry)
490 return FALSE;
491
492 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
493 sizeof (*node));
494 if (!node)
495 return FALSE;
496
497 node->info = info;
498 node->next = entry->head;
499 entry->head = node;
500
501 return TRUE;
502 }
503
504 /* Look up an info entry list from an info hash table. Return NULL
505 if there is none. */
506
507 static struct info_list_node *
508 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
509 {
510 struct info_hash_entry *entry;
511
512 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
513 FALSE, FALSE);
514 return entry ? entry->head : NULL;
515 }
516
517 /* Read a section into its appropriate place in the dwarf2_debug
518 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
519 not NULL, use bfd_simple_get_relocated_section_contents to read the
520 section contents, otherwise use bfd_get_section_contents. Fail if
521 the located section does not contain at least OFFSET bytes. */
522
523 static bfd_boolean
524 read_section (bfd * abfd,
525 const struct dwarf_debug_section *sec,
526 asymbol ** syms,
527 bfd_uint64_t offset,
528 bfd_byte ** section_buffer,
529 bfd_size_type * section_size)
530 {
531 asection *msec;
532 const char *section_name = sec->uncompressed_name;
533
534 /* The section may have already been read. */
535 if (*section_buffer == NULL)
536 {
537 msec = bfd_get_section_by_name (abfd, section_name);
538 if (! msec)
539 {
540 section_name = sec->compressed_name;
541 if (section_name != NULL)
542 msec = bfd_get_section_by_name (abfd, section_name);
543 }
544 if (! msec)
545 {
546 _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
547 sec->uncompressed_name);
548 bfd_set_error (bfd_error_bad_value);
549 return FALSE;
550 }
551
552 *section_size = msec->rawsize ? msec->rawsize : msec->size;
553 if (syms)
554 {
555 *section_buffer
556 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
557 if (! *section_buffer)
558 return FALSE;
559 }
560 else
561 {
562 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
563 if (! *section_buffer)
564 return FALSE;
565 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
566 0, *section_size))
567 return FALSE;
568 }
569
570 /* Paranoia - if we are reading in a string section, make sure that it
571 is NUL terminated. This is to prevent string functions from running
572 off the end of the buffer. Note - knowing the size of the buffer is
573 not enough as some functions, eg strchr, do not have a range limited
574 equivalent.
575
576 FIXME: We ought to use a flag in the dwarf_debug_sections[] table to
577 determine the nature of a debug section, rather than checking the
578 section name as we do here. */
579 if (*section_size > 0
580 && (*section_buffer)[*section_size - 1] != 0
581 && (strstr (section_name, "_str") || strstr (section_name, "names")))
582 {
583 bfd_byte * new_buffer = malloc (*section_size + 1);
584
585 _bfd_error_handler (_("warning: dwarf string section '%s' is not NUL terminated"),
586 section_name);
587 memcpy (new_buffer, *section_buffer, *section_size);
588 new_buffer[*section_size] = 0;
589 free (*section_buffer);
590 *section_buffer = new_buffer;
591 }
592 }
593
594 /* It is possible to get a bad value for the offset into the section
595 that the client wants. Validate it here to avoid trouble later. */
596 if (offset != 0 && offset >= *section_size)
597 {
598 /* xgettext: c-format */
599 _bfd_error_handler (_("Dwarf Error: Offset (%llu)"
600 " greater than or equal to %s size (%Lu)."),
601 (long long) offset, section_name, *section_size);
602 bfd_set_error (bfd_error_bad_value);
603 return FALSE;
604 }
605
606 return TRUE;
607 }
608
609 /* Read dwarf information from a buffer. */
610
611 static unsigned int
612 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
613 {
614 if (buf + 1 > end)
615 return 0;
616 return bfd_get_8 (abfd, buf);
617 }
618
619 static int
620 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
621 {
622 if (buf + 1 > end)
623 return 0;
624 return bfd_get_signed_8 (abfd, buf);
625 }
626
627 static unsigned int
628 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
629 {
630 if (buf + 2 > end)
631 return 0;
632 return bfd_get_16 (abfd, buf);
633 }
634
635 static unsigned int
636 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
637 {
638 if (buf + 4 > end)
639 return 0;
640 return bfd_get_32 (abfd, buf);
641 }
642
643 static bfd_uint64_t
644 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
645 {
646 if (buf + 8 > end)
647 return 0;
648 return bfd_get_64 (abfd, buf);
649 }
650
651 static bfd_byte *
652 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
653 bfd_byte *buf,
654 bfd_byte *end,
655 unsigned int size ATTRIBUTE_UNUSED)
656 {
657 if (buf + size > end)
658 return NULL;
659 return buf;
660 }
661
662 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
663 Returns the number of characters in the string, *including* the NUL byte,
664 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
665 at or beyond BUF_END will not be read. Returns NULL if there was a
666 problem, or if the string is empty. */
667
668 static char *
669 read_string (bfd * abfd ATTRIBUTE_UNUSED,
670 bfd_byte * buf,
671 bfd_byte * buf_end,
672 unsigned int * bytes_read_ptr)
673 {
674 bfd_byte *str = buf;
675
676 if (buf >= buf_end)
677 {
678 * bytes_read_ptr = 0;
679 return NULL;
680 }
681
682 if (*str == '\0')
683 {
684 * bytes_read_ptr = 1;
685 return NULL;
686 }
687
688 while (buf < buf_end)
689 if (* buf ++ == 0)
690 {
691 * bytes_read_ptr = buf - str;
692 return (char *) str;
693 }
694
695 * bytes_read_ptr = buf - str;
696 return NULL;
697 }
698
699 /* Reads an offset from BUF and then locates the string at this offset
700 inside the debug string section. Returns a pointer to the string.
701 Returns the number of bytes read from BUF, *not* the length of the string,
702 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
703 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
704 a problem, or if the string is empty. Does not check for NUL termination
705 of the string. */
706
707 static char *
708 read_indirect_string (struct comp_unit * unit,
709 bfd_byte * buf,
710 bfd_byte * buf_end,
711 unsigned int * bytes_read_ptr)
712 {
713 bfd_uint64_t offset;
714 struct dwarf2_debug *stash = unit->stash;
715 char *str;
716
717 if (buf + unit->offset_size > buf_end)
718 {
719 * bytes_read_ptr = 0;
720 return NULL;
721 }
722
723 if (unit->offset_size == 4)
724 offset = read_4_bytes (unit->abfd, buf, buf_end);
725 else
726 offset = read_8_bytes (unit->abfd, buf, buf_end);
727
728 *bytes_read_ptr = unit->offset_size;
729
730 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
731 stash->syms, offset,
732 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
733 return NULL;
734
735 if (offset >= stash->dwarf_str_size)
736 return NULL;
737 str = (char *) stash->dwarf_str_buffer + offset;
738 if (*str == '\0')
739 return NULL;
740 return str;
741 }
742
743 /* Like read_indirect_string but from .debug_line_str section. */
744
745 static char *
746 read_indirect_line_string (struct comp_unit * unit,
747 bfd_byte * buf,
748 bfd_byte * buf_end,
749 unsigned int * bytes_read_ptr)
750 {
751 bfd_uint64_t offset;
752 struct dwarf2_debug *stash = unit->stash;
753 char *str;
754
755 if (buf + unit->offset_size > buf_end)
756 {
757 * bytes_read_ptr = 0;
758 return NULL;
759 }
760
761 if (unit->offset_size == 4)
762 offset = read_4_bytes (unit->abfd, buf, buf_end);
763 else
764 offset = read_8_bytes (unit->abfd, buf, buf_end);
765
766 *bytes_read_ptr = unit->offset_size;
767
768 if (! read_section (unit->abfd, &stash->debug_sections[debug_line_str],
769 stash->syms, offset,
770 &stash->dwarf_line_str_buffer,
771 &stash->dwarf_line_str_size))
772 return NULL;
773
774 if (offset >= stash->dwarf_line_str_size)
775 return NULL;
776 str = (char *) stash->dwarf_line_str_buffer + offset;
777 if (*str == '\0')
778 return NULL;
779 return str;
780 }
781
782 /* Like read_indirect_string but uses a .debug_str located in
783 an alternate file pointed to by the .gnu_debugaltlink section.
784 Used to impement DW_FORM_GNU_strp_alt. */
785
786 static char *
787 read_alt_indirect_string (struct comp_unit * unit,
788 bfd_byte * buf,
789 bfd_byte * buf_end,
790 unsigned int * bytes_read_ptr)
791 {
792 bfd_uint64_t offset;
793 struct dwarf2_debug *stash = unit->stash;
794 char *str;
795
796 if (buf + unit->offset_size > buf_end)
797 {
798 * bytes_read_ptr = 0;
799 return NULL;
800 }
801
802 if (unit->offset_size == 4)
803 offset = read_4_bytes (unit->abfd, buf, buf_end);
804 else
805 offset = read_8_bytes (unit->abfd, buf, buf_end);
806
807 *bytes_read_ptr = unit->offset_size;
808
809 if (stash->alt_bfd_ptr == NULL)
810 {
811 bfd * debug_bfd;
812 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
813
814 if (debug_filename == NULL)
815 return NULL;
816
817 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
818 || ! bfd_check_format (debug_bfd, bfd_object))
819 {
820 if (debug_bfd)
821 bfd_close (debug_bfd);
822
823 /* FIXME: Should we report our failure to follow the debuglink ? */
824 free (debug_filename);
825 return NULL;
826 }
827 stash->alt_bfd_ptr = debug_bfd;
828 }
829
830 if (! read_section (unit->stash->alt_bfd_ptr,
831 stash->debug_sections + debug_str_alt,
832 NULL, /* FIXME: Do we need to load alternate symbols ? */
833 offset,
834 &stash->alt_dwarf_str_buffer,
835 &stash->alt_dwarf_str_size))
836 return NULL;
837
838 if (offset >= stash->alt_dwarf_str_size)
839 return NULL;
840 str = (char *) stash->alt_dwarf_str_buffer + offset;
841 if (*str == '\0')
842 return NULL;
843
844 return str;
845 }
846
847 /* Resolve an alternate reference from UNIT at OFFSET.
848 Returns a pointer into the loaded alternate CU upon success
849 or NULL upon failure. */
850
851 static bfd_byte *
852 read_alt_indirect_ref (struct comp_unit * unit,
853 bfd_uint64_t offset)
854 {
855 struct dwarf2_debug *stash = unit->stash;
856
857 if (stash->alt_bfd_ptr == NULL)
858 {
859 bfd * debug_bfd;
860 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
861
862 if (debug_filename == NULL)
863 return FALSE;
864
865 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
866 || ! bfd_check_format (debug_bfd, bfd_object))
867 {
868 if (debug_bfd)
869 bfd_close (debug_bfd);
870
871 /* FIXME: Should we report our failure to follow the debuglink ? */
872 free (debug_filename);
873 return NULL;
874 }
875 stash->alt_bfd_ptr = debug_bfd;
876 }
877
878 if (! read_section (unit->stash->alt_bfd_ptr,
879 stash->debug_sections + debug_info_alt,
880 NULL, /* FIXME: Do we need to load alternate symbols ? */
881 offset,
882 &stash->alt_dwarf_info_buffer,
883 &stash->alt_dwarf_info_size))
884 return NULL;
885
886 if (offset >= stash->alt_dwarf_info_size)
887 return NULL;
888 return stash->alt_dwarf_info_buffer + offset;
889 }
890
891 static bfd_uint64_t
892 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
893 {
894 int signed_vma = 0;
895
896 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
897 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
898
899 if (buf + unit->addr_size > buf_end)
900 return 0;
901
902 if (signed_vma)
903 {
904 switch (unit->addr_size)
905 {
906 case 8:
907 return bfd_get_signed_64 (unit->abfd, buf);
908 case 4:
909 return bfd_get_signed_32 (unit->abfd, buf);
910 case 2:
911 return bfd_get_signed_16 (unit->abfd, buf);
912 default:
913 abort ();
914 }
915 }
916 else
917 {
918 switch (unit->addr_size)
919 {
920 case 8:
921 return bfd_get_64 (unit->abfd, buf);
922 case 4:
923 return bfd_get_32 (unit->abfd, buf);
924 case 2:
925 return bfd_get_16 (unit->abfd, buf);
926 default:
927 abort ();
928 }
929 }
930 }
931
932 /* Lookup an abbrev_info structure in the abbrev hash table. */
933
934 static struct abbrev_info *
935 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
936 {
937 unsigned int hash_number;
938 struct abbrev_info *abbrev;
939
940 hash_number = number % ABBREV_HASH_SIZE;
941 abbrev = abbrevs[hash_number];
942
943 while (abbrev)
944 {
945 if (abbrev->number == number)
946 return abbrev;
947 else
948 abbrev = abbrev->next;
949 }
950
951 return NULL;
952 }
953
954 /* In DWARF version 2, the description of the debugging information is
955 stored in a separate .debug_abbrev section. Before we read any
956 dies from a section we read in all abbreviations and install them
957 in a hash table. */
958
959 static struct abbrev_info**
960 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
961 {
962 struct abbrev_info **abbrevs;
963 bfd_byte *abbrev_ptr;
964 bfd_byte *abbrev_end;
965 struct abbrev_info *cur_abbrev;
966 unsigned int abbrev_number, bytes_read, abbrev_name;
967 unsigned int abbrev_form, hash_number;
968 bfd_size_type amt;
969
970 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
971 stash->syms, offset,
972 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
973 return NULL;
974
975 if (offset >= stash->dwarf_abbrev_size)
976 return NULL;
977
978 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
979 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
980 if (abbrevs == NULL)
981 return NULL;
982
983 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
984 abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
985 abbrev_number = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
986 FALSE, abbrev_end);
987 abbrev_ptr += bytes_read;
988
989 /* Loop until we reach an abbrev number of 0. */
990 while (abbrev_number)
991 {
992 amt = sizeof (struct abbrev_info);
993 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
994 if (cur_abbrev == NULL)
995 return NULL;
996
997 /* Read in abbrev header. */
998 cur_abbrev->number = abbrev_number;
999 cur_abbrev->tag = (enum dwarf_tag)
1000 _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
1001 FALSE, abbrev_end);
1002 abbrev_ptr += bytes_read;
1003 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
1004 abbrev_ptr += 1;
1005
1006 /* Now read in declarations. */
1007 for (;;)
1008 {
1009 /* Initialize it just to avoid a GCC false warning. */
1010 bfd_vma implicit_const = -1;
1011
1012 abbrev_name = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
1013 FALSE, abbrev_end);
1014 abbrev_ptr += bytes_read;
1015 abbrev_form = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
1016 FALSE, abbrev_end);
1017 abbrev_ptr += bytes_read;
1018 if (abbrev_form == DW_FORM_implicit_const)
1019 {
1020 implicit_const = _bfd_safe_read_leb128 (abfd, abbrev_ptr,
1021 &bytes_read, TRUE,
1022 abbrev_end);
1023 abbrev_ptr += bytes_read;
1024 }
1025
1026 if (abbrev_name == 0)
1027 break;
1028
1029 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
1030 {
1031 struct attr_abbrev *tmp;
1032
1033 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
1034 amt *= sizeof (struct attr_abbrev);
1035 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
1036 if (tmp == NULL)
1037 {
1038 size_t i;
1039
1040 for (i = 0; i < ABBREV_HASH_SIZE; i++)
1041 {
1042 struct abbrev_info *abbrev = abbrevs[i];
1043
1044 while (abbrev)
1045 {
1046 free (abbrev->attrs);
1047 abbrev = abbrev->next;
1048 }
1049 }
1050 return NULL;
1051 }
1052 cur_abbrev->attrs = tmp;
1053 }
1054
1055 cur_abbrev->attrs[cur_abbrev->num_attrs].name
1056 = (enum dwarf_attribute) abbrev_name;
1057 cur_abbrev->attrs[cur_abbrev->num_attrs].form
1058 = (enum dwarf_form) abbrev_form;
1059 cur_abbrev->attrs[cur_abbrev->num_attrs].implicit_const
1060 = implicit_const;
1061 ++cur_abbrev->num_attrs;
1062 }
1063
1064 hash_number = abbrev_number % ABBREV_HASH_SIZE;
1065 cur_abbrev->next = abbrevs[hash_number];
1066 abbrevs[hash_number] = cur_abbrev;
1067
1068 /* Get next abbreviation.
1069 Under Irix6 the abbreviations for a compilation unit are not
1070 always properly terminated with an abbrev number of 0.
1071 Exit loop if we encounter an abbreviation which we have
1072 already read (which means we are about to read the abbreviations
1073 for the next compile unit) or if the end of the abbreviation
1074 table is reached. */
1075 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
1076 >= stash->dwarf_abbrev_size)
1077 break;
1078 abbrev_number = _bfd_safe_read_leb128 (abfd, abbrev_ptr,
1079 &bytes_read, FALSE, abbrev_end);
1080 abbrev_ptr += bytes_read;
1081 if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
1082 break;
1083 }
1084
1085 return abbrevs;
1086 }
1087
1088 /* Returns true if the form is one which has a string value. */
1089
1090 static inline bfd_boolean
1091 is_str_attr (enum dwarf_form form)
1092 {
1093 return (form == DW_FORM_string || form == DW_FORM_strp
1094 || form == DW_FORM_line_strp || form == DW_FORM_GNU_strp_alt);
1095 }
1096
1097 /* Read and fill in the value of attribute ATTR as described by FORM.
1098 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1099 Returns an updated INFO_PTR taking into account the amount of data read. */
1100
1101 static bfd_byte *
1102 read_attribute_value (struct attribute * attr,
1103 unsigned form,
1104 bfd_vma implicit_const,
1105 struct comp_unit * unit,
1106 bfd_byte * info_ptr,
1107 bfd_byte * info_ptr_end)
1108 {
1109 bfd *abfd = unit->abfd;
1110 unsigned int bytes_read;
1111 struct dwarf_block *blk;
1112 bfd_size_type amt;
1113
1114 if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
1115 {
1116 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1117 bfd_set_error (bfd_error_bad_value);
1118 return info_ptr;
1119 }
1120
1121 attr->form = (enum dwarf_form) form;
1122
1123 switch (form)
1124 {
1125 case DW_FORM_ref_addr:
1126 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1127 DWARF3. */
1128 if (unit->version == 3 || unit->version == 4)
1129 {
1130 if (unit->offset_size == 4)
1131 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1132 else
1133 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1134 info_ptr += unit->offset_size;
1135 break;
1136 }
1137 /* FALLTHROUGH */
1138 case DW_FORM_addr:
1139 attr->u.val = read_address (unit, info_ptr, info_ptr_end);
1140 info_ptr += unit->addr_size;
1141 break;
1142 case DW_FORM_GNU_ref_alt:
1143 case DW_FORM_sec_offset:
1144 if (unit->offset_size == 4)
1145 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1146 else
1147 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1148 info_ptr += unit->offset_size;
1149 break;
1150 case DW_FORM_block2:
1151 amt = sizeof (struct dwarf_block);
1152 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1153 if (blk == NULL)
1154 return NULL;
1155 blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
1156 info_ptr += 2;
1157 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1158 info_ptr += blk->size;
1159 attr->u.blk = blk;
1160 break;
1161 case DW_FORM_block4:
1162 amt = sizeof (struct dwarf_block);
1163 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1164 if (blk == NULL)
1165 return NULL;
1166 blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
1167 info_ptr += 4;
1168 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1169 info_ptr += blk->size;
1170 attr->u.blk = blk;
1171 break;
1172 case DW_FORM_data2:
1173 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1174 info_ptr += 2;
1175 break;
1176 case DW_FORM_data4:
1177 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1178 info_ptr += 4;
1179 break;
1180 case DW_FORM_data8:
1181 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1182 info_ptr += 8;
1183 break;
1184 case DW_FORM_string:
1185 attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
1186 info_ptr += bytes_read;
1187 break;
1188 case DW_FORM_strp:
1189 attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1190 info_ptr += bytes_read;
1191 break;
1192 case DW_FORM_line_strp:
1193 attr->u.str = read_indirect_line_string (unit, info_ptr, info_ptr_end, &bytes_read);
1194 info_ptr += bytes_read;
1195 break;
1196 case DW_FORM_GNU_strp_alt:
1197 attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1198 info_ptr += bytes_read;
1199 break;
1200 case DW_FORM_exprloc:
1201 case DW_FORM_block:
1202 amt = sizeof (struct dwarf_block);
1203 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1204 if (blk == NULL)
1205 return NULL;
1206 blk->size = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1207 FALSE, info_ptr_end);
1208 info_ptr += bytes_read;
1209 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1210 info_ptr += blk->size;
1211 attr->u.blk = blk;
1212 break;
1213 case DW_FORM_block1:
1214 amt = sizeof (struct dwarf_block);
1215 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1216 if (blk == NULL)
1217 return NULL;
1218 blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
1219 info_ptr += 1;
1220 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1221 info_ptr += blk->size;
1222 attr->u.blk = blk;
1223 break;
1224 case DW_FORM_data1:
1225 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1226 info_ptr += 1;
1227 break;
1228 case DW_FORM_flag:
1229 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1230 info_ptr += 1;
1231 break;
1232 case DW_FORM_flag_present:
1233 attr->u.val = 1;
1234 break;
1235 case DW_FORM_sdata:
1236 attr->u.sval = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1237 TRUE, info_ptr_end);
1238 info_ptr += bytes_read;
1239 break;
1240 case DW_FORM_udata:
1241 attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1242 FALSE, info_ptr_end);
1243 info_ptr += bytes_read;
1244 break;
1245 case DW_FORM_ref1:
1246 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1247 info_ptr += 1;
1248 break;
1249 case DW_FORM_ref2:
1250 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1251 info_ptr += 2;
1252 break;
1253 case DW_FORM_ref4:
1254 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1255 info_ptr += 4;
1256 break;
1257 case DW_FORM_ref8:
1258 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1259 info_ptr += 8;
1260 break;
1261 case DW_FORM_ref_sig8:
1262 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1263 info_ptr += 8;
1264 break;
1265 case DW_FORM_ref_udata:
1266 attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1267 FALSE, info_ptr_end);
1268 info_ptr += bytes_read;
1269 break;
1270 case DW_FORM_indirect:
1271 form = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1272 FALSE, info_ptr_end);
1273 info_ptr += bytes_read;
1274 if (form == DW_FORM_implicit_const)
1275 {
1276 implicit_const = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
1277 TRUE, info_ptr_end);
1278 info_ptr += bytes_read;
1279 }
1280 info_ptr = read_attribute_value (attr, form, implicit_const, unit,
1281 info_ptr, info_ptr_end);
1282 break;
1283 case DW_FORM_implicit_const:
1284 attr->form = DW_FORM_sdata;
1285 attr->u.sval = implicit_const;
1286 break;
1287 default:
1288 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1289 form);
1290 bfd_set_error (bfd_error_bad_value);
1291 return NULL;
1292 }
1293 return info_ptr;
1294 }
1295
1296 /* Read an attribute described by an abbreviated attribute. */
1297
1298 static bfd_byte *
1299 read_attribute (struct attribute * attr,
1300 struct attr_abbrev * abbrev,
1301 struct comp_unit * unit,
1302 bfd_byte * info_ptr,
1303 bfd_byte * info_ptr_end)
1304 {
1305 attr->name = abbrev->name;
1306 info_ptr = read_attribute_value (attr, abbrev->form, abbrev->implicit_const,
1307 unit, info_ptr, info_ptr_end);
1308 return info_ptr;
1309 }
1310
1311 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1312 for a function. */
1313
1314 static bfd_boolean
1315 non_mangled (int lang)
1316 {
1317 switch (lang)
1318 {
1319 default:
1320 return FALSE;
1321
1322 case DW_LANG_C89:
1323 case DW_LANG_C:
1324 case DW_LANG_Ada83:
1325 case DW_LANG_Cobol74:
1326 case DW_LANG_Cobol85:
1327 case DW_LANG_Fortran77:
1328 case DW_LANG_Pascal83:
1329 case DW_LANG_C99:
1330 case DW_LANG_Ada95:
1331 case DW_LANG_PLI:
1332 case DW_LANG_UPC:
1333 case DW_LANG_C11:
1334 return TRUE;
1335 }
1336 }
1337
1338 /* Source line information table routines. */
1339
1340 #define FILE_ALLOC_CHUNK 5
1341 #define DIR_ALLOC_CHUNK 5
1342
1343 struct line_info
1344 {
1345 struct line_info * prev_line;
1346 bfd_vma address;
1347 char * filename;
1348 unsigned int line;
1349 unsigned int column;
1350 unsigned int discriminator;
1351 unsigned char op_index;
1352 unsigned char end_sequence; /* End of (sequential) code sequence. */
1353 };
1354
1355 struct fileinfo
1356 {
1357 char * name;
1358 unsigned int dir;
1359 unsigned int time;
1360 unsigned int size;
1361 };
1362
1363 struct line_sequence
1364 {
1365 bfd_vma low_pc;
1366 struct line_sequence* prev_sequence;
1367 struct line_info* last_line; /* Largest VMA. */
1368 struct line_info** line_info_lookup;
1369 bfd_size_type num_lines;
1370 };
1371
1372 struct line_info_table
1373 {
1374 bfd * abfd;
1375 unsigned int num_files;
1376 unsigned int num_dirs;
1377 unsigned int num_sequences;
1378 char * comp_dir;
1379 char ** dirs;
1380 struct fileinfo* files;
1381 struct line_sequence* sequences;
1382 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1383 };
1384
1385 /* Remember some information about each function. If the function is
1386 inlined (DW_TAG_inlined_subroutine) it may have two additional
1387 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1388 source code location where this function was inlined. */
1389
1390 struct funcinfo
1391 {
1392 /* Pointer to previous function in list of all functions. */
1393 struct funcinfo * prev_func;
1394 /* Pointer to function one scope higher. */
1395 struct funcinfo * caller_func;
1396 /* Source location file name where caller_func inlines this func. */
1397 char * caller_file;
1398 /* Source location file name. */
1399 char * file;
1400 /* Source location line number where caller_func inlines this func. */
1401 int caller_line;
1402 /* Source location line number. */
1403 int line;
1404 int tag;
1405 bfd_boolean is_linkage;
1406 const char * name;
1407 struct arange arange;
1408 /* Where the symbol is defined. */
1409 asection * sec;
1410 };
1411
1412 struct lookup_funcinfo
1413 {
1414 /* Function information corresponding to this lookup table entry. */
1415 struct funcinfo * funcinfo;
1416
1417 /* The lowest address for this specific function. */
1418 bfd_vma low_addr;
1419
1420 /* The highest address of this function before the lookup table is sorted.
1421 The highest address of all prior functions after the lookup table is
1422 sorted, which is used for binary search. */
1423 bfd_vma high_addr;
1424 };
1425
1426 struct varinfo
1427 {
1428 /* Pointer to previous variable in list of all variables */
1429 struct varinfo *prev_var;
1430 /* Source location file name */
1431 char *file;
1432 /* Source location line number */
1433 int line;
1434 int tag;
1435 char *name;
1436 bfd_vma addr;
1437 /* Where the symbol is defined */
1438 asection *sec;
1439 /* Is this a stack variable? */
1440 unsigned int stack: 1;
1441 };
1442
1443 /* Return TRUE if NEW_LINE should sort after LINE. */
1444
1445 static inline bfd_boolean
1446 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1447 {
1448 return (new_line->address > line->address
1449 || (new_line->address == line->address
1450 && (new_line->op_index > line->op_index
1451 || (new_line->op_index == line->op_index
1452 && new_line->end_sequence < line->end_sequence))));
1453 }
1454
1455
1456 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1457 that the list is sorted. Note that the line_info list is sorted from
1458 highest to lowest VMA (with possible duplicates); that is,
1459 line_info->prev_line always accesses an equal or smaller VMA. */
1460
1461 static bfd_boolean
1462 add_line_info (struct line_info_table *table,
1463 bfd_vma address,
1464 unsigned char op_index,
1465 char *filename,
1466 unsigned int line,
1467 unsigned int column,
1468 unsigned int discriminator,
1469 int end_sequence)
1470 {
1471 bfd_size_type amt = sizeof (struct line_info);
1472 struct line_sequence* seq = table->sequences;
1473 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1474
1475 if (info == NULL)
1476 return FALSE;
1477
1478 /* Set member data of 'info'. */
1479 info->prev_line = NULL;
1480 info->address = address;
1481 info->op_index = op_index;
1482 info->line = line;
1483 info->column = column;
1484 info->discriminator = discriminator;
1485 info->end_sequence = end_sequence;
1486
1487 if (filename && filename[0])
1488 {
1489 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1490 if (info->filename == NULL)
1491 return FALSE;
1492 strcpy (info->filename, filename);
1493 }
1494 else
1495 info->filename = NULL;
1496
1497 /* Find the correct location for 'info'. Normally we will receive
1498 new line_info data 1) in order and 2) with increasing VMAs.
1499 However some compilers break the rules (cf. decode_line_info) and
1500 so we include some heuristics for quickly finding the correct
1501 location for 'info'. In particular, these heuristics optimize for
1502 the common case in which the VMA sequence that we receive is a
1503 list of locally sorted VMAs such as
1504 p...z a...j (where a < j < p < z)
1505
1506 Note: table->lcl_head is used to head an *actual* or *possible*
1507 sub-sequence within the list (such as a...j) that is not directly
1508 headed by table->last_line
1509
1510 Note: we may receive duplicate entries from 'decode_line_info'. */
1511
1512 if (seq
1513 && seq->last_line->address == address
1514 && seq->last_line->op_index == op_index
1515 && seq->last_line->end_sequence == end_sequence)
1516 {
1517 /* We only keep the last entry with the same address and end
1518 sequence. See PR ld/4986. */
1519 if (table->lcl_head == seq->last_line)
1520 table->lcl_head = info;
1521 info->prev_line = seq->last_line->prev_line;
1522 seq->last_line = info;
1523 }
1524 else if (!seq || seq->last_line->end_sequence)
1525 {
1526 /* Start a new line sequence. */
1527 amt = sizeof (struct line_sequence);
1528 seq = (struct line_sequence *) bfd_malloc (amt);
1529 if (seq == NULL)
1530 return FALSE;
1531 seq->low_pc = address;
1532 seq->prev_sequence = table->sequences;
1533 seq->last_line = info;
1534 table->lcl_head = info;
1535 table->sequences = seq;
1536 table->num_sequences++;
1537 }
1538 else if (new_line_sorts_after (info, seq->last_line))
1539 {
1540 /* Normal case: add 'info' to the beginning of the current sequence. */
1541 info->prev_line = seq->last_line;
1542 seq->last_line = info;
1543
1544 /* lcl_head: initialize to head a *possible* sequence at the end. */
1545 if (!table->lcl_head)
1546 table->lcl_head = info;
1547 }
1548 else if (!new_line_sorts_after (info, table->lcl_head)
1549 && (!table->lcl_head->prev_line
1550 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1551 {
1552 /* Abnormal but easy: lcl_head is the head of 'info'. */
1553 info->prev_line = table->lcl_head->prev_line;
1554 table->lcl_head->prev_line = info;
1555 }
1556 else
1557 {
1558 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1559 are valid heads for 'info'. Reset 'lcl_head'. */
1560 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1561 struct line_info* li1 = li2->prev_line;
1562
1563 while (li1)
1564 {
1565 if (!new_line_sorts_after (info, li2)
1566 && new_line_sorts_after (info, li1))
1567 break;
1568
1569 li2 = li1; /* always non-NULL */
1570 li1 = li1->prev_line;
1571 }
1572 table->lcl_head = li2;
1573 info->prev_line = table->lcl_head->prev_line;
1574 table->lcl_head->prev_line = info;
1575 if (address < seq->low_pc)
1576 seq->low_pc = address;
1577 }
1578 return TRUE;
1579 }
1580
1581 /* Extract a fully qualified filename from a line info table.
1582 The returned string has been malloc'ed and it is the caller's
1583 responsibility to free it. */
1584
1585 static char *
1586 concat_filename (struct line_info_table *table, unsigned int file)
1587 {
1588 char *filename;
1589
1590 if (file - 1 >= table->num_files)
1591 {
1592 /* FILE == 0 means unknown. */
1593 if (file)
1594 _bfd_error_handler
1595 (_("Dwarf Error: mangled line number section (bad file number)."));
1596 return strdup ("<unknown>");
1597 }
1598
1599 filename = table->files[file - 1].name;
1600
1601 if (!IS_ABSOLUTE_PATH (filename))
1602 {
1603 char *dir_name = NULL;
1604 char *subdir_name = NULL;
1605 char *name;
1606 size_t len;
1607
1608 if (table->files[file - 1].dir
1609 /* PR 17512: file: 0317e960. */
1610 && table->files[file - 1].dir <= table->num_dirs
1611 /* PR 17512: file: 7f3d2e4b. */
1612 && table->dirs != NULL)
1613 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1614
1615 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1616 dir_name = table->comp_dir;
1617
1618 if (!dir_name)
1619 {
1620 dir_name = subdir_name;
1621 subdir_name = NULL;
1622 }
1623
1624 if (!dir_name)
1625 return strdup (filename);
1626
1627 len = strlen (dir_name) + strlen (filename) + 2;
1628
1629 if (subdir_name)
1630 {
1631 len += strlen (subdir_name) + 1;
1632 name = (char *) bfd_malloc (len);
1633 if (name)
1634 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1635 }
1636 else
1637 {
1638 name = (char *) bfd_malloc (len);
1639 if (name)
1640 sprintf (name, "%s/%s", dir_name, filename);
1641 }
1642
1643 return name;
1644 }
1645
1646 return strdup (filename);
1647 }
1648
1649 static bfd_boolean
1650 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1651 bfd_vma low_pc, bfd_vma high_pc)
1652 {
1653 struct arange *arange;
1654
1655 /* Ignore empty ranges. */
1656 if (low_pc == high_pc)
1657 return TRUE;
1658
1659 /* If the first arange is empty, use it. */
1660 if (first_arange->high == 0)
1661 {
1662 first_arange->low = low_pc;
1663 first_arange->high = high_pc;
1664 return TRUE;
1665 }
1666
1667 /* Next see if we can cheaply extend an existing range. */
1668 arange = first_arange;
1669 do
1670 {
1671 if (low_pc == arange->high)
1672 {
1673 arange->high = high_pc;
1674 return TRUE;
1675 }
1676 if (high_pc == arange->low)
1677 {
1678 arange->low = low_pc;
1679 return TRUE;
1680 }
1681 arange = arange->next;
1682 }
1683 while (arange);
1684
1685 /* Need to allocate a new arange and insert it into the arange list.
1686 Order isn't significant, so just insert after the first arange. */
1687 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1688 if (arange == NULL)
1689 return FALSE;
1690 arange->low = low_pc;
1691 arange->high = high_pc;
1692 arange->next = first_arange->next;
1693 first_arange->next = arange;
1694 return TRUE;
1695 }
1696
1697 /* Compare function for line sequences. */
1698
1699 static int
1700 compare_sequences (const void* a, const void* b)
1701 {
1702 const struct line_sequence* seq1 = a;
1703 const struct line_sequence* seq2 = b;
1704
1705 /* Sort by low_pc as the primary key. */
1706 if (seq1->low_pc < seq2->low_pc)
1707 return -1;
1708 if (seq1->low_pc > seq2->low_pc)
1709 return 1;
1710
1711 /* If low_pc values are equal, sort in reverse order of
1712 high_pc, so that the largest region comes first. */
1713 if (seq1->last_line->address < seq2->last_line->address)
1714 return 1;
1715 if (seq1->last_line->address > seq2->last_line->address)
1716 return -1;
1717
1718 if (seq1->last_line->op_index < seq2->last_line->op_index)
1719 return 1;
1720 if (seq1->last_line->op_index > seq2->last_line->op_index)
1721 return -1;
1722
1723 return 0;
1724 }
1725
1726 /* Construct the line information table for quick lookup. */
1727
1728 static bfd_boolean
1729 build_line_info_table (struct line_info_table * table,
1730 struct line_sequence * seq)
1731 {
1732 bfd_size_type amt;
1733 struct line_info** line_info_lookup;
1734 struct line_info* each_line;
1735 unsigned int num_lines;
1736 unsigned int line_index;
1737
1738 if (seq->line_info_lookup != NULL)
1739 return TRUE;
1740
1741 /* Count the number of line information entries. We could do this while
1742 scanning the debug information, but some entries may be added via
1743 lcl_head without having a sequence handy to increment the number of
1744 lines. */
1745 num_lines = 0;
1746 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1747 num_lines++;
1748
1749 if (num_lines == 0)
1750 return TRUE;
1751
1752 /* Allocate space for the line information lookup table. */
1753 amt = sizeof (struct line_info*) * num_lines;
1754 line_info_lookup = (struct line_info**) bfd_alloc (table->abfd, amt);
1755 if (line_info_lookup == NULL)
1756 return FALSE;
1757
1758 /* Create the line information lookup table. */
1759 line_index = num_lines;
1760 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1761 line_info_lookup[--line_index] = each_line;
1762
1763 BFD_ASSERT (line_index == 0);
1764
1765 seq->num_lines = num_lines;
1766 seq->line_info_lookup = line_info_lookup;
1767
1768 return TRUE;
1769 }
1770
1771 /* Sort the line sequences for quick lookup. */
1772
1773 static bfd_boolean
1774 sort_line_sequences (struct line_info_table* table)
1775 {
1776 bfd_size_type amt;
1777 struct line_sequence* sequences;
1778 struct line_sequence* seq;
1779 unsigned int n = 0;
1780 unsigned int num_sequences = table->num_sequences;
1781 bfd_vma last_high_pc;
1782
1783 if (num_sequences == 0)
1784 return TRUE;
1785
1786 /* Allocate space for an array of sequences. */
1787 amt = sizeof (struct line_sequence) * num_sequences;
1788 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1789 if (sequences == NULL)
1790 return FALSE;
1791
1792 /* Copy the linked list into the array, freeing the original nodes. */
1793 seq = table->sequences;
1794 for (n = 0; n < num_sequences; n++)
1795 {
1796 struct line_sequence* last_seq = seq;
1797
1798 BFD_ASSERT (seq);
1799 sequences[n].low_pc = seq->low_pc;
1800 sequences[n].prev_sequence = NULL;
1801 sequences[n].last_line = seq->last_line;
1802 sequences[n].line_info_lookup = NULL;
1803 sequences[n].num_lines = 0;
1804 seq = seq->prev_sequence;
1805 free (last_seq);
1806 }
1807 BFD_ASSERT (seq == NULL);
1808
1809 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1810
1811 /* Make the list binary-searchable by trimming overlapping entries
1812 and removing nested entries. */
1813 num_sequences = 1;
1814 last_high_pc = sequences[0].last_line->address;
1815 for (n = 1; n < table->num_sequences; n++)
1816 {
1817 if (sequences[n].low_pc < last_high_pc)
1818 {
1819 if (sequences[n].last_line->address <= last_high_pc)
1820 /* Skip nested entries. */
1821 continue;
1822
1823 /* Trim overlapping entries. */
1824 sequences[n].low_pc = last_high_pc;
1825 }
1826 last_high_pc = sequences[n].last_line->address;
1827 if (n > num_sequences)
1828 {
1829 /* Close up the gap. */
1830 sequences[num_sequences].low_pc = sequences[n].low_pc;
1831 sequences[num_sequences].last_line = sequences[n].last_line;
1832 }
1833 num_sequences++;
1834 }
1835
1836 table->sequences = sequences;
1837 table->num_sequences = num_sequences;
1838 return TRUE;
1839 }
1840
1841 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1842
1843 static bfd_boolean
1844 line_info_add_include_dir (struct line_info_table *table, char *cur_dir)
1845 {
1846 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1847 {
1848 char **tmp;
1849 bfd_size_type amt;
1850
1851 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1852 amt *= sizeof (char *);
1853
1854 tmp = (char **) bfd_realloc (table->dirs, amt);
1855 if (tmp == NULL)
1856 return FALSE;
1857 table->dirs = tmp;
1858 }
1859
1860 table->dirs[table->num_dirs++] = cur_dir;
1861 return TRUE;
1862 }
1863
1864 static bfd_boolean
1865 line_info_add_include_dir_stub (struct line_info_table *table, char *cur_dir,
1866 unsigned int dir ATTRIBUTE_UNUSED,
1867 unsigned int xtime ATTRIBUTE_UNUSED,
1868 unsigned int size ATTRIBUTE_UNUSED)
1869 {
1870 return line_info_add_include_dir (table, cur_dir);
1871 }
1872
1873 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1874
1875 static bfd_boolean
1876 line_info_add_file_name (struct line_info_table *table, char *cur_file,
1877 unsigned int dir, unsigned int xtime,
1878 unsigned int size)
1879 {
1880 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1881 {
1882 struct fileinfo *tmp;
1883 bfd_size_type amt;
1884
1885 amt = table->num_files + FILE_ALLOC_CHUNK;
1886 amt *= sizeof (struct fileinfo);
1887
1888 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1889 if (tmp == NULL)
1890 return FALSE;
1891 table->files = tmp;
1892 }
1893
1894 table->files[table->num_files].name = cur_file;
1895 table->files[table->num_files].dir = dir;
1896 table->files[table->num_files].time = xtime;
1897 table->files[table->num_files].size = size;
1898 table->num_files++;
1899 return TRUE;
1900 }
1901
1902 /* Read directory or file name entry format, starting with byte of
1903 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1904 entries count and the entries themselves in the described entry
1905 format. */
1906
1907 static bfd_boolean
1908 read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
1909 bfd_byte *buf_end, struct line_info_table *table,
1910 bfd_boolean (*callback) (struct line_info_table *table,
1911 char *cur_file,
1912 unsigned int dir,
1913 unsigned int time,
1914 unsigned int size))
1915 {
1916 bfd *abfd = unit->abfd;
1917 bfd_byte format_count, formati;
1918 bfd_vma data_count, datai;
1919 bfd_byte *buf = *bufp;
1920 bfd_byte *format_header_data;
1921 unsigned int bytes_read;
1922
1923 format_count = read_1_byte (abfd, buf, buf_end);
1924 buf += 1;
1925 format_header_data = buf;
1926 for (formati = 0; formati < format_count; formati++)
1927 {
1928 _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
1929 buf += bytes_read;
1930 _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
1931 buf += bytes_read;
1932 }
1933
1934 data_count = _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
1935 buf += bytes_read;
1936 for (datai = 0; datai < data_count; datai++)
1937 {
1938 bfd_byte *format = format_header_data;
1939 struct fileinfo fe;
1940
1941 for (formati = 0; formati < format_count; formati++)
1942 {
1943 bfd_vma content_type, form;
1944 char *string_trash;
1945 char **stringp = &string_trash;
1946 unsigned int uint_trash, *uintp = &uint_trash;
1947
1948 content_type = _bfd_safe_read_leb128 (abfd, format, &bytes_read,
1949 FALSE, buf_end);
1950 format += bytes_read;
1951 switch (content_type)
1952 {
1953 case DW_LNCT_path:
1954 stringp = &fe.name;
1955 break;
1956 case DW_LNCT_directory_index:
1957 uintp = &fe.dir;
1958 break;
1959 case DW_LNCT_timestamp:
1960 uintp = &fe.time;
1961 break;
1962 case DW_LNCT_size:
1963 uintp = &fe.size;
1964 break;
1965 case DW_LNCT_MD5:
1966 break;
1967 default:
1968 _bfd_error_handler
1969 (_("Dwarf Error: Unknown format content type %Lu."),
1970 content_type);
1971 bfd_set_error (bfd_error_bad_value);
1972 return FALSE;
1973 }
1974
1975 form = _bfd_safe_read_leb128 (abfd, format, &bytes_read, FALSE,
1976 buf_end);
1977 format += bytes_read;
1978 switch (form)
1979 {
1980 case DW_FORM_string:
1981 *stringp = read_string (abfd, buf, buf_end, &bytes_read);
1982 buf += bytes_read;
1983 break;
1984
1985 case DW_FORM_line_strp:
1986 *stringp = read_indirect_line_string (unit, buf, buf_end, &bytes_read);
1987 buf += bytes_read;
1988 break;
1989
1990 case DW_FORM_data1:
1991 *uintp = read_1_byte (abfd, buf, buf_end);
1992 buf += 1;
1993 break;
1994
1995 case DW_FORM_data2:
1996 *uintp = read_2_bytes (abfd, buf, buf_end);
1997 buf += 2;
1998 break;
1999
2000 case DW_FORM_data4:
2001 *uintp = read_4_bytes (abfd, buf, buf_end);
2002 buf += 4;
2003 break;
2004
2005 case DW_FORM_data8:
2006 *uintp = read_8_bytes (abfd, buf, buf_end);
2007 buf += 8;
2008 break;
2009
2010 case DW_FORM_udata:
2011 *uintp = _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE,
2012 buf_end);
2013 buf += bytes_read;
2014 break;
2015
2016 case DW_FORM_block:
2017 /* It is valid only for DW_LNCT_timestamp which is ignored by
2018 current GDB. */
2019 break;
2020 }
2021 }
2022
2023 if (!callback (table, fe.name, fe.dir, fe.time, fe.size))
2024 return FALSE;
2025 }
2026
2027 *bufp = buf;
2028 return TRUE;
2029 }
2030
2031 /* Decode the line number information for UNIT. */
2032
2033 static struct line_info_table*
2034 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
2035 {
2036 bfd *abfd = unit->abfd;
2037 struct line_info_table* table;
2038 bfd_byte *line_ptr;
2039 bfd_byte *line_end;
2040 struct line_head lh;
2041 unsigned int i, bytes_read, offset_size;
2042 char *cur_file, *cur_dir;
2043 unsigned char op_code, extended_op, adj_opcode;
2044 unsigned int exop_len;
2045 bfd_size_type amt;
2046
2047 if (! read_section (abfd, &stash->debug_sections[debug_line],
2048 stash->syms, unit->line_offset,
2049 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
2050 return NULL;
2051
2052 amt = sizeof (struct line_info_table);
2053 table = (struct line_info_table *) bfd_alloc (abfd, amt);
2054 if (table == NULL)
2055 return NULL;
2056 table->abfd = abfd;
2057 table->comp_dir = unit->comp_dir;
2058
2059 table->num_files = 0;
2060 table->files = NULL;
2061
2062 table->num_dirs = 0;
2063 table->dirs = NULL;
2064
2065 table->num_sequences = 0;
2066 table->sequences = NULL;
2067
2068 table->lcl_head = NULL;
2069
2070 if (stash->dwarf_line_size < 16)
2071 {
2072 _bfd_error_handler
2073 (_("Dwarf Error: Line info section is too small (%Ld)"),
2074 stash->dwarf_line_size);
2075 bfd_set_error (bfd_error_bad_value);
2076 return NULL;
2077 }
2078 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
2079 line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
2080
2081 /* Read in the prologue. */
2082 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
2083 line_ptr += 4;
2084 offset_size = 4;
2085 if (lh.total_length == 0xffffffff)
2086 {
2087 lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
2088 line_ptr += 8;
2089 offset_size = 8;
2090 }
2091 else if (lh.total_length == 0 && unit->addr_size == 8)
2092 {
2093 /* Handle (non-standard) 64-bit DWARF2 formats. */
2094 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
2095 line_ptr += 4;
2096 offset_size = 8;
2097 }
2098
2099 if (lh.total_length > (size_t) (line_end - line_ptr))
2100 {
2101 _bfd_error_handler
2102 /* xgettext: c-format */
2103 (_("Dwarf Error: Line info data is bigger (%#Lx)"
2104 " than the space remaining in the section (%#lx)"),
2105 lh.total_length, (unsigned long) (line_end - line_ptr));
2106 bfd_set_error (bfd_error_bad_value);
2107 return NULL;
2108 }
2109
2110 line_end = line_ptr + lh.total_length;
2111
2112 lh.version = read_2_bytes (abfd, line_ptr, line_end);
2113 if (lh.version < 2 || lh.version > 5)
2114 {
2115 _bfd_error_handler
2116 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
2117 bfd_set_error (bfd_error_bad_value);
2118 return NULL;
2119 }
2120 line_ptr += 2;
2121
2122 if (line_ptr + offset_size + (lh.version >= 5 ? 8 : (lh.version >= 4 ? 6 : 5))
2123 >= line_end)
2124 {
2125 _bfd_error_handler
2126 (_("Dwarf Error: Ran out of room reading prologue"));
2127 bfd_set_error (bfd_error_bad_value);
2128 return NULL;
2129 }
2130
2131 if (lh.version >= 5)
2132 {
2133 unsigned int segment_selector_size;
2134
2135 /* Skip address size. */
2136 read_1_byte (abfd, line_ptr, line_end);
2137 line_ptr += 1;
2138
2139 segment_selector_size = read_1_byte (abfd, line_ptr, line_end);
2140 line_ptr += 1;
2141 if (segment_selector_size != 0)
2142 {
2143 _bfd_error_handler
2144 (_("Dwarf Error: Line info unsupported segment selector size %u."),
2145 segment_selector_size);
2146 bfd_set_error (bfd_error_bad_value);
2147 return NULL;
2148 }
2149 }
2150
2151 if (offset_size == 4)
2152 lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
2153 else
2154 lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
2155 line_ptr += offset_size;
2156
2157 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
2158 line_ptr += 1;
2159
2160 if (lh.version >= 4)
2161 {
2162 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
2163 line_ptr += 1;
2164 }
2165 else
2166 lh.maximum_ops_per_insn = 1;
2167
2168 if (lh.maximum_ops_per_insn == 0)
2169 {
2170 _bfd_error_handler
2171 (_("Dwarf Error: Invalid maximum operations per instruction."));
2172 bfd_set_error (bfd_error_bad_value);
2173 return NULL;
2174 }
2175
2176 lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
2177 line_ptr += 1;
2178
2179 lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
2180 line_ptr += 1;
2181
2182 lh.line_range = read_1_byte (abfd, line_ptr, line_end);
2183 line_ptr += 1;
2184
2185 lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
2186 line_ptr += 1;
2187
2188 if (line_ptr + (lh.opcode_base - 1) >= line_end)
2189 {
2190 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
2191 bfd_set_error (bfd_error_bad_value);
2192 return NULL;
2193 }
2194
2195 amt = lh.opcode_base * sizeof (unsigned char);
2196 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
2197
2198 lh.standard_opcode_lengths[0] = 1;
2199
2200 for (i = 1; i < lh.opcode_base; ++i)
2201 {
2202 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
2203 line_ptr += 1;
2204 }
2205
2206 if (lh.version >= 5)
2207 {
2208 /* Read directory table. */
2209 if (!read_formatted_entries (unit, &line_ptr, line_end, table,
2210 line_info_add_include_dir_stub))
2211 goto fail;
2212
2213 /* Read file name table. */
2214 if (!read_formatted_entries (unit, &line_ptr, line_end, table,
2215 line_info_add_file_name))
2216 goto fail;
2217 }
2218 else
2219 {
2220 /* Read directory table. */
2221 while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
2222 {
2223 line_ptr += bytes_read;
2224
2225 if (!line_info_add_include_dir (table, cur_dir))
2226 goto fail;
2227 }
2228
2229 line_ptr += bytes_read;
2230
2231 /* Read file name table. */
2232 while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
2233 {
2234 unsigned int dir, xtime, size;
2235
2236 line_ptr += bytes_read;
2237
2238 dir = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2239 line_ptr += bytes_read;
2240 xtime = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2241 line_ptr += bytes_read;
2242 size = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2243 line_ptr += bytes_read;
2244
2245 if (!line_info_add_file_name (table, cur_file, dir, xtime, size))
2246 goto fail;
2247 }
2248
2249 line_ptr += bytes_read;
2250 }
2251
2252 /* Read the statement sequences until there's nothing left. */
2253 while (line_ptr < line_end)
2254 {
2255 /* State machine registers. */
2256 bfd_vma address = 0;
2257 unsigned char op_index = 0;
2258 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
2259 unsigned int line = 1;
2260 unsigned int column = 0;
2261 unsigned int discriminator = 0;
2262 int is_stmt = lh.default_is_stmt;
2263 int end_sequence = 0;
2264 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2265 compilers generate address sequences that are wildly out of
2266 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2267 for ia64-Linux). Thus, to determine the low and high
2268 address, we must compare on every DW_LNS_copy, etc. */
2269 bfd_vma low_pc = (bfd_vma) -1;
2270 bfd_vma high_pc = 0;
2271
2272 /* Decode the table. */
2273 while (! end_sequence)
2274 {
2275 op_code = read_1_byte (abfd, line_ptr, line_end);
2276 line_ptr += 1;
2277
2278 if (op_code >= lh.opcode_base)
2279 {
2280 /* Special operand. */
2281 adj_opcode = op_code - lh.opcode_base;
2282 if (lh.line_range == 0)
2283 goto line_fail;
2284 if (lh.maximum_ops_per_insn == 1)
2285 address += (adj_opcode / lh.line_range
2286 * lh.minimum_instruction_length);
2287 else
2288 {
2289 address += ((op_index + adj_opcode / lh.line_range)
2290 / lh.maximum_ops_per_insn
2291 * lh.minimum_instruction_length);
2292 op_index = ((op_index + adj_opcode / lh.line_range)
2293 % lh.maximum_ops_per_insn);
2294 }
2295 line += lh.line_base + (adj_opcode % lh.line_range);
2296 /* Append row to matrix using current values. */
2297 if (!add_line_info (table, address, op_index, filename,
2298 line, column, discriminator, 0))
2299 goto line_fail;
2300 discriminator = 0;
2301 if (address < low_pc)
2302 low_pc = address;
2303 if (address > high_pc)
2304 high_pc = address;
2305 }
2306 else switch (op_code)
2307 {
2308 case DW_LNS_extended_op:
2309 exop_len = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2310 FALSE, line_end);
2311 line_ptr += bytes_read;
2312 extended_op = read_1_byte (abfd, line_ptr, line_end);
2313 line_ptr += 1;
2314
2315 switch (extended_op)
2316 {
2317 case DW_LNE_end_sequence:
2318 end_sequence = 1;
2319 if (!add_line_info (table, address, op_index, filename, line,
2320 column, discriminator, end_sequence))
2321 goto line_fail;
2322 discriminator = 0;
2323 if (address < low_pc)
2324 low_pc = address;
2325 if (address > high_pc)
2326 high_pc = address;
2327 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2328 goto line_fail;
2329 break;
2330 case DW_LNE_set_address:
2331 address = read_address (unit, line_ptr, line_end);
2332 op_index = 0;
2333 line_ptr += unit->addr_size;
2334 break;
2335 case DW_LNE_define_file:
2336 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
2337 line_ptr += bytes_read;
2338 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
2339 {
2340 struct fileinfo *tmp;
2341
2342 amt = table->num_files + FILE_ALLOC_CHUNK;
2343 amt *= sizeof (struct fileinfo);
2344 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
2345 if (tmp == NULL)
2346 goto line_fail;
2347 table->files = tmp;
2348 }
2349 table->files[table->num_files].name = cur_file;
2350 table->files[table->num_files].dir =
2351 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2352 FALSE, line_end);
2353 line_ptr += bytes_read;
2354 table->files[table->num_files].time =
2355 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2356 FALSE, line_end);
2357 line_ptr += bytes_read;
2358 table->files[table->num_files].size =
2359 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2360 FALSE, line_end);
2361 line_ptr += bytes_read;
2362 table->num_files++;
2363 break;
2364 case DW_LNE_set_discriminator:
2365 discriminator =
2366 _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2367 FALSE, line_end);
2368 line_ptr += bytes_read;
2369 break;
2370 case DW_LNE_HP_source_file_correlation:
2371 line_ptr += exop_len - 1;
2372 break;
2373 default:
2374 _bfd_error_handler
2375 (_("Dwarf Error: mangled line number section."));
2376 bfd_set_error (bfd_error_bad_value);
2377 line_fail:
2378 if (filename != NULL)
2379 free (filename);
2380 goto fail;
2381 }
2382 break;
2383 case DW_LNS_copy:
2384 if (!add_line_info (table, address, op_index,
2385 filename, line, column, discriminator, 0))
2386 goto line_fail;
2387 discriminator = 0;
2388 if (address < low_pc)
2389 low_pc = address;
2390 if (address > high_pc)
2391 high_pc = address;
2392 break;
2393 case DW_LNS_advance_pc:
2394 if (lh.maximum_ops_per_insn == 1)
2395 address += (lh.minimum_instruction_length
2396 * _bfd_safe_read_leb128 (abfd, line_ptr,
2397 &bytes_read,
2398 FALSE, line_end));
2399 else
2400 {
2401 bfd_vma adjust = _bfd_safe_read_leb128 (abfd, line_ptr,
2402 &bytes_read,
2403 FALSE, line_end);
2404 address = ((op_index + adjust) / lh.maximum_ops_per_insn
2405 * lh.minimum_instruction_length);
2406 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2407 }
2408 line_ptr += bytes_read;
2409 break;
2410 case DW_LNS_advance_line:
2411 line += _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2412 TRUE, line_end);
2413 line_ptr += bytes_read;
2414 break;
2415 case DW_LNS_set_file:
2416 {
2417 unsigned int file;
2418
2419 /* The file and directory tables are 0
2420 based, the references are 1 based. */
2421 file = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2422 FALSE, line_end);
2423 line_ptr += bytes_read;
2424 if (filename)
2425 free (filename);
2426 filename = concat_filename (table, file);
2427 break;
2428 }
2429 case DW_LNS_set_column:
2430 column = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2431 FALSE, line_end);
2432 line_ptr += bytes_read;
2433 break;
2434 case DW_LNS_negate_stmt:
2435 is_stmt = (!is_stmt);
2436 break;
2437 case DW_LNS_set_basic_block:
2438 break;
2439 case DW_LNS_const_add_pc:
2440 if (lh.maximum_ops_per_insn == 1)
2441 address += (lh.minimum_instruction_length
2442 * ((255 - lh.opcode_base) / lh.line_range));
2443 else
2444 {
2445 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
2446 address += (lh.minimum_instruction_length
2447 * ((op_index + adjust)
2448 / lh.maximum_ops_per_insn));
2449 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2450 }
2451 break;
2452 case DW_LNS_fixed_advance_pc:
2453 address += read_2_bytes (abfd, line_ptr, line_end);
2454 op_index = 0;
2455 line_ptr += 2;
2456 break;
2457 default:
2458 /* Unknown standard opcode, ignore it. */
2459 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
2460 {
2461 (void) _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
2462 FALSE, line_end);
2463 line_ptr += bytes_read;
2464 }
2465 break;
2466 }
2467 }
2468
2469 if (filename)
2470 free (filename);
2471 }
2472
2473 if (sort_line_sequences (table))
2474 return table;
2475
2476 fail:
2477 if (table->sequences != NULL)
2478 free (table->sequences);
2479 if (table->files != NULL)
2480 free (table->files);
2481 if (table->dirs != NULL)
2482 free (table->dirs);
2483 return NULL;
2484 }
2485
2486 /* If ADDR is within TABLE set the output parameters and return the
2487 range of addresses covered by the entry used to fill them out.
2488 Otherwise set * FILENAME_PTR to NULL and return 0.
2489 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2490 are pointers to the objects to be filled in. */
2491
2492 static bfd_vma
2493 lookup_address_in_line_info_table (struct line_info_table *table,
2494 bfd_vma addr,
2495 const char **filename_ptr,
2496 unsigned int *linenumber_ptr,
2497 unsigned int *discriminator_ptr)
2498 {
2499 struct line_sequence *seq = NULL;
2500 struct line_info *info;
2501 int low, high, mid;
2502
2503 /* Binary search the array of sequences. */
2504 low = 0;
2505 high = table->num_sequences;
2506 while (low < high)
2507 {
2508 mid = (low + high) / 2;
2509 seq = &table->sequences[mid];
2510 if (addr < seq->low_pc)
2511 high = mid;
2512 else if (addr >= seq->last_line->address)
2513 low = mid + 1;
2514 else
2515 break;
2516 }
2517
2518 /* Check for a valid sequence. */
2519 if (!seq || addr < seq->low_pc || addr >= seq->last_line->address)
2520 goto fail;
2521
2522 if (!build_line_info_table (table, seq))
2523 goto fail;
2524
2525 /* Binary search the array of line information. */
2526 low = 0;
2527 high = seq->num_lines;
2528 info = NULL;
2529 while (low < high)
2530 {
2531 mid = (low + high) / 2;
2532 info = seq->line_info_lookup[mid];
2533 if (addr < info->address)
2534 high = mid;
2535 else if (addr >= seq->line_info_lookup[mid + 1]->address)
2536 low = mid + 1;
2537 else
2538 break;
2539 }
2540
2541 /* Check for a valid line information entry. */
2542 if (info
2543 && addr >= info->address
2544 && addr < seq->line_info_lookup[mid + 1]->address
2545 && !(info->end_sequence || info == seq->last_line))
2546 {
2547 *filename_ptr = info->filename;
2548 *linenumber_ptr = info->line;
2549 if (discriminator_ptr)
2550 *discriminator_ptr = info->discriminator;
2551 return seq->last_line->address - seq->low_pc;
2552 }
2553
2554 fail:
2555 *filename_ptr = NULL;
2556 return 0;
2557 }
2558
2559 /* Read in the .debug_ranges section for future reference. */
2560
2561 static bfd_boolean
2562 read_debug_ranges (struct comp_unit * unit)
2563 {
2564 struct dwarf2_debug * stash = unit->stash;
2565
2566 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
2567 stash->syms, 0,
2568 &stash->dwarf_ranges_buffer,
2569 &stash->dwarf_ranges_size);
2570 }
2571
2572 /* Function table functions. */
2573
2574 static int
2575 compare_lookup_funcinfos (const void * a, const void * b)
2576 {
2577 const struct lookup_funcinfo * lookup1 = a;
2578 const struct lookup_funcinfo * lookup2 = b;
2579
2580 if (lookup1->low_addr < lookup2->low_addr)
2581 return -1;
2582 if (lookup1->low_addr > lookup2->low_addr)
2583 return 1;
2584 if (lookup1->high_addr < lookup2->high_addr)
2585 return -1;
2586 if (lookup1->high_addr > lookup2->high_addr)
2587 return 1;
2588
2589 return 0;
2590 }
2591
2592 static bfd_boolean
2593 build_lookup_funcinfo_table (struct comp_unit * unit)
2594 {
2595 struct lookup_funcinfo *lookup_funcinfo_table = unit->lookup_funcinfo_table;
2596 unsigned int number_of_functions = unit->number_of_functions;
2597 struct funcinfo *each;
2598 struct lookup_funcinfo *entry;
2599 size_t func_index;
2600 struct arange *range;
2601 bfd_vma low_addr, high_addr;
2602
2603 if (lookup_funcinfo_table || number_of_functions == 0)
2604 return TRUE;
2605
2606 /* Create the function info lookup table. */
2607 lookup_funcinfo_table = (struct lookup_funcinfo *)
2608 bfd_malloc (number_of_functions * sizeof (struct lookup_funcinfo));
2609 if (lookup_funcinfo_table == NULL)
2610 return FALSE;
2611
2612 /* Populate the function info lookup table. */
2613 func_index = number_of_functions;
2614 for (each = unit->function_table; each; each = each->prev_func)
2615 {
2616 entry = &lookup_funcinfo_table[--func_index];
2617 entry->funcinfo = each;
2618
2619 /* Calculate the lowest and highest address for this function entry. */
2620 low_addr = entry->funcinfo->arange.low;
2621 high_addr = entry->funcinfo->arange.high;
2622
2623 for (range = entry->funcinfo->arange.next; range; range = range->next)
2624 {
2625 if (range->low < low_addr)
2626 low_addr = range->low;
2627 if (range->high > high_addr)
2628 high_addr = range->high;
2629 }
2630
2631 entry->low_addr = low_addr;
2632 entry->high_addr = high_addr;
2633 }
2634
2635 BFD_ASSERT (func_index == 0);
2636
2637 /* Sort the function by address. */
2638 qsort (lookup_funcinfo_table,
2639 number_of_functions,
2640 sizeof (struct lookup_funcinfo),
2641 compare_lookup_funcinfos);
2642
2643 /* Calculate the high watermark for each function in the lookup table. */
2644 high_addr = lookup_funcinfo_table[0].high_addr;
2645 for (func_index = 1; func_index < number_of_functions; func_index++)
2646 {
2647 entry = &lookup_funcinfo_table[func_index];
2648 if (entry->high_addr > high_addr)
2649 high_addr = entry->high_addr;
2650 else
2651 entry->high_addr = high_addr;
2652 }
2653
2654 unit->lookup_funcinfo_table = lookup_funcinfo_table;
2655 return TRUE;
2656 }
2657
2658 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2659 TRUE. Note that we need to find the function that has the smallest range
2660 that contains ADDR, to handle inlined functions without depending upon
2661 them being ordered in TABLE by increasing range. */
2662
2663 static bfd_boolean
2664 lookup_address_in_function_table (struct comp_unit *unit,
2665 bfd_vma addr,
2666 struct funcinfo **function_ptr)
2667 {
2668 unsigned int number_of_functions = unit->number_of_functions;
2669 struct lookup_funcinfo* lookup_funcinfo = NULL;
2670 struct funcinfo* funcinfo = NULL;
2671 struct funcinfo* best_fit = NULL;
2672 bfd_vma best_fit_len = 0;
2673 bfd_size_type low, high, mid, first;
2674 struct arange *arange;
2675
2676 if (number_of_functions == 0)
2677 return FALSE;
2678
2679 if (!build_lookup_funcinfo_table (unit))
2680 return FALSE;
2681
2682 if (unit->lookup_funcinfo_table[number_of_functions - 1].high_addr < addr)
2683 return FALSE;
2684
2685 /* Find the first function in the lookup table which may contain the
2686 specified address. */
2687 low = 0;
2688 high = number_of_functions;
2689 first = high;
2690 while (low < high)
2691 {
2692 mid = (low + high) / 2;
2693 lookup_funcinfo = &unit->lookup_funcinfo_table[mid];
2694 if (addr < lookup_funcinfo->low_addr)
2695 high = mid;
2696 else if (addr >= lookup_funcinfo->high_addr)
2697 low = mid + 1;
2698 else
2699 high = first = mid;
2700 }
2701
2702 /* Find the 'best' match for the address. The prior algorithm defined the
2703 best match as the function with the smallest address range containing
2704 the specified address. This definition should probably be changed to the
2705 innermost inline routine containing the address, but right now we want
2706 to get the same results we did before. */
2707 while (first < number_of_functions)
2708 {
2709 if (addr < unit->lookup_funcinfo_table[first].low_addr)
2710 break;
2711 funcinfo = unit->lookup_funcinfo_table[first].funcinfo;
2712
2713 for (arange = &funcinfo->arange; arange; arange = arange->next)
2714 {
2715 if (addr < arange->low || addr >= arange->high)
2716 continue;
2717
2718 if (!best_fit
2719 || arange->high - arange->low < best_fit_len
2720 /* The following comparison is designed to return the same
2721 match as the previous algorithm for routines which have the
2722 same best fit length. */
2723 || (arange->high - arange->low == best_fit_len
2724 && funcinfo > best_fit))
2725 {
2726 best_fit = funcinfo;
2727 best_fit_len = arange->high - arange->low;
2728 }
2729 }
2730
2731 first++;
2732 }
2733
2734 if (!best_fit)
2735 return FALSE;
2736
2737 *function_ptr = best_fit;
2738 return TRUE;
2739 }
2740
2741 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2742 and LINENUMBER_PTR, and return TRUE. */
2743
2744 static bfd_boolean
2745 lookup_symbol_in_function_table (struct comp_unit *unit,
2746 asymbol *sym,
2747 bfd_vma addr,
2748 const char **filename_ptr,
2749 unsigned int *linenumber_ptr)
2750 {
2751 struct funcinfo* each_func;
2752 struct funcinfo* best_fit = NULL;
2753 bfd_vma best_fit_len = 0;
2754 struct arange *arange;
2755 const char *name = bfd_asymbol_name (sym);
2756 asection *sec = bfd_get_section (sym);
2757
2758 for (each_func = unit->function_table;
2759 each_func;
2760 each_func = each_func->prev_func)
2761 {
2762 for (arange = &each_func->arange;
2763 arange;
2764 arange = arange->next)
2765 {
2766 if ((!each_func->sec || each_func->sec == sec)
2767 && addr >= arange->low
2768 && addr < arange->high
2769 && each_func->name
2770 && strcmp (name, each_func->name) == 0
2771 && (!best_fit
2772 || arange->high - arange->low < best_fit_len))
2773 {
2774 best_fit = each_func;
2775 best_fit_len = arange->high - arange->low;
2776 }
2777 }
2778 }
2779
2780 if (best_fit)
2781 {
2782 best_fit->sec = sec;
2783 *filename_ptr = best_fit->file;
2784 *linenumber_ptr = best_fit->line;
2785 return TRUE;
2786 }
2787 else
2788 return FALSE;
2789 }
2790
2791 /* Variable table functions. */
2792
2793 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2794 LINENUMBER_PTR, and return TRUE. */
2795
2796 static bfd_boolean
2797 lookup_symbol_in_variable_table (struct comp_unit *unit,
2798 asymbol *sym,
2799 bfd_vma addr,
2800 const char **filename_ptr,
2801 unsigned int *linenumber_ptr)
2802 {
2803 const char *name = bfd_asymbol_name (sym);
2804 asection *sec = bfd_get_section (sym);
2805 struct varinfo* each;
2806
2807 for (each = unit->variable_table; each; each = each->prev_var)
2808 if (each->stack == 0
2809 && each->file != NULL
2810 && each->name != NULL
2811 && each->addr == addr
2812 && (!each->sec || each->sec == sec)
2813 && strcmp (name, each->name) == 0)
2814 break;
2815
2816 if (each)
2817 {
2818 each->sec = sec;
2819 *filename_ptr = each->file;
2820 *linenumber_ptr = each->line;
2821 return TRUE;
2822 }
2823
2824 return FALSE;
2825 }
2826
2827 static char *
2828 find_abstract_instance_name (struct comp_unit *unit,
2829 struct attribute *attr_ptr,
2830 bfd_boolean *is_linkage)
2831 {
2832 bfd *abfd = unit->abfd;
2833 bfd_byte *info_ptr;
2834 bfd_byte *info_ptr_end;
2835 unsigned int abbrev_number, bytes_read, i;
2836 struct abbrev_info *abbrev;
2837 bfd_uint64_t die_ref = attr_ptr->u.val;
2838 struct attribute attr;
2839 char *name = NULL;
2840
2841 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2842 is an offset from the .debug_info section, not the current CU. */
2843 if (attr_ptr->form == DW_FORM_ref_addr)
2844 {
2845 /* We only support DW_FORM_ref_addr within the same file, so
2846 any relocations should be resolved already. */
2847 if (!die_ref)
2848 abort ();
2849
2850 info_ptr = unit->sec_info_ptr + die_ref;
2851 info_ptr_end = unit->end_ptr;
2852
2853 /* Now find the CU containing this pointer. */
2854 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2855 ;
2856 else
2857 {
2858 /* Check other CUs to see if they contain the abbrev. */
2859 struct comp_unit * u;
2860
2861 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2862 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2863 break;
2864
2865 if (u == NULL)
2866 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2867 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2868 break;
2869
2870 if (u)
2871 unit = u;
2872 /* else FIXME: What do we do now ? */
2873 }
2874 }
2875 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2876 {
2877 info_ptr = read_alt_indirect_ref (unit, die_ref);
2878 if (info_ptr == NULL)
2879 {
2880 _bfd_error_handler
2881 (_("Dwarf Error: Unable to read alt ref %llu."),
2882 (long long) die_ref);
2883 bfd_set_error (bfd_error_bad_value);
2884 return NULL;
2885 }
2886 info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
2887
2888 /* FIXME: Do we need to locate the correct CU, in a similar
2889 fashion to the code in the DW_FORM_ref_addr case above ? */
2890 }
2891 else
2892 {
2893 info_ptr = unit->info_ptr_unit + die_ref;
2894 info_ptr_end = unit->end_ptr;
2895 }
2896
2897 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
2898 FALSE, info_ptr_end);
2899 info_ptr += bytes_read;
2900
2901 if (abbrev_number)
2902 {
2903 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2904 if (! abbrev)
2905 {
2906 _bfd_error_handler
2907 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2908 bfd_set_error (bfd_error_bad_value);
2909 }
2910 else
2911 {
2912 for (i = 0; i < abbrev->num_attrs; ++i)
2913 {
2914 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2915 info_ptr, info_ptr_end);
2916 if (info_ptr == NULL)
2917 break;
2918 switch (attr.name)
2919 {
2920 case DW_AT_name:
2921 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2922 over DW_AT_name. */
2923 if (name == NULL && is_str_attr (attr.form))
2924 {
2925 name = attr.u.str;
2926 if (non_mangled (unit->lang))
2927 *is_linkage = TRUE;
2928 }
2929 break;
2930 case DW_AT_specification:
2931 name = find_abstract_instance_name (unit, &attr, is_linkage);
2932 break;
2933 case DW_AT_linkage_name:
2934 case DW_AT_MIPS_linkage_name:
2935 /* PR 16949: Corrupt debug info can place
2936 non-string forms into these attributes. */
2937 if (is_str_attr (attr.form))
2938 {
2939 name = attr.u.str;
2940 *is_linkage = TRUE;
2941 }
2942 break;
2943 default:
2944 break;
2945 }
2946 }
2947 }
2948 }
2949 return name;
2950 }
2951
2952 static bfd_boolean
2953 read_rangelist (struct comp_unit *unit, struct arange *arange,
2954 bfd_uint64_t offset)
2955 {
2956 bfd_byte *ranges_ptr;
2957 bfd_byte *ranges_end;
2958 bfd_vma base_address = unit->base_address;
2959
2960 if (! unit->stash->dwarf_ranges_buffer)
2961 {
2962 if (! read_debug_ranges (unit))
2963 return FALSE;
2964 }
2965
2966 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2967 if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
2968 return FALSE;
2969 ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
2970
2971 for (;;)
2972 {
2973 bfd_vma low_pc;
2974 bfd_vma high_pc;
2975
2976 /* PR 17512: file: 62cada7d. */
2977 if (ranges_ptr + 2 * unit->addr_size > ranges_end)
2978 return FALSE;
2979
2980 low_pc = read_address (unit, ranges_ptr, ranges_end);
2981 ranges_ptr += unit->addr_size;
2982 high_pc = read_address (unit, ranges_ptr, ranges_end);
2983 ranges_ptr += unit->addr_size;
2984
2985 if (low_pc == 0 && high_pc == 0)
2986 break;
2987 if (low_pc == -1UL && high_pc != -1UL)
2988 base_address = high_pc;
2989 else
2990 {
2991 if (!arange_add (unit, arange,
2992 base_address + low_pc, base_address + high_pc))
2993 return FALSE;
2994 }
2995 }
2996 return TRUE;
2997 }
2998
2999 /* DWARF2 Compilation unit functions. */
3000
3001 /* Scan over each die in a comp. unit looking for functions to add
3002 to the function table and variables to the variable table. */
3003
3004 static bfd_boolean
3005 scan_unit_for_symbols (struct comp_unit *unit)
3006 {
3007 bfd *abfd = unit->abfd;
3008 bfd_byte *info_ptr = unit->first_child_die_ptr;
3009 bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
3010 int nesting_level = 1;
3011 struct funcinfo **nested_funcs;
3012 int nested_funcs_size;
3013
3014 /* Maintain a stack of in-scope functions and inlined functions, which we
3015 can use to set the caller_func field. */
3016 nested_funcs_size = 32;
3017 nested_funcs = (struct funcinfo **)
3018 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
3019 if (nested_funcs == NULL)
3020 return FALSE;
3021 nested_funcs[nesting_level] = 0;
3022
3023 while (nesting_level)
3024 {
3025 unsigned int abbrev_number, bytes_read, i;
3026 struct abbrev_info *abbrev;
3027 struct attribute attr;
3028 struct funcinfo *func;
3029 struct varinfo *var;
3030 bfd_vma low_pc = 0;
3031 bfd_vma high_pc = 0;
3032 bfd_boolean high_pc_relative = FALSE;
3033
3034 /* PR 17512: file: 9f405d9d. */
3035 if (info_ptr >= info_ptr_end)
3036 goto fail;
3037
3038 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
3039 FALSE, info_ptr_end);
3040 info_ptr += bytes_read;
3041
3042 if (! abbrev_number)
3043 {
3044 nesting_level--;
3045 continue;
3046 }
3047
3048 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
3049 if (! abbrev)
3050 {
3051 static unsigned int previous_failed_abbrev = -1U;
3052
3053 /* Avoid multiple reports of the same missing abbrev. */
3054 if (abbrev_number != previous_failed_abbrev)
3055 {
3056 _bfd_error_handler
3057 (_("Dwarf Error: Could not find abbrev number %u."),
3058 abbrev_number);
3059 previous_failed_abbrev = abbrev_number;
3060 }
3061 bfd_set_error (bfd_error_bad_value);
3062 goto fail;
3063 }
3064
3065 var = NULL;
3066 if (abbrev->tag == DW_TAG_subprogram
3067 || abbrev->tag == DW_TAG_entry_point
3068 || abbrev->tag == DW_TAG_inlined_subroutine)
3069 {
3070 bfd_size_type amt = sizeof (struct funcinfo);
3071 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
3072 if (func == NULL)
3073 goto fail;
3074 func->tag = abbrev->tag;
3075 func->prev_func = unit->function_table;
3076 unit->function_table = func;
3077 unit->number_of_functions++;
3078 BFD_ASSERT (!unit->cached);
3079
3080 if (func->tag == DW_TAG_inlined_subroutine)
3081 for (i = nesting_level - 1; i >= 1; i--)
3082 if (nested_funcs[i])
3083 {
3084 func->caller_func = nested_funcs[i];
3085 break;
3086 }
3087 nested_funcs[nesting_level] = func;
3088 }
3089 else
3090 {
3091 func = NULL;
3092 if (abbrev->tag == DW_TAG_variable)
3093 {
3094 bfd_size_type amt = sizeof (struct varinfo);
3095 var = (struct varinfo *) bfd_zalloc (abfd, amt);
3096 if (var == NULL)
3097 goto fail;
3098 var->tag = abbrev->tag;
3099 var->stack = 1;
3100 var->prev_var = unit->variable_table;
3101 unit->variable_table = var;
3102 /* PR 18205: Missing debug information can cause this
3103 var to be attached to an already cached unit. */
3104 }
3105
3106 /* No inline function in scope at this nesting level. */
3107 nested_funcs[nesting_level] = 0;
3108 }
3109
3110 for (i = 0; i < abbrev->num_attrs; ++i)
3111 {
3112 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
3113 if (info_ptr == NULL)
3114 goto fail;
3115
3116 if (func)
3117 {
3118 switch (attr.name)
3119 {
3120 case DW_AT_call_file:
3121 func->caller_file = concat_filename (unit->line_table,
3122 attr.u.val);
3123 break;
3124
3125 case DW_AT_call_line:
3126 func->caller_line = attr.u.val;
3127 break;
3128
3129 case DW_AT_abstract_origin:
3130 case DW_AT_specification:
3131 func->name = find_abstract_instance_name (unit, &attr,
3132 &func->is_linkage);
3133 break;
3134
3135 case DW_AT_name:
3136 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3137 over DW_AT_name. */
3138 if (func->name == NULL && is_str_attr (attr.form))
3139 {
3140 func->name = attr.u.str;
3141 if (non_mangled (unit->lang))
3142 func->is_linkage = TRUE;
3143 }
3144 break;
3145
3146 case DW_AT_linkage_name:
3147 case DW_AT_MIPS_linkage_name:
3148 /* PR 16949: Corrupt debug info can place
3149 non-string forms into these attributes. */
3150 if (is_str_attr (attr.form))
3151 {
3152 func->name = attr.u.str;
3153 func->is_linkage = TRUE;
3154 }
3155 break;
3156
3157 case DW_AT_low_pc:
3158 low_pc = attr.u.val;
3159 break;
3160
3161 case DW_AT_high_pc:
3162 high_pc = attr.u.val;
3163 high_pc_relative = attr.form != DW_FORM_addr;
3164 break;
3165
3166 case DW_AT_ranges:
3167 if (!read_rangelist (unit, &func->arange, attr.u.val))
3168 goto fail;
3169 break;
3170
3171 case DW_AT_decl_file:
3172 func->file = concat_filename (unit->line_table,
3173 attr.u.val);
3174 break;
3175
3176 case DW_AT_decl_line:
3177 func->line = attr.u.val;
3178 break;
3179
3180 default:
3181 break;
3182 }
3183 }
3184 else if (var)
3185 {
3186 switch (attr.name)
3187 {
3188 case DW_AT_name:
3189 var->name = attr.u.str;
3190 break;
3191
3192 case DW_AT_decl_file:
3193 var->file = concat_filename (unit->line_table,
3194 attr.u.val);
3195 break;
3196
3197 case DW_AT_decl_line:
3198 var->line = attr.u.val;
3199 break;
3200
3201 case DW_AT_external:
3202 if (attr.u.val != 0)
3203 var->stack = 0;
3204 break;
3205
3206 case DW_AT_location:
3207 switch (attr.form)
3208 {
3209 case DW_FORM_block:
3210 case DW_FORM_block1:
3211 case DW_FORM_block2:
3212 case DW_FORM_block4:
3213 case DW_FORM_exprloc:
3214 if (attr.u.blk->data != NULL
3215 && *attr.u.blk->data == DW_OP_addr)
3216 {
3217 var->stack = 0;
3218
3219 /* Verify that DW_OP_addr is the only opcode in the
3220 location, in which case the block size will be 1
3221 plus the address size. */
3222 /* ??? For TLS variables, gcc can emit
3223 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3224 which we don't handle here yet. */
3225 if (attr.u.blk->size == unit->addr_size + 1U)
3226 var->addr = bfd_get (unit->addr_size * 8,
3227 unit->abfd,
3228 attr.u.blk->data + 1);
3229 }
3230 break;
3231
3232 default:
3233 break;
3234 }
3235 break;
3236
3237 default:
3238 break;
3239 }
3240 }
3241 }
3242
3243 if (high_pc_relative)
3244 high_pc += low_pc;
3245
3246 if (func && high_pc != 0)
3247 {
3248 if (!arange_add (unit, &func->arange, low_pc, high_pc))
3249 goto fail;
3250 }
3251
3252 if (abbrev->has_children)
3253 {
3254 nesting_level++;
3255
3256 if (nesting_level >= nested_funcs_size)
3257 {
3258 struct funcinfo **tmp;
3259
3260 nested_funcs_size *= 2;
3261 tmp = (struct funcinfo **)
3262 bfd_realloc (nested_funcs,
3263 nested_funcs_size * sizeof (struct funcinfo *));
3264 if (tmp == NULL)
3265 goto fail;
3266 nested_funcs = tmp;
3267 }
3268 nested_funcs[nesting_level] = 0;
3269 }
3270 }
3271
3272 free (nested_funcs);
3273 return TRUE;
3274
3275 fail:
3276 free (nested_funcs);
3277 return FALSE;
3278 }
3279
3280 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
3281 includes the compilation unit header that proceeds the DIE's, but
3282 does not include the length field that precedes each compilation
3283 unit header. END_PTR points one past the end of this comp unit.
3284 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3285
3286 This routine does not read the whole compilation unit; only enough
3287 to get to the line number information for the compilation unit. */
3288
3289 static struct comp_unit *
3290 parse_comp_unit (struct dwarf2_debug *stash,
3291 bfd_vma unit_length,
3292 bfd_byte *info_ptr_unit,
3293 unsigned int offset_size)
3294 {
3295 struct comp_unit* unit;
3296 unsigned int version;
3297 bfd_uint64_t abbrev_offset = 0;
3298 /* Initialize it just to avoid a GCC false warning. */
3299 unsigned int addr_size = -1;
3300 struct abbrev_info** abbrevs;
3301 unsigned int abbrev_number, bytes_read, i;
3302 struct abbrev_info *abbrev;
3303 struct attribute attr;
3304 bfd_byte *info_ptr = stash->info_ptr;
3305 bfd_byte *end_ptr = info_ptr + unit_length;
3306 bfd_size_type amt;
3307 bfd_vma low_pc = 0;
3308 bfd_vma high_pc = 0;
3309 bfd *abfd = stash->bfd_ptr;
3310 bfd_boolean high_pc_relative = FALSE;
3311 enum dwarf_unit_type unit_type;
3312
3313 version = read_2_bytes (abfd, info_ptr, end_ptr);
3314 info_ptr += 2;
3315 if (version < 2 || version > 5)
3316 {
3317 /* PR 19872: A version number of 0 probably means that there is padding
3318 at the end of the .debug_info section. Gold puts it there when
3319 performing an incremental link, for example. So do not generate
3320 an error, just return a NULL. */
3321 if (version)
3322 {
3323 _bfd_error_handler
3324 (_("Dwarf Error: found dwarf version '%u', this reader"
3325 " only handles version 2, 3, 4 and 5 information."), version);
3326 bfd_set_error (bfd_error_bad_value);
3327 }
3328 return NULL;
3329 }
3330
3331 if (version < 5)
3332 unit_type = DW_UT_compile;
3333 else
3334 {
3335 unit_type = read_1_byte (abfd, info_ptr, end_ptr);
3336 info_ptr += 1;
3337
3338 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
3339 info_ptr += 1;
3340 }
3341
3342 BFD_ASSERT (offset_size == 4 || offset_size == 8);
3343 if (offset_size == 4)
3344 abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
3345 else
3346 abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
3347 info_ptr += offset_size;
3348
3349 if (version < 5)
3350 {
3351 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
3352 info_ptr += 1;
3353 }
3354
3355 if (unit_type == DW_UT_type)
3356 {
3357 /* Skip type signature. */
3358 info_ptr += 8;
3359
3360 /* Skip type offset. */
3361 info_ptr += offset_size;
3362 }
3363
3364 if (addr_size > sizeof (bfd_vma))
3365 {
3366 _bfd_error_handler
3367 /* xgettext: c-format */
3368 (_("Dwarf Error: found address size '%u', this reader"
3369 " can not handle sizes greater than '%u'."),
3370 addr_size,
3371 (unsigned int) sizeof (bfd_vma));
3372 bfd_set_error (bfd_error_bad_value);
3373 return NULL;
3374 }
3375
3376 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
3377 {
3378 _bfd_error_handler
3379 ("Dwarf Error: found address size '%u', this reader"
3380 " can only handle address sizes '2', '4' and '8'.", addr_size);
3381 bfd_set_error (bfd_error_bad_value);
3382 return NULL;
3383 }
3384
3385 /* Read the abbrevs for this compilation unit into a table. */
3386 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
3387 if (! abbrevs)
3388 return NULL;
3389
3390 abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
3391 FALSE, end_ptr);
3392 info_ptr += bytes_read;
3393 if (! abbrev_number)
3394 {
3395 /* PR 19872: An abbrev number of 0 probably means that there is padding
3396 at the end of the .debug_abbrev section. Gold puts it there when
3397 performing an incremental link, for example. So do not generate
3398 an error, just return a NULL. */
3399 return NULL;
3400 }
3401
3402 abbrev = lookup_abbrev (abbrev_number, abbrevs);
3403 if (! abbrev)
3404 {
3405 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3406 abbrev_number);
3407 bfd_set_error (bfd_error_bad_value);
3408 return NULL;
3409 }
3410
3411 amt = sizeof (struct comp_unit);
3412 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
3413 if (unit == NULL)
3414 return NULL;
3415 unit->abfd = abfd;
3416 unit->version = version;
3417 unit->addr_size = addr_size;
3418 unit->offset_size = offset_size;
3419 unit->abbrevs = abbrevs;
3420 unit->end_ptr = end_ptr;
3421 unit->stash = stash;
3422 unit->info_ptr_unit = info_ptr_unit;
3423 unit->sec_info_ptr = stash->sec_info_ptr;
3424
3425 for (i = 0; i < abbrev->num_attrs; ++i)
3426 {
3427 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
3428 if (info_ptr == NULL)
3429 return NULL;
3430
3431 /* Store the data if it is of an attribute we want to keep in a
3432 partial symbol table. */
3433 switch (attr.name)
3434 {
3435 case DW_AT_stmt_list:
3436 unit->stmtlist = 1;
3437 unit->line_offset = attr.u.val;
3438 break;
3439
3440 case DW_AT_name:
3441 unit->name = attr.u.str;
3442 break;
3443
3444 case DW_AT_low_pc:
3445 low_pc = attr.u.val;
3446 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3447 this is the base address to use when reading location
3448 lists or range lists. */
3449 if (abbrev->tag == DW_TAG_compile_unit)
3450 unit->base_address = low_pc;
3451 break;
3452
3453 case DW_AT_high_pc:
3454 high_pc = attr.u.val;
3455 high_pc_relative = attr.form != DW_FORM_addr;
3456 break;
3457
3458 case DW_AT_ranges:
3459 if (!read_rangelist (unit, &unit->arange, attr.u.val))
3460 return NULL;
3461 break;
3462
3463 case DW_AT_comp_dir:
3464 {
3465 char *comp_dir = attr.u.str;
3466
3467 /* PR 17512: file: 1fe726be. */
3468 if (! is_str_attr (attr.form))
3469 {
3470 _bfd_error_handler
3471 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3472 comp_dir = NULL;
3473 }
3474
3475 if (comp_dir)
3476 {
3477 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3478 directory, get rid of it. */
3479 char *cp = strchr (comp_dir, ':');
3480
3481 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
3482 comp_dir = cp + 1;
3483 }
3484 unit->comp_dir = comp_dir;
3485 break;
3486 }
3487
3488 case DW_AT_language:
3489 unit->lang = attr.u.val;
3490 break;
3491
3492 default:
3493 break;
3494 }
3495 }
3496 if (high_pc_relative)
3497 high_pc += low_pc;
3498 if (high_pc != 0)
3499 {
3500 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
3501 return NULL;
3502 }
3503
3504 unit->first_child_die_ptr = info_ptr;
3505 return unit;
3506 }
3507
3508 /* Return TRUE if UNIT may contain the address given by ADDR. When
3509 there are functions written entirely with inline asm statements, the
3510 range info in the compilation unit header may not be correct. We
3511 need to consult the line info table to see if a compilation unit
3512 really contains the given address. */
3513
3514 static bfd_boolean
3515 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
3516 {
3517 struct arange *arange;
3518
3519 if (unit->error)
3520 return FALSE;
3521
3522 arange = &unit->arange;
3523 do
3524 {
3525 if (addr >= arange->low && addr < arange->high)
3526 return TRUE;
3527 arange = arange->next;
3528 }
3529 while (arange);
3530
3531 return FALSE;
3532 }
3533
3534 /* If UNIT contains ADDR, set the output parameters to the values for
3535 the line containing ADDR. The output parameters, FILENAME_PTR,
3536 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3537 to be filled in.
3538
3539 Returns the range of addresses covered by the entry that was used
3540 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3541
3542 static bfd_vma
3543 comp_unit_find_nearest_line (struct comp_unit *unit,
3544 bfd_vma addr,
3545 const char **filename_ptr,
3546 struct funcinfo **function_ptr,
3547 unsigned int *linenumber_ptr,
3548 unsigned int *discriminator_ptr,
3549 struct dwarf2_debug *stash)
3550 {
3551 bfd_boolean func_p;
3552
3553 if (unit->error)
3554 return FALSE;
3555
3556 if (! unit->line_table)
3557 {
3558 if (! unit->stmtlist)
3559 {
3560 unit->error = 1;
3561 return FALSE;
3562 }
3563
3564 unit->line_table = decode_line_info (unit, stash);
3565
3566 if (! unit->line_table)
3567 {
3568 unit->error = 1;
3569 return FALSE;
3570 }
3571
3572 if (unit->first_child_die_ptr < unit->end_ptr
3573 && ! scan_unit_for_symbols (unit))
3574 {
3575 unit->error = 1;
3576 return FALSE;
3577 }
3578 }
3579
3580 *function_ptr = NULL;
3581 func_p = lookup_address_in_function_table (unit, addr, function_ptr);
3582 if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
3583 stash->inliner_chain = *function_ptr;
3584
3585 return lookup_address_in_line_info_table (unit->line_table, addr,
3586 filename_ptr,
3587 linenumber_ptr,
3588 discriminator_ptr);
3589 }
3590
3591 /* Check to see if line info is already decoded in a comp_unit.
3592 If not, decode it. Returns TRUE if no errors were encountered;
3593 FALSE otherwise. */
3594
3595 static bfd_boolean
3596 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
3597 struct dwarf2_debug *stash)
3598 {
3599 if (unit->error)
3600 return FALSE;
3601
3602 if (! unit->line_table)
3603 {
3604 if (! unit->stmtlist)
3605 {
3606 unit->error = 1;
3607 return FALSE;
3608 }
3609
3610 unit->line_table = decode_line_info (unit, stash);
3611
3612 if (! unit->line_table)
3613 {
3614 unit->error = 1;
3615 return FALSE;
3616 }
3617
3618 if (unit->first_child_die_ptr < unit->end_ptr
3619 && ! scan_unit_for_symbols (unit))
3620 {
3621 unit->error = 1;
3622 return FALSE;
3623 }
3624 }
3625
3626 return TRUE;
3627 }
3628
3629 /* If UNIT contains SYM at ADDR, set the output parameters to the
3630 values for the line containing SYM. The output parameters,
3631 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3632 filled in.
3633
3634 Return TRUE if UNIT contains SYM, and no errors were encountered;
3635 FALSE otherwise. */
3636
3637 static bfd_boolean
3638 comp_unit_find_line (struct comp_unit *unit,
3639 asymbol *sym,
3640 bfd_vma addr,
3641 const char **filename_ptr,
3642 unsigned int *linenumber_ptr,
3643 struct dwarf2_debug *stash)
3644 {
3645 if (!comp_unit_maybe_decode_line_info (unit, stash))
3646 return FALSE;
3647
3648 if (sym->flags & BSF_FUNCTION)
3649 return lookup_symbol_in_function_table (unit, sym, addr,
3650 filename_ptr,
3651 linenumber_ptr);
3652
3653 return lookup_symbol_in_variable_table (unit, sym, addr,
3654 filename_ptr,
3655 linenumber_ptr);
3656 }
3657
3658 static struct funcinfo *
3659 reverse_funcinfo_list (struct funcinfo *head)
3660 {
3661 struct funcinfo *rhead;
3662 struct funcinfo *temp;
3663
3664 for (rhead = NULL; head; head = temp)
3665 {
3666 temp = head->prev_func;
3667 head->prev_func = rhead;
3668 rhead = head;
3669 }
3670 return rhead;
3671 }
3672
3673 static struct varinfo *
3674 reverse_varinfo_list (struct varinfo *head)
3675 {
3676 struct varinfo *rhead;
3677 struct varinfo *temp;
3678
3679 for (rhead = NULL; head; head = temp)
3680 {
3681 temp = head->prev_var;
3682 head->prev_var = rhead;
3683 rhead = head;
3684 }
3685 return rhead;
3686 }
3687
3688 /* Extract all interesting funcinfos and varinfos of a compilation
3689 unit into hash tables for faster lookup. Returns TRUE if no
3690 errors were enountered; FALSE otherwise. */
3691
3692 static bfd_boolean
3693 comp_unit_hash_info (struct dwarf2_debug *stash,
3694 struct comp_unit *unit,
3695 struct info_hash_table *funcinfo_hash_table,
3696 struct info_hash_table *varinfo_hash_table)
3697 {
3698 struct funcinfo* each_func;
3699 struct varinfo* each_var;
3700 bfd_boolean okay = TRUE;
3701
3702 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
3703
3704 if (!comp_unit_maybe_decode_line_info (unit, stash))
3705 return FALSE;
3706
3707 BFD_ASSERT (!unit->cached);
3708
3709 /* To preserve the original search order, we went to visit the function
3710 infos in the reversed order of the list. However, making the list
3711 bi-directional use quite a bit of extra memory. So we reverse
3712 the list first, traverse the list in the now reversed order and
3713 finally reverse the list again to get back the original order. */
3714 unit->function_table = reverse_funcinfo_list (unit->function_table);
3715 for (each_func = unit->function_table;
3716 each_func && okay;
3717 each_func = each_func->prev_func)
3718 {
3719 /* Skip nameless functions. */
3720 if (each_func->name)
3721 /* There is no need to copy name string into hash table as
3722 name string is either in the dwarf string buffer or
3723 info in the stash. */
3724 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
3725 (void*) each_func, FALSE);
3726 }
3727 unit->function_table = reverse_funcinfo_list (unit->function_table);
3728 if (!okay)
3729 return FALSE;
3730
3731 /* We do the same for variable infos. */
3732 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3733 for (each_var = unit->variable_table;
3734 each_var && okay;
3735 each_var = each_var->prev_var)
3736 {
3737 /* Skip stack vars and vars with no files or names. */
3738 if (each_var->stack == 0
3739 && each_var->file != NULL
3740 && each_var->name != NULL)
3741 /* There is no need to copy name string into hash table as
3742 name string is either in the dwarf string buffer or
3743 info in the stash. */
3744 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
3745 (void*) each_var, FALSE);
3746 }
3747
3748 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3749 unit->cached = TRUE;
3750 return okay;
3751 }
3752
3753 /* Locate a section in a BFD containing debugging info. The search starts
3754 from the section after AFTER_SEC, or from the first section in the BFD if
3755 AFTER_SEC is NULL. The search works by examining the names of the
3756 sections. There are three permissiable names. The first two are given
3757 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3758 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3759 This is a variation on the .debug_info section which has a checksum
3760 describing the contents appended onto the name. This allows the linker to
3761 identify and discard duplicate debugging sections for different
3762 compilation units. */
3763 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3764
3765 static asection *
3766 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
3767 asection *after_sec)
3768 {
3769 asection *msec;
3770 const char *look;
3771
3772 if (after_sec == NULL)
3773 {
3774 look = debug_sections[debug_info].uncompressed_name;
3775 msec = bfd_get_section_by_name (abfd, look);
3776 if (msec != NULL)
3777 return msec;
3778
3779 look = debug_sections[debug_info].compressed_name;
3780 if (look != NULL)
3781 {
3782 msec = bfd_get_section_by_name (abfd, look);
3783 if (msec != NULL)
3784 return msec;
3785 }
3786
3787 for (msec = abfd->sections; msec != NULL; msec = msec->next)
3788 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3789 return msec;
3790
3791 return NULL;
3792 }
3793
3794 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3795 {
3796 look = debug_sections[debug_info].uncompressed_name;
3797 if (strcmp (msec->name, look) == 0)
3798 return msec;
3799
3800 look = debug_sections[debug_info].compressed_name;
3801 if (look != NULL && strcmp (msec->name, look) == 0)
3802 return msec;
3803
3804 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3805 return msec;
3806 }
3807
3808 return NULL;
3809 }
3810
3811 /* Transfer VMAs from object file to separate debug file. */
3812
3813 static void
3814 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3815 {
3816 asection *s, *d;
3817
3818 for (s = orig_bfd->sections, d = debug_bfd->sections;
3819 s != NULL && d != NULL;
3820 s = s->next, d = d->next)
3821 {
3822 if ((d->flags & SEC_DEBUGGING) != 0)
3823 break;
3824 /* ??? Assumes 1-1 correspondence between sections in the
3825 two files. */
3826 if (strcmp (s->name, d->name) == 0)
3827 {
3828 d->output_section = s->output_section;
3829 d->output_offset = s->output_offset;
3830 d->vma = s->vma;
3831 }
3832 }
3833 }
3834
3835 /* Unset vmas for adjusted sections in STASH. */
3836
3837 static void
3838 unset_sections (struct dwarf2_debug *stash)
3839 {
3840 int i;
3841 struct adjusted_section *p;
3842
3843 i = stash->adjusted_section_count;
3844 p = stash->adjusted_sections;
3845 for (; i > 0; i--, p++)
3846 p->section->vma = 0;
3847 }
3848
3849 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3850 relocatable object file. VMAs are normally all zero in relocatable
3851 object files, so if we want to distinguish locations in sections by
3852 address we need to set VMAs so the sections do not overlap. We
3853 also set VMA on .debug_info so that when we have multiple
3854 .debug_info sections (or the linkonce variant) they also do not
3855 overlap. The multiple .debug_info sections make up a single
3856 logical section. ??? We should probably do the same for other
3857 debug sections. */
3858
3859 static bfd_boolean
3860 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3861 {
3862 bfd *abfd;
3863 struct adjusted_section *p;
3864 int i;
3865 const char *debug_info_name;
3866
3867 if (stash->adjusted_section_count != 0)
3868 {
3869 i = stash->adjusted_section_count;
3870 p = stash->adjusted_sections;
3871 for (; i > 0; i--, p++)
3872 p->section->vma = p->adj_vma;
3873 return TRUE;
3874 }
3875
3876 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3877 i = 0;
3878 abfd = orig_bfd;
3879 while (1)
3880 {
3881 asection *sect;
3882
3883 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3884 {
3885 int is_debug_info;
3886
3887 if ((sect->output_section != NULL
3888 && sect->output_section != sect
3889 && (sect->flags & SEC_DEBUGGING) == 0)
3890 || sect->vma != 0)
3891 continue;
3892
3893 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3894 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3895
3896 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3897 && !is_debug_info)
3898 continue;
3899
3900 i++;
3901 }
3902 if (abfd == stash->bfd_ptr)
3903 break;
3904 abfd = stash->bfd_ptr;
3905 }
3906
3907 if (i <= 1)
3908 stash->adjusted_section_count = -1;
3909 else
3910 {
3911 bfd_vma last_vma = 0, last_dwarf = 0;
3912 bfd_size_type amt = i * sizeof (struct adjusted_section);
3913
3914 p = (struct adjusted_section *) bfd_malloc (amt);
3915 if (p == NULL)
3916 return FALSE;
3917
3918 stash->adjusted_sections = p;
3919 stash->adjusted_section_count = i;
3920
3921 abfd = orig_bfd;
3922 while (1)
3923 {
3924 asection *sect;
3925
3926 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3927 {
3928 bfd_size_type sz;
3929 int is_debug_info;
3930
3931 if ((sect->output_section != NULL
3932 && sect->output_section != sect
3933 && (sect->flags & SEC_DEBUGGING) == 0)
3934 || sect->vma != 0)
3935 continue;
3936
3937 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3938 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3939
3940 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3941 && !is_debug_info)
3942 continue;
3943
3944 sz = sect->rawsize ? sect->rawsize : sect->size;
3945
3946 if (is_debug_info)
3947 {
3948 BFD_ASSERT (sect->alignment_power == 0);
3949 sect->vma = last_dwarf;
3950 last_dwarf += sz;
3951 }
3952 else
3953 {
3954 /* Align the new address to the current section
3955 alignment. */
3956 last_vma = ((last_vma
3957 + ~(-((bfd_vma) 1 << sect->alignment_power)))
3958 & (-((bfd_vma) 1 << sect->alignment_power)));
3959 sect->vma = last_vma;
3960 last_vma += sz;
3961 }
3962
3963 p->section = sect;
3964 p->adj_vma = sect->vma;
3965 p++;
3966 }
3967 if (abfd == stash->bfd_ptr)
3968 break;
3969 abfd = stash->bfd_ptr;
3970 }
3971 }
3972
3973 if (orig_bfd != stash->bfd_ptr)
3974 set_debug_vma (orig_bfd, stash->bfd_ptr);
3975
3976 return TRUE;
3977 }
3978
3979 /* Look up a funcinfo by name using the given info hash table. If found,
3980 also update the locations pointed to by filename_ptr and linenumber_ptr.
3981
3982 This function returns TRUE if a funcinfo that matches the given symbol
3983 and address is found with any error; otherwise it returns FALSE. */
3984
3985 static bfd_boolean
3986 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3987 asymbol *sym,
3988 bfd_vma addr,
3989 const char **filename_ptr,
3990 unsigned int *linenumber_ptr)
3991 {
3992 struct funcinfo* each_func;
3993 struct funcinfo* best_fit = NULL;
3994 bfd_vma best_fit_len = 0;
3995 struct info_list_node *node;
3996 struct arange *arange;
3997 const char *name = bfd_asymbol_name (sym);
3998 asection *sec = bfd_get_section (sym);
3999
4000 for (node = lookup_info_hash_table (hash_table, name);
4001 node;
4002 node = node->next)
4003 {
4004 each_func = (struct funcinfo *) node->info;
4005 for (arange = &each_func->arange;
4006 arange;
4007 arange = arange->next)
4008 {
4009 if ((!each_func->sec || each_func->sec == sec)
4010 && addr >= arange->low
4011 && addr < arange->high
4012 && (!best_fit
4013 || arange->high - arange->low < best_fit_len))
4014 {
4015 best_fit = each_func;
4016 best_fit_len = arange->high - arange->low;
4017 }
4018 }
4019 }
4020
4021 if (best_fit)
4022 {
4023 best_fit->sec = sec;
4024 *filename_ptr = best_fit->file;
4025 *linenumber_ptr = best_fit->line;
4026 return TRUE;
4027 }
4028
4029 return FALSE;
4030 }
4031
4032 /* Look up a varinfo by name using the given info hash table. If found,
4033 also update the locations pointed to by filename_ptr and linenumber_ptr.
4034
4035 This function returns TRUE if a varinfo that matches the given symbol
4036 and address is found with any error; otherwise it returns FALSE. */
4037
4038 static bfd_boolean
4039 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
4040 asymbol *sym,
4041 bfd_vma addr,
4042 const char **filename_ptr,
4043 unsigned int *linenumber_ptr)
4044 {
4045 const char *name = bfd_asymbol_name (sym);
4046 asection *sec = bfd_get_section (sym);
4047 struct varinfo* each;
4048 struct info_list_node *node;
4049
4050 for (node = lookup_info_hash_table (hash_table, name);
4051 node;
4052 node = node->next)
4053 {
4054 each = (struct varinfo *) node->info;
4055 if (each->addr == addr
4056 && (!each->sec || each->sec == sec))
4057 {
4058 each->sec = sec;
4059 *filename_ptr = each->file;
4060 *linenumber_ptr = each->line;
4061 return TRUE;
4062 }
4063 }
4064
4065 return FALSE;
4066 }
4067
4068 /* Update the funcinfo and varinfo info hash tables if they are
4069 not up to date. Returns TRUE if there is no error; otherwise
4070 returns FALSE and disable the info hash tables. */
4071
4072 static bfd_boolean
4073 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
4074 {
4075 struct comp_unit *each;
4076
4077 /* Exit if hash tables are up-to-date. */
4078 if (stash->all_comp_units == stash->hash_units_head)
4079 return TRUE;
4080
4081 if (stash->hash_units_head)
4082 each = stash->hash_units_head->prev_unit;
4083 else
4084 each = stash->last_comp_unit;
4085
4086 while (each)
4087 {
4088 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
4089 stash->varinfo_hash_table))
4090 {
4091 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
4092 return FALSE;
4093 }
4094 each = each->prev_unit;
4095 }
4096
4097 stash->hash_units_head = stash->all_comp_units;
4098 return TRUE;
4099 }
4100
4101 /* Check consistency of info hash tables. This is for debugging only. */
4102
4103 static void ATTRIBUTE_UNUSED
4104 stash_verify_info_hash_table (struct dwarf2_debug *stash)
4105 {
4106 struct comp_unit *each_unit;
4107 struct funcinfo *each_func;
4108 struct varinfo *each_var;
4109 struct info_list_node *node;
4110 bfd_boolean found;
4111
4112 for (each_unit = stash->all_comp_units;
4113 each_unit;
4114 each_unit = each_unit->next_unit)
4115 {
4116 for (each_func = each_unit->function_table;
4117 each_func;
4118 each_func = each_func->prev_func)
4119 {
4120 if (!each_func->name)
4121 continue;
4122 node = lookup_info_hash_table (stash->funcinfo_hash_table,
4123 each_func->name);
4124 BFD_ASSERT (node);
4125 found = FALSE;
4126 while (node && !found)
4127 {
4128 found = node->info == each_func;
4129 node = node->next;
4130 }
4131 BFD_ASSERT (found);
4132 }
4133
4134 for (each_var = each_unit->variable_table;
4135 each_var;
4136 each_var = each_var->prev_var)
4137 {
4138 if (!each_var->name || !each_var->file || each_var->stack)
4139 continue;
4140 node = lookup_info_hash_table (stash->varinfo_hash_table,
4141 each_var->name);
4142 BFD_ASSERT (node);
4143 found = FALSE;
4144 while (node && !found)
4145 {
4146 found = node->info == each_var;
4147 node = node->next;
4148 }
4149 BFD_ASSERT (found);
4150 }
4151 }
4152 }
4153
4154 /* Check to see if we want to enable the info hash tables, which consume
4155 quite a bit of memory. Currently we only check the number times
4156 bfd_dwarf2_find_line is called. In the future, we may also want to
4157 take the number of symbols into account. */
4158
4159 static void
4160 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
4161 {
4162 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
4163
4164 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
4165 return;
4166
4167 /* FIXME: Maybe we should check the reduce_memory_overheads
4168 and optimize fields in the bfd_link_info structure ? */
4169
4170 /* Create hash tables. */
4171 stash->funcinfo_hash_table = create_info_hash_table (abfd);
4172 stash->varinfo_hash_table = create_info_hash_table (abfd);
4173 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
4174 {
4175 /* Turn off info hashes if any allocation above fails. */
4176 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
4177 return;
4178 }
4179 /* We need a forced update so that the info hash tables will
4180 be created even though there is no compilation unit. That
4181 happens if STASH_INFO_HASH_TRIGGER is 0. */
4182 stash_maybe_update_info_hash_tables (stash);
4183 stash->info_hash_status = STASH_INFO_HASH_ON;
4184 }
4185
4186 /* Find the file and line associated with a symbol and address using the
4187 info hash tables of a stash. If there is a match, the function returns
4188 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4189 otherwise it returns FALSE. */
4190
4191 static bfd_boolean
4192 stash_find_line_fast (struct dwarf2_debug *stash,
4193 asymbol *sym,
4194 bfd_vma addr,
4195 const char **filename_ptr,
4196 unsigned int *linenumber_ptr)
4197 {
4198 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
4199
4200 if (sym->flags & BSF_FUNCTION)
4201 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
4202 filename_ptr, linenumber_ptr);
4203 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
4204 filename_ptr, linenumber_ptr);
4205 }
4206
4207 /* Save current section VMAs. */
4208
4209 static bfd_boolean
4210 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
4211 {
4212 asection *s;
4213 unsigned int i;
4214
4215 if (abfd->section_count == 0)
4216 return TRUE;
4217 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
4218 if (stash->sec_vma == NULL)
4219 return FALSE;
4220 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
4221 {
4222 if (s->output_section != NULL)
4223 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
4224 else
4225 stash->sec_vma[i] = s->vma;
4226 }
4227 return TRUE;
4228 }
4229
4230 /* Compare current section VMAs against those at the time the stash
4231 was created. If find_nearest_line is used in linker warnings or
4232 errors early in the link process, the debug info stash will be
4233 invalid for later calls. This is because we relocate debug info
4234 sections, so the stashed section contents depend on symbol values,
4235 which in turn depend on section VMAs. */
4236
4237 static bfd_boolean
4238 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
4239 {
4240 asection *s;
4241 unsigned int i;
4242
4243 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
4244 {
4245 bfd_vma vma;
4246
4247 if (s->output_section != NULL)
4248 vma = s->output_section->vma + s->output_offset;
4249 else
4250 vma = s->vma;
4251 if (vma != stash->sec_vma[i])
4252 return FALSE;
4253 }
4254 return TRUE;
4255 }
4256
4257 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4258 If DEBUG_BFD is not specified, we read debug information from ABFD
4259 or its gnu_debuglink. The results will be stored in PINFO.
4260 The function returns TRUE iff debug information is ready. */
4261
4262 bfd_boolean
4263 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
4264 const struct dwarf_debug_section *debug_sections,
4265 asymbol **symbols,
4266 void **pinfo,
4267 bfd_boolean do_place)
4268 {
4269 bfd_size_type amt = sizeof (struct dwarf2_debug);
4270 bfd_size_type total_size;
4271 asection *msec;
4272 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4273
4274 if (stash != NULL)
4275 {
4276 if (stash->orig_bfd == abfd
4277 && section_vma_same (abfd, stash))
4278 {
4279 /* Check that we did previously find some debug information
4280 before attempting to make use of it. */
4281 if (stash->bfd_ptr != NULL)
4282 {
4283 if (do_place && !place_sections (abfd, stash))
4284 return FALSE;
4285 return TRUE;
4286 }
4287
4288 return FALSE;
4289 }
4290 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
4291 memset (stash, 0, amt);
4292 }
4293 else
4294 {
4295 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
4296 if (! stash)
4297 return FALSE;
4298 }
4299 stash->orig_bfd = abfd;
4300 stash->debug_sections = debug_sections;
4301 stash->syms = symbols;
4302 if (!save_section_vma (abfd, stash))
4303 return FALSE;
4304
4305 *pinfo = stash;
4306
4307 if (debug_bfd == NULL)
4308 debug_bfd = abfd;
4309
4310 msec = find_debug_info (debug_bfd, debug_sections, NULL);
4311 if (msec == NULL && abfd == debug_bfd)
4312 {
4313 char * debug_filename;
4314
4315 debug_filename = bfd_follow_build_id_debuglink (abfd, DEBUGDIR);
4316 if (debug_filename == NULL)
4317 debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
4318
4319 if (debug_filename == NULL)
4320 /* No dwarf2 info, and no gnu_debuglink to follow.
4321 Note that at this point the stash has been allocated, but
4322 contains zeros. This lets future calls to this function
4323 fail more quickly. */
4324 return FALSE;
4325
4326 /* Set BFD_DECOMPRESS to decompress debug sections. */
4327 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
4328 || !(debug_bfd->flags |= BFD_DECOMPRESS,
4329 bfd_check_format (debug_bfd, bfd_object))
4330 || (msec = find_debug_info (debug_bfd,
4331 debug_sections, NULL)) == NULL
4332 || !bfd_generic_link_read_symbols (debug_bfd))
4333 {
4334 if (debug_bfd)
4335 bfd_close (debug_bfd);
4336 /* FIXME: Should we report our failure to follow the debuglink ? */
4337 free (debug_filename);
4338 return FALSE;
4339 }
4340
4341 symbols = bfd_get_outsymbols (debug_bfd);
4342 stash->syms = symbols;
4343 stash->close_on_cleanup = TRUE;
4344 }
4345 stash->bfd_ptr = debug_bfd;
4346
4347 if (do_place
4348 && !place_sections (abfd, stash))
4349 return FALSE;
4350
4351 /* There can be more than one DWARF2 info section in a BFD these
4352 days. First handle the easy case when there's only one. If
4353 there's more than one, try case two: none of the sections is
4354 compressed. In that case, read them all in and produce one
4355 large stash. We do this in two passes - in the first pass we
4356 just accumulate the section sizes, and in the second pass we
4357 read in the section's contents. (The allows us to avoid
4358 reallocing the data as we add sections to the stash.) If
4359 some or all sections are compressed, then do things the slow
4360 way, with a bunch of reallocs. */
4361
4362 if (! find_debug_info (debug_bfd, debug_sections, msec))
4363 {
4364 /* Case 1: only one info section. */
4365 total_size = msec->size;
4366 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
4367 symbols, 0,
4368 &stash->info_ptr_memory, &total_size))
4369 return FALSE;
4370 }
4371 else
4372 {
4373 /* Case 2: multiple sections. */
4374 for (total_size = 0;
4375 msec;
4376 msec = find_debug_info (debug_bfd, debug_sections, msec))
4377 total_size += msec->size;
4378
4379 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
4380 if (stash->info_ptr_memory == NULL)
4381 return FALSE;
4382
4383 total_size = 0;
4384 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
4385 msec;
4386 msec = find_debug_info (debug_bfd, debug_sections, msec))
4387 {
4388 bfd_size_type size;
4389
4390 size = msec->size;
4391 if (size == 0)
4392 continue;
4393
4394 if (!(bfd_simple_get_relocated_section_contents
4395 (debug_bfd, msec, stash->info_ptr_memory + total_size,
4396 symbols)))
4397 return FALSE;
4398
4399 total_size += size;
4400 }
4401 }
4402
4403 stash->info_ptr = stash->info_ptr_memory;
4404 stash->info_ptr_end = stash->info_ptr + total_size;
4405 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
4406 stash->sec_info_ptr = stash->info_ptr;
4407 return TRUE;
4408 }
4409
4410 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4411 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4412 symbol in SYMBOLS and return the difference between the low_pc and
4413 the symbol's address. Returns 0 if no suitable symbol could be found. */
4414
4415 bfd_signed_vma
4416 _bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
4417 {
4418 struct dwarf2_debug *stash;
4419 struct comp_unit * unit;
4420
4421 stash = (struct dwarf2_debug *) *pinfo;
4422
4423 if (stash == NULL)
4424 return 0;
4425
4426 for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
4427 {
4428 struct funcinfo * func;
4429
4430 if (unit->function_table == NULL)
4431 {
4432 if (unit->line_table == NULL)
4433 unit->line_table = decode_line_info (unit, stash);
4434 if (unit->line_table != NULL)
4435 scan_unit_for_symbols (unit);
4436 }
4437
4438 for (func = unit->function_table; func != NULL; func = func->prev_func)
4439 if (func->name && func->arange.low)
4440 {
4441 asymbol ** psym;
4442
4443 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4444
4445 for (psym = symbols; * psym != NULL; psym++)
4446 {
4447 asymbol * sym = * psym;
4448
4449 if (sym->flags & BSF_FUNCTION
4450 && sym->section != NULL
4451 && strcmp (sym->name, func->name) == 0)
4452 return ((bfd_signed_vma) func->arange.low) -
4453 ((bfd_signed_vma) (sym->value + sym->section->vma));
4454 }
4455 }
4456 }
4457
4458 return 0;
4459 }
4460
4461 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4462 then find the nearest source code location corresponding to
4463 the address SECTION + OFFSET.
4464 Returns TRUE if the line is found without error and fills in
4465 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4466 NULL the FUNCTIONNAME_PTR is also filled in.
4467 SYMBOLS contains the symbol table for ABFD.
4468 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4469 ADDR_SIZE is the number of bytes in the initial .debug_info length
4470 field and in the abbreviation offset, or zero to indicate that the
4471 default value should be used. */
4472
4473 bfd_boolean
4474 _bfd_dwarf2_find_nearest_line (bfd *abfd,
4475 asymbol **symbols,
4476 asymbol *symbol,
4477 asection *section,
4478 bfd_vma offset,
4479 const char **filename_ptr,
4480 const char **functionname_ptr,
4481 unsigned int *linenumber_ptr,
4482 unsigned int *discriminator_ptr,
4483 const struct dwarf_debug_section *debug_sections,
4484 unsigned int addr_size,
4485 void **pinfo)
4486 {
4487 /* Read each compilation unit from the section .debug_info, and check
4488 to see if it contains the address we are searching for. If yes,
4489 lookup the address, and return the line number info. If no, go
4490 on to the next compilation unit.
4491
4492 We keep a list of all the previously read compilation units, and
4493 a pointer to the next un-read compilation unit. Check the
4494 previously read units before reading more. */
4495 struct dwarf2_debug *stash;
4496 /* What address are we looking for? */
4497 bfd_vma addr;
4498 struct comp_unit* each;
4499 struct funcinfo *function = NULL;
4500 bfd_boolean found = FALSE;
4501 bfd_boolean do_line;
4502
4503 *filename_ptr = NULL;
4504 if (functionname_ptr != NULL)
4505 *functionname_ptr = NULL;
4506 *linenumber_ptr = 0;
4507 if (discriminator_ptr)
4508 *discriminator_ptr = 0;
4509
4510 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
4511 symbols, pinfo,
4512 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
4513 return FALSE;
4514
4515 stash = (struct dwarf2_debug *) *pinfo;
4516
4517 do_line = symbol != NULL;
4518 if (do_line)
4519 {
4520 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
4521 section = bfd_get_section (symbol);
4522 addr = symbol->value;
4523 }
4524 else
4525 {
4526 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
4527 addr = offset;
4528
4529 /* If we have no SYMBOL but the section we're looking at is not a
4530 code section, then take a look through the list of symbols to see
4531 if we have a symbol at the address we're looking for. If we do
4532 then use this to look up line information. This will allow us to
4533 give file and line results for data symbols. We exclude code
4534 symbols here, if we look up a function symbol and then look up the
4535 line information we'll actually return the line number for the
4536 opening '{' rather than the function definition line. This is
4537 because looking up by symbol uses the line table, in which the
4538 first line for a function is usually the opening '{', while
4539 looking up the function by section + offset uses the
4540 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4541 which will be the line of the function name. */
4542 if (symbols != NULL && (section->flags & SEC_CODE) == 0)
4543 {
4544 asymbol **tmp;
4545
4546 for (tmp = symbols; (*tmp) != NULL; ++tmp)
4547 if ((*tmp)->the_bfd == abfd
4548 && (*tmp)->section == section
4549 && (*tmp)->value == offset
4550 && ((*tmp)->flags & BSF_SECTION_SYM) == 0)
4551 {
4552 symbol = *tmp;
4553 do_line = TRUE;
4554 /* For local symbols, keep going in the hope we find a
4555 global. */
4556 if ((symbol->flags & BSF_GLOBAL) != 0)
4557 break;
4558 }
4559 }
4560 }
4561
4562 if (section->output_section)
4563 addr += section->output_section->vma + section->output_offset;
4564 else
4565 addr += section->vma;
4566
4567 /* A null info_ptr indicates that there is no dwarf2 info
4568 (or that an error occured while setting up the stash). */
4569 if (! stash->info_ptr)
4570 return FALSE;
4571
4572 stash->inliner_chain = NULL;
4573
4574 /* Check the previously read comp. units first. */
4575 if (do_line)
4576 {
4577 /* The info hash tables use quite a bit of memory. We may not want to
4578 always use them. We use some heuristics to decide if and when to
4579 turn it on. */
4580 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
4581 stash_maybe_enable_info_hash_tables (abfd, stash);
4582
4583 /* Keep info hash table up to date if they are available. Note that we
4584 may disable the hash tables if there is any error duing update. */
4585 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4586 stash_maybe_update_info_hash_tables (stash);
4587
4588 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4589 {
4590 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
4591 linenumber_ptr);
4592 if (found)
4593 goto done;
4594 }
4595 else
4596 {
4597 /* Check the previously read comp. units first. */
4598 for (each = stash->all_comp_units; each; each = each->next_unit)
4599 if ((symbol->flags & BSF_FUNCTION) == 0
4600 || each->arange.high == 0
4601 || comp_unit_contains_address (each, addr))
4602 {
4603 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
4604 linenumber_ptr, stash);
4605 if (found)
4606 goto done;
4607 }
4608 }
4609 }
4610 else
4611 {
4612 bfd_vma min_range = (bfd_vma) -1;
4613 const char * local_filename = NULL;
4614 struct funcinfo *local_function = NULL;
4615 unsigned int local_linenumber = 0;
4616 unsigned int local_discriminator = 0;
4617
4618 for (each = stash->all_comp_units; each; each = each->next_unit)
4619 {
4620 bfd_vma range = (bfd_vma) -1;
4621
4622 found = ((each->arange.high == 0
4623 || comp_unit_contains_address (each, addr))
4624 && (range = comp_unit_find_nearest_line (each, addr,
4625 & local_filename,
4626 & local_function,
4627 & local_linenumber,
4628 & local_discriminator,
4629 stash)) != 0);
4630 if (found)
4631 {
4632 /* PRs 15935 15994: Bogus debug information may have provided us
4633 with an erroneous match. We attempt to counter this by
4634 selecting the match that has the smallest address range
4635 associated with it. (We are assuming that corrupt debug info
4636 will tend to result in extra large address ranges rather than
4637 extra small ranges).
4638
4639 This does mean that we scan through all of the CUs associated
4640 with the bfd each time this function is called. But this does
4641 have the benefit of producing consistent results every time the
4642 function is called. */
4643 if (range <= min_range)
4644 {
4645 if (filename_ptr && local_filename)
4646 * filename_ptr = local_filename;
4647 if (local_function)
4648 function = local_function;
4649 if (discriminator_ptr && local_discriminator)
4650 * discriminator_ptr = local_discriminator;
4651 if (local_linenumber)
4652 * linenumber_ptr = local_linenumber;
4653 min_range = range;
4654 }
4655 }
4656 }
4657
4658 if (* linenumber_ptr)
4659 {
4660 found = TRUE;
4661 goto done;
4662 }
4663 }
4664
4665 /* The DWARF2 spec says that the initial length field, and the
4666 offset of the abbreviation table, should both be 4-byte values.
4667 However, some compilers do things differently. */
4668 if (addr_size == 0)
4669 addr_size = 4;
4670 BFD_ASSERT (addr_size == 4 || addr_size == 8);
4671
4672 /* Read each remaining comp. units checking each as they are read. */
4673 while (stash->info_ptr < stash->info_ptr_end)
4674 {
4675 bfd_vma length;
4676 unsigned int offset_size = addr_size;
4677 bfd_byte *info_ptr_unit = stash->info_ptr;
4678
4679 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
4680 /* A 0xffffff length is the DWARF3 way of indicating
4681 we use 64-bit offsets, instead of 32-bit offsets. */
4682 if (length == 0xffffffff)
4683 {
4684 offset_size = 8;
4685 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4686 stash->info_ptr += 12;
4687 }
4688 /* A zero length is the IRIX way of indicating 64-bit offsets,
4689 mostly because the 64-bit length will generally fit in 32
4690 bits, and the endianness helps. */
4691 else if (length == 0)
4692 {
4693 offset_size = 8;
4694 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4695 stash->info_ptr += 8;
4696 }
4697 /* In the absence of the hints above, we assume 32-bit DWARF2
4698 offsets even for targets with 64-bit addresses, because:
4699 a) most of the time these targets will not have generated
4700 more than 2Gb of debug info and so will not need 64-bit
4701 offsets,
4702 and
4703 b) if they do use 64-bit offsets but they are not using
4704 the size hints that are tested for above then they are
4705 not conforming to the DWARF3 standard anyway. */
4706 else if (addr_size == 8)
4707 {
4708 offset_size = 4;
4709 stash->info_ptr += 4;
4710 }
4711 else
4712 stash->info_ptr += 4;
4713
4714 if (length > 0)
4715 {
4716 bfd_byte * new_ptr;
4717
4718 /* PR 21151 */
4719 if (stash->info_ptr + length > stash->info_ptr_end)
4720 return FALSE;
4721
4722 each = parse_comp_unit (stash, length, info_ptr_unit,
4723 offset_size);
4724 if (!each)
4725 /* The dwarf information is damaged, don't trust it any
4726 more. */
4727 break;
4728
4729 new_ptr = stash->info_ptr + length;
4730 /* PR 17512: file: 1500698c. */
4731 if (new_ptr < stash->info_ptr)
4732 {
4733 /* A corrupt length value - do not trust the info any more. */
4734 found = FALSE;
4735 break;
4736 }
4737 else
4738 stash->info_ptr = new_ptr;
4739
4740 if (stash->all_comp_units)
4741 stash->all_comp_units->prev_unit = each;
4742 else
4743 stash->last_comp_unit = each;
4744
4745 each->next_unit = stash->all_comp_units;
4746 stash->all_comp_units = each;
4747
4748 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4749 compilation units. If we don't have them (i.e.,
4750 unit->high == 0), we need to consult the line info table
4751 to see if a compilation unit contains the given
4752 address. */
4753 if (do_line)
4754 found = (((symbol->flags & BSF_FUNCTION) == 0
4755 || each->arange.high == 0
4756 || comp_unit_contains_address (each, addr))
4757 && comp_unit_find_line (each, symbol, addr,
4758 filename_ptr,
4759 linenumber_ptr,
4760 stash));
4761 else
4762 found = ((each->arange.high == 0
4763 || comp_unit_contains_address (each, addr))
4764 && comp_unit_find_nearest_line (each, addr,
4765 filename_ptr,
4766 &function,
4767 linenumber_ptr,
4768 discriminator_ptr,
4769 stash) != 0);
4770
4771 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
4772 == stash->sec->size)
4773 {
4774 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
4775 stash->sec);
4776 stash->sec_info_ptr = stash->info_ptr;
4777 }
4778
4779 if (found)
4780 goto done;
4781 }
4782 }
4783
4784 done:
4785 if (function)
4786 {
4787 if (!function->is_linkage)
4788 {
4789 asymbol *fun;
4790 bfd_vma sec_vma;
4791
4792 fun = _bfd_elf_find_function (abfd, symbols, section, offset,
4793 *filename_ptr ? NULL : filename_ptr,
4794 functionname_ptr);
4795 sec_vma = section->vma;
4796 if (section->output_section != NULL)
4797 sec_vma = section->output_section->vma + section->output_offset;
4798 if (fun != NULL
4799 && fun->value + sec_vma == function->arange.low)
4800 function->name = *functionname_ptr;
4801 /* Even if we didn't find a linkage name, say that we have
4802 to stop a repeated search of symbols. */
4803 function->is_linkage = TRUE;
4804 }
4805 *functionname_ptr = function->name;
4806 }
4807 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
4808 unset_sections (stash);
4809
4810 return found;
4811 }
4812
4813 bfd_boolean
4814 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
4815 const char **filename_ptr,
4816 const char **functionname_ptr,
4817 unsigned int *linenumber_ptr,
4818 void **pinfo)
4819 {
4820 struct dwarf2_debug *stash;
4821
4822 stash = (struct dwarf2_debug *) *pinfo;
4823 if (stash)
4824 {
4825 struct funcinfo *func = stash->inliner_chain;
4826
4827 if (func && func->caller_func)
4828 {
4829 *filename_ptr = func->caller_file;
4830 *functionname_ptr = func->caller_func->name;
4831 *linenumber_ptr = func->caller_line;
4832 stash->inliner_chain = func->caller_func;
4833 return TRUE;
4834 }
4835 }
4836
4837 return FALSE;
4838 }
4839
4840 void
4841 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
4842 {
4843 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4844 struct comp_unit *each;
4845
4846 if (abfd == NULL || stash == NULL)
4847 return;
4848
4849 for (each = stash->all_comp_units; each; each = each->next_unit)
4850 {
4851 struct abbrev_info **abbrevs = each->abbrevs;
4852 struct funcinfo *function_table = each->function_table;
4853 struct varinfo *variable_table = each->variable_table;
4854 size_t i;
4855
4856 for (i = 0; i < ABBREV_HASH_SIZE; i++)
4857 {
4858 struct abbrev_info *abbrev = abbrevs[i];
4859
4860 while (abbrev)
4861 {
4862 free (abbrev->attrs);
4863 abbrev = abbrev->next;
4864 }
4865 }
4866
4867 if (each->line_table)
4868 {
4869 free (each->line_table->dirs);
4870 free (each->line_table->files);
4871 }
4872
4873 while (function_table)
4874 {
4875 if (function_table->file)
4876 {
4877 free (function_table->file);
4878 function_table->file = NULL;
4879 }
4880
4881 if (function_table->caller_file)
4882 {
4883 free (function_table->caller_file);
4884 function_table->caller_file = NULL;
4885 }
4886 function_table = function_table->prev_func;
4887 }
4888
4889 if (each->lookup_funcinfo_table)
4890 {
4891 free (each->lookup_funcinfo_table);
4892 each->lookup_funcinfo_table = NULL;
4893 }
4894
4895 while (variable_table)
4896 {
4897 if (variable_table->file)
4898 {
4899 free (variable_table->file);
4900 variable_table->file = NULL;
4901 }
4902
4903 variable_table = variable_table->prev_var;
4904 }
4905 }
4906
4907 if (stash->dwarf_abbrev_buffer)
4908 free (stash->dwarf_abbrev_buffer);
4909 if (stash->dwarf_line_buffer)
4910 free (stash->dwarf_line_buffer);
4911 if (stash->dwarf_str_buffer)
4912 free (stash->dwarf_str_buffer);
4913 if (stash->dwarf_line_str_buffer)
4914 free (stash->dwarf_line_str_buffer);
4915 if (stash->dwarf_ranges_buffer)
4916 free (stash->dwarf_ranges_buffer);
4917 if (stash->info_ptr_memory)
4918 free (stash->info_ptr_memory);
4919 if (stash->close_on_cleanup)
4920 bfd_close (stash->bfd_ptr);
4921 if (stash->alt_dwarf_str_buffer)
4922 free (stash->alt_dwarf_str_buffer);
4923 if (stash->alt_dwarf_info_buffer)
4924 free (stash->alt_dwarf_info_buffer);
4925 if (stash->sec_vma)
4926 free (stash->sec_vma);
4927 if (stash->adjusted_sections)
4928 free (stash->adjusted_sections);
4929 if (stash->alt_bfd_ptr)
4930 bfd_close (stash->alt_bfd_ptr);
4931 }
4932
4933 /* Find the function to a particular section and offset,
4934 for error reporting. */
4935
4936 asymbol *
4937 _bfd_elf_find_function (bfd *abfd,
4938 asymbol **symbols,
4939 asection *section,
4940 bfd_vma offset,
4941 const char **filename_ptr,
4942 const char **functionname_ptr)
4943 {
4944 struct elf_find_function_cache
4945 {
4946 asection *last_section;
4947 asymbol *func;
4948 const char *filename;
4949 bfd_size_type func_size;
4950 } *cache;
4951
4952 if (symbols == NULL)
4953 return NULL;
4954
4955 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
4956 return NULL;
4957
4958 cache = elf_tdata (abfd)->elf_find_function_cache;
4959 if (cache == NULL)
4960 {
4961 cache = bfd_zalloc (abfd, sizeof (*cache));
4962 elf_tdata (abfd)->elf_find_function_cache = cache;
4963 if (cache == NULL)
4964 return NULL;
4965 }
4966 if (cache->last_section != section
4967 || cache->func == NULL
4968 || offset < cache->func->value
4969 || offset >= cache->func->value + cache->func_size)
4970 {
4971 asymbol *file;
4972 bfd_vma low_func;
4973 asymbol **p;
4974 /* ??? Given multiple file symbols, it is impossible to reliably
4975 choose the right file name for global symbols. File symbols are
4976 local symbols, and thus all file symbols must sort before any
4977 global symbols. The ELF spec may be interpreted to say that a
4978 file symbol must sort before other local symbols, but currently
4979 ld -r doesn't do this. So, for ld -r output, it is possible to
4980 make a better choice of file name for local symbols by ignoring
4981 file symbols appearing after a given local symbol. */
4982 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
4983 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4984
4985 file = NULL;
4986 low_func = 0;
4987 state = nothing_seen;
4988 cache->filename = NULL;
4989 cache->func = NULL;
4990 cache->func_size = 0;
4991 cache->last_section = section;
4992
4993 for (p = symbols; *p != NULL; p++)
4994 {
4995 asymbol *sym = *p;
4996 bfd_vma code_off;
4997 bfd_size_type size;
4998
4999 if ((sym->flags & BSF_FILE) != 0)
5000 {
5001 file = sym;
5002 if (state == symbol_seen)
5003 state = file_after_symbol_seen;
5004 continue;
5005 }
5006
5007 size = bed->maybe_function_sym (sym, section, &code_off);
5008 if (size != 0
5009 && code_off <= offset
5010 && (code_off > low_func
5011 || (code_off == low_func
5012 && size > cache->func_size)))
5013 {
5014 cache->func = sym;
5015 cache->func_size = size;
5016 cache->filename = NULL;
5017 low_func = code_off;
5018 if (file != NULL
5019 && ((sym->flags & BSF_LOCAL) != 0
5020 || state != file_after_symbol_seen))
5021 cache->filename = bfd_asymbol_name (file);
5022 }
5023 if (state == nothing_seen)
5024 state = symbol_seen;
5025 }
5026 }
5027
5028 if (cache->func == NULL)
5029 return NULL;
5030
5031 if (filename_ptr)
5032 *filename_ptr = cache->filename;
5033 if (functionname_ptr)
5034 *functionname_ptr = bfd_asymbol_name (cache->func);
5035
5036 return cache->func;
5037 }