* readelf.c (get_arm_section_type_name): Added support for
[deliverable/binutils-gdb.git] / bfd / dwarf2.c
1 /* DWARF 2 support.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
6 (gavin@cygnus.com).
7
8 From the dwarf2read.c header:
9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
10 Inc. with support from Florida State University (under contract
11 with the Ada Joint Program Office), and Silicon Graphics, Inc.
12 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 support in dwarfread.c
15
16 This file is part of BFD.
17
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 3 of the License, or (at
21 your option) any later version.
22
23 This program is distributed in the hope that it will be useful, but
24 WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 General Public License for more details.
27
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
31 MA 02110-1301, USA. */
32
33 #include "sysdep.h"
34 #include "bfd.h"
35 #include "libiberty.h"
36 #include "libbfd.h"
37 #include "elf-bfd.h"
38 #include "dwarf2.h"
39
40 /* The data in the .debug_line statement prologue looks like this. */
41
42 struct line_head
43 {
44 bfd_vma total_length;
45 unsigned short version;
46 bfd_vma prologue_length;
47 unsigned char minimum_instruction_length;
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 /* The next unread compilation unit within the .debug_info section.
93 Zero indicates that the .debug_info section has not been loaded
94 into a buffer yet. */
95 bfd_byte *info_ptr;
96
97 /* Pointer to the end of the .debug_info section memory buffer. */
98 bfd_byte *info_ptr_end;
99
100 /* Pointer to the bfd, section and address of the beginning of the
101 section. The bfd might be different than expected because of
102 gnu_debuglink sections. */
103 bfd * bfd;
104 asection *sec;
105 bfd_byte *sec_info_ptr;
106
107 /* A pointer to the memory block allocated for info_ptr. Neither
108 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
109 beginning of the malloc block. This is used only to free the
110 memory later. */
111 bfd_byte *info_ptr_memory;
112
113 /* Pointer to the symbol table. */
114 asymbol **syms;
115
116 /* Pointer to the .debug_abbrev section loaded into memory. */
117 bfd_byte *dwarf_abbrev_buffer;
118
119 /* Length of the loaded .debug_abbrev section. */
120 bfd_size_type dwarf_abbrev_size;
121
122 /* Buffer for decode_line_info. */
123 bfd_byte *dwarf_line_buffer;
124
125 /* Length of the loaded .debug_line section. */
126 bfd_size_type dwarf_line_size;
127
128 /* Pointer to the .debug_str section loaded into memory. */
129 bfd_byte *dwarf_str_buffer;
130
131 /* Length of the loaded .debug_str section. */
132 bfd_size_type dwarf_str_size;
133
134 /* Pointer to the .debug_ranges section loaded into memory. */
135 bfd_byte *dwarf_ranges_buffer;
136
137 /* Length of the loaded .debug_ranges section. */
138 bfd_size_type dwarf_ranges_size;
139
140 /* If the most recent call to bfd_find_nearest_line was given an
141 address in an inlined function, preserve a pointer into the
142 calling chain for subsequent calls to bfd_find_inliner_info to
143 use. */
144 struct funcinfo *inliner_chain;
145
146 /* Number of sections whose VMA we must adjust. */
147 unsigned int adjusted_section_count;
148
149 /* Array of sections with adjusted VMA. */
150 struct adjusted_section *adjusted_sections;
151
152 /* Number of times find_line is called. This is used in
153 the heuristic for enabling the info hash tables. */
154 int info_hash_count;
155
156 #define STASH_INFO_HASH_TRIGGER 100
157
158 /* Hash table mapping symbol names to function infos. */
159 struct info_hash_table *funcinfo_hash_table;
160
161 /* Hash table mapping symbol names to variable infos. */
162 struct info_hash_table *varinfo_hash_table;
163
164 /* Head of comp_unit list in the last hash table update. */
165 struct comp_unit *hash_units_head;
166
167 /* Status of info hash. */
168 int info_hash_status;
169 #define STASH_INFO_HASH_OFF 0
170 #define STASH_INFO_HASH_ON 1
171 #define STASH_INFO_HASH_DISABLED 2
172 };
173
174 struct arange
175 {
176 struct arange *next;
177 bfd_vma low;
178 bfd_vma high;
179 };
180
181 /* A minimal decoding of DWARF2 compilation units. We only decode
182 what's needed to get to the line number information. */
183
184 struct comp_unit
185 {
186 /* Chain the previously read compilation units. */
187 struct comp_unit *next_unit;
188
189 /* Likewise, chain the compilation unit read after this one.
190 The comp units are stored in reversed reading order. */
191 struct comp_unit *prev_unit;
192
193 /* Keep the bfd convenient (for memory allocation). */
194 bfd *abfd;
195
196 /* The lowest and highest addresses contained in this compilation
197 unit as specified in the compilation unit header. */
198 struct arange arange;
199
200 /* The DW_AT_name attribute (for error messages). */
201 char *name;
202
203 /* The abbrev hash table. */
204 struct abbrev_info **abbrevs;
205
206 /* Note that an error was found by comp_unit_find_nearest_line. */
207 int error;
208
209 /* The DW_AT_comp_dir attribute. */
210 char *comp_dir;
211
212 /* TRUE if there is a line number table associated with this comp. unit. */
213 int stmtlist;
214
215 /* Pointer to the current comp_unit so that we can find a given entry
216 by its reference. */
217 bfd_byte *info_ptr_unit;
218
219 /* The offset into .debug_line of the line number table. */
220 unsigned long line_offset;
221
222 /* Pointer to the first child die for the comp unit. */
223 bfd_byte *first_child_die_ptr;
224
225 /* The end of the comp unit. */
226 bfd_byte *end_ptr;
227
228 /* The decoded line number, NULL if not yet decoded. */
229 struct line_info_table *line_table;
230
231 /* A list of the functions found in this comp. unit. */
232 struct funcinfo *function_table;
233
234 /* A list of the variables found in this comp. unit. */
235 struct varinfo *variable_table;
236
237 /* Pointer to dwarf2_debug structure. */
238 struct dwarf2_debug *stash;
239
240 /* DWARF format version for this unit - from unit header. */
241 int version;
242
243 /* Address size for this unit - from unit header. */
244 unsigned char addr_size;
245
246 /* Offset size for this unit - from unit header. */
247 unsigned char offset_size;
248
249 /* Base address for this unit - from DW_AT_low_pc attribute of
250 DW_TAG_compile_unit DIE */
251 bfd_vma base_address;
252
253 /* TRUE if symbols are cached in hash table for faster lookup by name. */
254 bfd_boolean cached;
255 };
256
257 /* This data structure holds the information of an abbrev. */
258 struct abbrev_info
259 {
260 unsigned int number; /* Number identifying abbrev. */
261 enum dwarf_tag tag; /* DWARF tag. */
262 int has_children; /* Boolean. */
263 unsigned int num_attrs; /* Number of attributes. */
264 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
265 struct abbrev_info *next; /* Next in chain. */
266 };
267
268 struct attr_abbrev
269 {
270 enum dwarf_attribute name;
271 enum dwarf_form form;
272 };
273
274 #ifndef ABBREV_HASH_SIZE
275 #define ABBREV_HASH_SIZE 121
276 #endif
277 #ifndef ATTR_ALLOC_CHUNK
278 #define ATTR_ALLOC_CHUNK 4
279 #endif
280
281 /* Variable and function hash tables. This is used to speed up look-up
282 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
283 In order to share code between variable and function infos, we use
284 a list of untyped pointer for all variable/function info associated with
285 a symbol. We waste a bit of memory for list with one node but that
286 simplifies the code. */
287
288 struct info_list_node
289 {
290 struct info_list_node *next;
291 void *info;
292 };
293
294 /* Info hash entry. */
295 struct info_hash_entry
296 {
297 struct bfd_hash_entry root;
298 struct info_list_node *head;
299 };
300
301 struct info_hash_table
302 {
303 struct bfd_hash_table base;
304 };
305
306 /* Function to create a new entry in info hash table. */
307
308 static struct bfd_hash_entry *
309 info_hash_table_newfunc (struct bfd_hash_entry *entry,
310 struct bfd_hash_table *table,
311 const char *string)
312 {
313 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
314
315 /* Allocate the structure if it has not already been allocated by a
316 derived class. */
317 if (ret == NULL)
318 {
319 ret = bfd_hash_allocate (table, sizeof (* ret));
320 if (ret == NULL)
321 return NULL;
322 }
323
324 /* Call the allocation method of the base class. */
325 ret = ((struct info_hash_entry *)
326 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
327
328 /* Initialize the local fields here. */
329 if (ret)
330 ret->head = NULL;
331
332 return (struct bfd_hash_entry *) ret;
333 }
334
335 /* Function to create a new info hash table. It returns a pointer to the
336 newly created table or NULL if there is any error. We need abfd
337 solely for memory allocation. */
338
339 static struct info_hash_table *
340 create_info_hash_table (bfd *abfd)
341 {
342 struct info_hash_table *hash_table;
343
344 hash_table = bfd_alloc (abfd, sizeof (struct info_hash_table));
345 if (!hash_table)
346 return hash_table;
347
348 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
349 sizeof (struct info_hash_entry)))
350 {
351 bfd_release (abfd, hash_table);
352 return NULL;
353 }
354
355 return hash_table;
356 }
357
358 /* Insert an info entry into an info hash table. We do not check of
359 duplicate entries. Also, the caller need to guarantee that the
360 right type of info in inserted as info is passed as a void* pointer.
361 This function returns true if there is no error. */
362
363 static bfd_boolean
364 insert_info_hash_table (struct info_hash_table *hash_table,
365 const char *key,
366 void *info,
367 bfd_boolean copy_p)
368 {
369 struct info_hash_entry *entry;
370 struct info_list_node *node;
371
372 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
373 key, TRUE, copy_p);
374 if (!entry)
375 return FALSE;
376
377 node = bfd_hash_allocate (&hash_table->base, sizeof (*node));
378 if (!node)
379 return FALSE;
380
381 node->info = info;
382 node->next = entry->head;
383 entry->head = node;
384
385 return TRUE;
386 }
387
388 /* Look up an info entry list from an info hash table. Return NULL
389 if there is none. */
390
391 static struct info_list_node *
392 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
393 {
394 struct info_hash_entry *entry;
395
396 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
397 FALSE, FALSE);
398 return entry ? entry->head : NULL;
399 }
400
401 /* Read a section into its appropriate place in the dwarf2_debug
402 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
403 not NULL, use bfd_simple_get_relocated_section_contents to read the
404 section contents, otherwise use bfd_get_section_contents. Fail if
405 the located section does not contain at least OFFSET bytes. */
406
407 static bfd_boolean
408 read_section (bfd * abfd,
409 const char * section_name,
410 const char * compressed_section_name,
411 asymbol ** syms,
412 bfd_uint64_t offset,
413 bfd_byte ** section_buffer,
414 bfd_size_type * section_size)
415 {
416 asection *msec;
417 bfd_boolean section_is_compressed = FALSE;
418
419 /* read_section is a noop if the section has already been read. */
420 if (!*section_buffer)
421 {
422 msec = bfd_get_section_by_name (abfd, section_name);
423 if (! msec && compressed_section_name)
424 {
425 msec = bfd_get_section_by_name (abfd, compressed_section_name);
426 section_is_compressed = TRUE;
427 }
428 if (! msec)
429 {
430 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."), section_name);
431 bfd_set_error (bfd_error_bad_value);
432 return FALSE;
433 }
434
435 *section_size = msec->rawsize ? msec->rawsize : msec->size;
436 if (syms)
437 {
438 *section_buffer
439 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
440 if (! *section_buffer)
441 return FALSE;
442 }
443 else
444 {
445 *section_buffer = bfd_malloc (*section_size);
446 if (! *section_buffer)
447 return FALSE;
448 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
449 0, *section_size))
450 return FALSE;
451 }
452
453 if (section_is_compressed)
454 {
455 if (! bfd_uncompress_section_contents (section_buffer, section_size))
456 {
457 (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name);
458 bfd_set_error (bfd_error_bad_value);
459 return FALSE;
460 }
461 }
462 }
463
464 /* It is possible to get a bad value for the offset into the section
465 that the client wants. Validate it here to avoid trouble later. */
466 if (offset != 0 && offset >= *section_size)
467 {
468 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
469 (long) offset, section_name, *section_size);
470 bfd_set_error (bfd_error_bad_value);
471 return FALSE;
472 }
473
474 return TRUE;
475 }
476
477 /* VERBATIM
478 The following function up to the END VERBATIM mark are
479 copied directly from dwarf2read.c. */
480
481 /* Read dwarf information from a buffer. */
482
483 static unsigned int
484 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
485 {
486 return bfd_get_8 (abfd, buf);
487 }
488
489 static int
490 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
491 {
492 return bfd_get_signed_8 (abfd, buf);
493 }
494
495 static unsigned int
496 read_2_bytes (bfd *abfd, bfd_byte *buf)
497 {
498 return bfd_get_16 (abfd, buf);
499 }
500
501 static unsigned int
502 read_4_bytes (bfd *abfd, bfd_byte *buf)
503 {
504 return bfd_get_32 (abfd, buf);
505 }
506
507 static bfd_uint64_t
508 read_8_bytes (bfd *abfd, bfd_byte *buf)
509 {
510 return bfd_get_64 (abfd, buf);
511 }
512
513 static bfd_byte *
514 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
515 bfd_byte *buf,
516 unsigned int size ATTRIBUTE_UNUSED)
517 {
518 return buf;
519 }
520
521 static char *
522 read_string (bfd *abfd ATTRIBUTE_UNUSED,
523 bfd_byte *buf,
524 unsigned int *bytes_read_ptr)
525 {
526 /* Return a pointer to the embedded string. */
527 char *str = (char *) buf;
528
529 if (*str == '\0')
530 {
531 *bytes_read_ptr = 1;
532 return NULL;
533 }
534
535 *bytes_read_ptr = strlen (str) + 1;
536 return str;
537 }
538
539 /* END VERBATIM */
540
541 static char *
542 read_indirect_string (struct comp_unit * unit,
543 bfd_byte * buf,
544 unsigned int * bytes_read_ptr)
545 {
546 bfd_uint64_t offset;
547 struct dwarf2_debug *stash = unit->stash;
548 char *str;
549
550 if (unit->offset_size == 4)
551 offset = read_4_bytes (unit->abfd, buf);
552 else
553 offset = read_8_bytes (unit->abfd, buf);
554
555 *bytes_read_ptr = unit->offset_size;
556
557 if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
558 stash->syms, offset,
559 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
560 return NULL;
561
562 str = (char *) stash->dwarf_str_buffer + offset;
563 if (*str == '\0')
564 return NULL;
565 return str;
566 }
567
568 static bfd_uint64_t
569 read_address (struct comp_unit *unit, bfd_byte *buf)
570 {
571 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
572
573 if (signed_vma)
574 {
575 switch (unit->addr_size)
576 {
577 case 8:
578 return bfd_get_signed_64 (unit->abfd, buf);
579 case 4:
580 return bfd_get_signed_32 (unit->abfd, buf);
581 case 2:
582 return bfd_get_signed_16 (unit->abfd, buf);
583 default:
584 abort ();
585 }
586 }
587 else
588 {
589 switch (unit->addr_size)
590 {
591 case 8:
592 return bfd_get_64 (unit->abfd, buf);
593 case 4:
594 return bfd_get_32 (unit->abfd, buf);
595 case 2:
596 return bfd_get_16 (unit->abfd, buf);
597 default:
598 abort ();
599 }
600 }
601 }
602
603 /* Lookup an abbrev_info structure in the abbrev hash table. */
604
605 static struct abbrev_info *
606 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
607 {
608 unsigned int hash_number;
609 struct abbrev_info *abbrev;
610
611 hash_number = number % ABBREV_HASH_SIZE;
612 abbrev = abbrevs[hash_number];
613
614 while (abbrev)
615 {
616 if (abbrev->number == number)
617 return abbrev;
618 else
619 abbrev = abbrev->next;
620 }
621
622 return NULL;
623 }
624
625 /* In DWARF version 2, the description of the debugging information is
626 stored in a separate .debug_abbrev section. Before we read any
627 dies from a section we read in all abbreviations and install them
628 in a hash table. */
629
630 static struct abbrev_info**
631 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
632 {
633 struct abbrev_info **abbrevs;
634 bfd_byte *abbrev_ptr;
635 struct abbrev_info *cur_abbrev;
636 unsigned int abbrev_number, bytes_read, abbrev_name;
637 unsigned int abbrev_form, hash_number;
638 bfd_size_type amt;
639
640 if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
641 stash->syms, offset,
642 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
643 return 0;
644
645 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
646 abbrevs = bfd_zalloc (abfd, amt);
647
648 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
649 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
650 abbrev_ptr += bytes_read;
651
652 /* Loop until we reach an abbrev number of 0. */
653 while (abbrev_number)
654 {
655 amt = sizeof (struct abbrev_info);
656 cur_abbrev = bfd_zalloc (abfd, amt);
657
658 /* Read in abbrev header. */
659 cur_abbrev->number = abbrev_number;
660 cur_abbrev->tag = (enum dwarf_tag)
661 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
662 abbrev_ptr += bytes_read;
663 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
664 abbrev_ptr += 1;
665
666 /* Now read in declarations. */
667 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
668 abbrev_ptr += bytes_read;
669 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
670 abbrev_ptr += bytes_read;
671
672 while (abbrev_name)
673 {
674 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
675 {
676 struct attr_abbrev *tmp;
677
678 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
679 amt *= sizeof (struct attr_abbrev);
680 tmp = bfd_realloc (cur_abbrev->attrs, amt);
681 if (tmp == NULL)
682 {
683 size_t i;
684
685 for (i = 0; i < ABBREV_HASH_SIZE; i++)
686 {
687 struct abbrev_info *abbrev = abbrevs[i];
688
689 while (abbrev)
690 {
691 free (abbrev->attrs);
692 abbrev = abbrev->next;
693 }
694 }
695 return NULL;
696 }
697 cur_abbrev->attrs = tmp;
698 }
699
700 cur_abbrev->attrs[cur_abbrev->num_attrs].name
701 = (enum dwarf_attribute) abbrev_name;
702 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
703 = (enum dwarf_form) abbrev_form;
704 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
705 abbrev_ptr += bytes_read;
706 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
707 abbrev_ptr += bytes_read;
708 }
709
710 hash_number = abbrev_number % ABBREV_HASH_SIZE;
711 cur_abbrev->next = abbrevs[hash_number];
712 abbrevs[hash_number] = cur_abbrev;
713
714 /* Get next abbreviation.
715 Under Irix6 the abbreviations for a compilation unit are not
716 always properly terminated with an abbrev number of 0.
717 Exit loop if we encounter an abbreviation which we have
718 already read (which means we are about to read the abbreviations
719 for the next compile unit) or if the end of the abbreviation
720 table is reached. */
721 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
722 >= stash->dwarf_abbrev_size)
723 break;
724 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
725 abbrev_ptr += bytes_read;
726 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
727 break;
728 }
729
730 return abbrevs;
731 }
732
733 /* Read an attribute value described by an attribute form. */
734
735 static bfd_byte *
736 read_attribute_value (struct attribute *attr,
737 unsigned form,
738 struct comp_unit *unit,
739 bfd_byte *info_ptr)
740 {
741 bfd *abfd = unit->abfd;
742 unsigned int bytes_read;
743 struct dwarf_block *blk;
744 bfd_size_type amt;
745
746 attr->form = (enum dwarf_form) form;
747
748 switch (form)
749 {
750 case DW_FORM_ref_addr:
751 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
752 DWARF3. */
753 if (unit->version == 3)
754 {
755 if (unit->offset_size == 4)
756 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
757 else
758 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
759 info_ptr += unit->offset_size;
760 break;
761 }
762 /* FALLTHROUGH */
763 case DW_FORM_addr:
764 attr->u.val = read_address (unit, info_ptr);
765 info_ptr += unit->addr_size;
766 break;
767 case DW_FORM_block2:
768 amt = sizeof (struct dwarf_block);
769 blk = bfd_alloc (abfd, amt);
770 blk->size = read_2_bytes (abfd, info_ptr);
771 info_ptr += 2;
772 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
773 info_ptr += blk->size;
774 attr->u.blk = blk;
775 break;
776 case DW_FORM_block4:
777 amt = sizeof (struct dwarf_block);
778 blk = bfd_alloc (abfd, amt);
779 blk->size = read_4_bytes (abfd, info_ptr);
780 info_ptr += 4;
781 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
782 info_ptr += blk->size;
783 attr->u.blk = blk;
784 break;
785 case DW_FORM_data2:
786 attr->u.val = read_2_bytes (abfd, info_ptr);
787 info_ptr += 2;
788 break;
789 case DW_FORM_data4:
790 attr->u.val = read_4_bytes (abfd, info_ptr);
791 info_ptr += 4;
792 break;
793 case DW_FORM_data8:
794 attr->u.val = read_8_bytes (abfd, info_ptr);
795 info_ptr += 8;
796 break;
797 case DW_FORM_string:
798 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
799 info_ptr += bytes_read;
800 break;
801 case DW_FORM_strp:
802 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
803 info_ptr += bytes_read;
804 break;
805 case DW_FORM_block:
806 amt = sizeof (struct dwarf_block);
807 blk = bfd_alloc (abfd, amt);
808 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
809 info_ptr += bytes_read;
810 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
811 info_ptr += blk->size;
812 attr->u.blk = blk;
813 break;
814 case DW_FORM_block1:
815 amt = sizeof (struct dwarf_block);
816 blk = bfd_alloc (abfd, amt);
817 blk->size = read_1_byte (abfd, info_ptr);
818 info_ptr += 1;
819 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
820 info_ptr += blk->size;
821 attr->u.blk = blk;
822 break;
823 case DW_FORM_data1:
824 attr->u.val = read_1_byte (abfd, info_ptr);
825 info_ptr += 1;
826 break;
827 case DW_FORM_flag:
828 attr->u.val = read_1_byte (abfd, info_ptr);
829 info_ptr += 1;
830 break;
831 case DW_FORM_sdata:
832 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
833 info_ptr += bytes_read;
834 break;
835 case DW_FORM_udata:
836 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
837 info_ptr += bytes_read;
838 break;
839 case DW_FORM_ref1:
840 attr->u.val = read_1_byte (abfd, info_ptr);
841 info_ptr += 1;
842 break;
843 case DW_FORM_ref2:
844 attr->u.val = read_2_bytes (abfd, info_ptr);
845 info_ptr += 2;
846 break;
847 case DW_FORM_ref4:
848 attr->u.val = read_4_bytes (abfd, info_ptr);
849 info_ptr += 4;
850 break;
851 case DW_FORM_ref8:
852 attr->u.val = read_8_bytes (abfd, info_ptr);
853 info_ptr += 8;
854 break;
855 case DW_FORM_ref_udata:
856 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
857 info_ptr += bytes_read;
858 break;
859 case DW_FORM_indirect:
860 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
861 info_ptr += bytes_read;
862 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
863 break;
864 default:
865 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
866 form);
867 bfd_set_error (bfd_error_bad_value);
868 }
869 return info_ptr;
870 }
871
872 /* Read an attribute described by an abbreviated attribute. */
873
874 static bfd_byte *
875 read_attribute (struct attribute *attr,
876 struct attr_abbrev *abbrev,
877 struct comp_unit *unit,
878 bfd_byte *info_ptr)
879 {
880 attr->name = abbrev->name;
881 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
882 return info_ptr;
883 }
884
885 /* Source line information table routines. */
886
887 #define FILE_ALLOC_CHUNK 5
888 #define DIR_ALLOC_CHUNK 5
889
890 struct line_info
891 {
892 struct line_info* prev_line;
893 bfd_vma address;
894 char *filename;
895 unsigned int line;
896 unsigned int column;
897 int end_sequence; /* End of (sequential) code sequence. */
898 };
899
900 struct fileinfo
901 {
902 char *name;
903 unsigned int dir;
904 unsigned int time;
905 unsigned int size;
906 };
907
908 struct line_info_table
909 {
910 bfd* abfd;
911 unsigned int num_files;
912 unsigned int num_dirs;
913 char *comp_dir;
914 char **dirs;
915 struct fileinfo* files;
916 struct line_info* last_line; /* largest VMA */
917 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
918 };
919
920 /* Remember some information about each function. If the function is
921 inlined (DW_TAG_inlined_subroutine) it may have two additional
922 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
923 source code location where this function was inlined. */
924
925 struct funcinfo
926 {
927 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
928 struct funcinfo *caller_func; /* Pointer to function one scope higher */
929 char *caller_file; /* Source location file name where caller_func inlines this func */
930 int caller_line; /* Source location line number where caller_func inlines this func */
931 char *file; /* Source location file name */
932 int line; /* Source location line number */
933 int tag;
934 char *name;
935 struct arange arange;
936 asection *sec; /* Where the symbol is defined */
937 };
938
939 struct varinfo
940 {
941 /* Pointer to previous variable in list of all variables */
942 struct varinfo *prev_var;
943 /* Source location file name */
944 char *file;
945 /* Source location line number */
946 int line;
947 int tag;
948 char *name;
949 bfd_vma addr;
950 /* Where the symbol is defined */
951 asection *sec;
952 /* Is this a stack variable? */
953 unsigned int stack: 1;
954 };
955
956 /* Return TRUE if NEW_LINE should sort after LINE. */
957
958 static inline bfd_boolean
959 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
960 {
961 return (new_line->address > line->address
962 || (new_line->address == line->address
963 && new_line->end_sequence < line->end_sequence));
964 }
965
966
967 /* Adds a new entry to the line_info list in the line_info_table, ensuring
968 that the list is sorted. Note that the line_info list is sorted from
969 highest to lowest VMA (with possible duplicates); that is,
970 line_info->prev_line always accesses an equal or smaller VMA. */
971
972 static void
973 add_line_info (struct line_info_table *table,
974 bfd_vma address,
975 char *filename,
976 unsigned int line,
977 unsigned int column,
978 int end_sequence)
979 {
980 bfd_size_type amt = sizeof (struct line_info);
981 struct line_info* info = bfd_alloc (table->abfd, amt);
982
983 /* Set member data of 'info'. */
984 info->address = address;
985 info->line = line;
986 info->column = column;
987 info->end_sequence = end_sequence;
988
989 if (filename && filename[0])
990 {
991 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
992 if (info->filename)
993 strcpy (info->filename, filename);
994 }
995 else
996 info->filename = NULL;
997
998 /* Find the correct location for 'info'. Normally we will receive
999 new line_info data 1) in order and 2) with increasing VMAs.
1000 However some compilers break the rules (cf. decode_line_info) and
1001 so we include some heuristics for quickly finding the correct
1002 location for 'info'. In particular, these heuristics optimize for
1003 the common case in which the VMA sequence that we receive is a
1004 list of locally sorted VMAs such as
1005 p...z a...j (where a < j < p < z)
1006
1007 Note: table->lcl_head is used to head an *actual* or *possible*
1008 sequence within the list (such as a...j) that is not directly
1009 headed by table->last_line
1010
1011 Note: we may receive duplicate entries from 'decode_line_info'. */
1012
1013 if (table->last_line
1014 && table->last_line->address == address
1015 && table->last_line->end_sequence == end_sequence)
1016 {
1017 /* We only keep the last entry with the same address and end
1018 sequence. See PR ld/4986. */
1019 if (table->lcl_head == table->last_line)
1020 table->lcl_head = info;
1021 info->prev_line = table->last_line->prev_line;
1022 table->last_line = info;
1023 }
1024 else if (!table->last_line
1025 || new_line_sorts_after (info, table->last_line))
1026 {
1027 /* Normal case: add 'info' to the beginning of the list */
1028 info->prev_line = table->last_line;
1029 table->last_line = info;
1030
1031 /* lcl_head: initialize to head a *possible* sequence at the end. */
1032 if (!table->lcl_head)
1033 table->lcl_head = info;
1034 }
1035 else if (!new_line_sorts_after (info, table->lcl_head)
1036 && (!table->lcl_head->prev_line
1037 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1038 {
1039 /* Abnormal but easy: lcl_head is the head of 'info'. */
1040 info->prev_line = table->lcl_head->prev_line;
1041 table->lcl_head->prev_line = info;
1042 }
1043 else
1044 {
1045 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
1046 heads for 'info'. Reset 'lcl_head'. */
1047 struct line_info* li2 = table->last_line; /* always non-NULL */
1048 struct line_info* li1 = li2->prev_line;
1049
1050 while (li1)
1051 {
1052 if (!new_line_sorts_after (info, li2)
1053 && new_line_sorts_after (info, li1))
1054 break;
1055
1056 li2 = li1; /* always non-NULL */
1057 li1 = li1->prev_line;
1058 }
1059 table->lcl_head = li2;
1060 info->prev_line = table->lcl_head->prev_line;
1061 table->lcl_head->prev_line = info;
1062 }
1063 }
1064
1065 /* Extract a fully qualified filename from a line info table.
1066 The returned string has been malloc'ed and it is the caller's
1067 responsibility to free it. */
1068
1069 static char *
1070 concat_filename (struct line_info_table *table, unsigned int file)
1071 {
1072 char *filename;
1073
1074 if (file - 1 >= table->num_files)
1075 {
1076 /* FILE == 0 means unknown. */
1077 if (file)
1078 (*_bfd_error_handler)
1079 (_("Dwarf Error: mangled line number section (bad file number)."));
1080 return strdup ("<unknown>");
1081 }
1082
1083 filename = table->files[file - 1].name;
1084
1085 if (!IS_ABSOLUTE_PATH (filename))
1086 {
1087 char *dirname = NULL;
1088 char *subdirname = NULL;
1089 char *name;
1090 size_t len;
1091
1092 if (table->files[file - 1].dir)
1093 subdirname = table->dirs[table->files[file - 1].dir - 1];
1094
1095 if (!subdirname || !IS_ABSOLUTE_PATH (subdirname))
1096 dirname = table->comp_dir;
1097
1098 if (!dirname)
1099 {
1100 dirname = subdirname;
1101 subdirname = NULL;
1102 }
1103
1104 if (!dirname)
1105 return strdup (filename);
1106
1107 len = strlen (dirname) + strlen (filename) + 2;
1108
1109 if (subdirname)
1110 {
1111 len += strlen (subdirname) + 1;
1112 name = bfd_malloc (len);
1113 if (name)
1114 sprintf (name, "%s/%s/%s", dirname, subdirname, filename);
1115 }
1116 else
1117 {
1118 name = bfd_malloc (len);
1119 if (name)
1120 sprintf (name, "%s/%s", dirname, filename);
1121 }
1122
1123 return name;
1124 }
1125
1126 return strdup (filename);
1127 }
1128
1129 static void
1130 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
1131 {
1132 struct arange *arange;
1133
1134 /* If the first arange is empty, use it. */
1135 if (first_arange->high == 0)
1136 {
1137 first_arange->low = low_pc;
1138 first_arange->high = high_pc;
1139 return;
1140 }
1141
1142 /* Next see if we can cheaply extend an existing range. */
1143 arange = first_arange;
1144 do
1145 {
1146 if (low_pc == arange->high)
1147 {
1148 arange->high = high_pc;
1149 return;
1150 }
1151 if (high_pc == arange->low)
1152 {
1153 arange->low = low_pc;
1154 return;
1155 }
1156 arange = arange->next;
1157 }
1158 while (arange);
1159
1160 /* Need to allocate a new arange and insert it into the arange list.
1161 Order isn't significant, so just insert after the first arange. */
1162 arange = bfd_zalloc (abfd, sizeof (*arange));
1163 arange->low = low_pc;
1164 arange->high = high_pc;
1165 arange->next = first_arange->next;
1166 first_arange->next = arange;
1167 }
1168
1169 /* Decode the line number information for UNIT. */
1170
1171 static struct line_info_table*
1172 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1173 {
1174 bfd *abfd = unit->abfd;
1175 struct line_info_table* table;
1176 bfd_byte *line_ptr;
1177 bfd_byte *line_end;
1178 struct line_head lh;
1179 unsigned int i, bytes_read, offset_size;
1180 char *cur_file, *cur_dir;
1181 unsigned char op_code, extended_op, adj_opcode;
1182 bfd_size_type amt;
1183
1184 if (! read_section (abfd, ".debug_line", ".zdebug_line",
1185 stash->syms, unit->line_offset,
1186 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1187 return 0;
1188
1189 amt = sizeof (struct line_info_table);
1190 table = bfd_alloc (abfd, amt);
1191 table->abfd = abfd;
1192 table->comp_dir = unit->comp_dir;
1193
1194 table->num_files = 0;
1195 table->files = NULL;
1196
1197 table->num_dirs = 0;
1198 table->dirs = NULL;
1199
1200 table->files = NULL;
1201 table->last_line = NULL;
1202 table->lcl_head = NULL;
1203
1204 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1205
1206 /* Read in the prologue. */
1207 lh.total_length = read_4_bytes (abfd, line_ptr);
1208 line_ptr += 4;
1209 offset_size = 4;
1210 if (lh.total_length == 0xffffffff)
1211 {
1212 lh.total_length = read_8_bytes (abfd, line_ptr);
1213 line_ptr += 8;
1214 offset_size = 8;
1215 }
1216 else if (lh.total_length == 0 && unit->addr_size == 8)
1217 {
1218 /* Handle (non-standard) 64-bit DWARF2 formats. */
1219 lh.total_length = read_4_bytes (abfd, line_ptr);
1220 line_ptr += 4;
1221 offset_size = 8;
1222 }
1223 line_end = line_ptr + lh.total_length;
1224 lh.version = read_2_bytes (abfd, line_ptr);
1225 line_ptr += 2;
1226 if (offset_size == 4)
1227 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1228 else
1229 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1230 line_ptr += offset_size;
1231 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1232 line_ptr += 1;
1233 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1234 line_ptr += 1;
1235 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1236 line_ptr += 1;
1237 lh.line_range = read_1_byte (abfd, line_ptr);
1238 line_ptr += 1;
1239 lh.opcode_base = read_1_byte (abfd, line_ptr);
1240 line_ptr += 1;
1241 amt = lh.opcode_base * sizeof (unsigned char);
1242 lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1243
1244 lh.standard_opcode_lengths[0] = 1;
1245
1246 for (i = 1; i < lh.opcode_base; ++i)
1247 {
1248 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1249 line_ptr += 1;
1250 }
1251
1252 /* Read directory table. */
1253 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1254 {
1255 line_ptr += bytes_read;
1256
1257 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1258 {
1259 char **tmp;
1260
1261 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1262 amt *= sizeof (char *);
1263
1264 tmp = bfd_realloc (table->dirs, amt);
1265 if (tmp == NULL)
1266 {
1267 free (table->dirs);
1268 return NULL;
1269 }
1270 table->dirs = tmp;
1271 }
1272
1273 table->dirs[table->num_dirs++] = cur_dir;
1274 }
1275
1276 line_ptr += bytes_read;
1277
1278 /* Read file name table. */
1279 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1280 {
1281 line_ptr += bytes_read;
1282
1283 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1284 {
1285 struct fileinfo *tmp;
1286
1287 amt = table->num_files + FILE_ALLOC_CHUNK;
1288 amt *= sizeof (struct fileinfo);
1289
1290 tmp = bfd_realloc (table->files, amt);
1291 if (tmp == NULL)
1292 {
1293 free (table->files);
1294 free (table->dirs);
1295 return NULL;
1296 }
1297 table->files = tmp;
1298 }
1299
1300 table->files[table->num_files].name = cur_file;
1301 table->files[table->num_files].dir =
1302 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1303 line_ptr += bytes_read;
1304 table->files[table->num_files].time =
1305 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1306 line_ptr += bytes_read;
1307 table->files[table->num_files].size =
1308 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1309 line_ptr += bytes_read;
1310 table->num_files++;
1311 }
1312
1313 line_ptr += bytes_read;
1314
1315 /* Read the statement sequences until there's nothing left. */
1316 while (line_ptr < line_end)
1317 {
1318 /* State machine registers. */
1319 bfd_vma address = 0;
1320 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1321 unsigned int line = 1;
1322 unsigned int column = 0;
1323 int is_stmt = lh.default_is_stmt;
1324 int end_sequence = 0;
1325 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1326 compilers generate address sequences that are wildly out of
1327 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1328 for ia64-Linux). Thus, to determine the low and high
1329 address, we must compare on every DW_LNS_copy, etc. */
1330 bfd_vma low_pc = (bfd_vma) -1;
1331 bfd_vma high_pc = 0;
1332
1333 /* Decode the table. */
1334 while (! end_sequence)
1335 {
1336 op_code = read_1_byte (abfd, line_ptr);
1337 line_ptr += 1;
1338
1339 if (op_code >= lh.opcode_base)
1340 {
1341 /* Special operand. */
1342 adj_opcode = op_code - lh.opcode_base;
1343 address += (adj_opcode / lh.line_range)
1344 * lh.minimum_instruction_length;
1345 line += lh.line_base + (adj_opcode % lh.line_range);
1346 /* Append row to matrix using current values. */
1347 add_line_info (table, address, filename, line, column, 0);
1348 if (address < low_pc)
1349 low_pc = address;
1350 if (address > high_pc)
1351 high_pc = address;
1352 }
1353 else switch (op_code)
1354 {
1355 case DW_LNS_extended_op:
1356 /* Ignore length. */
1357 line_ptr += 1;
1358 extended_op = read_1_byte (abfd, line_ptr);
1359 line_ptr += 1;
1360
1361 switch (extended_op)
1362 {
1363 case DW_LNE_end_sequence:
1364 end_sequence = 1;
1365 add_line_info (table, address, filename, line, column,
1366 end_sequence);
1367 if (address < low_pc)
1368 low_pc = address;
1369 if (address > high_pc)
1370 high_pc = address;
1371 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1372 break;
1373 case DW_LNE_set_address:
1374 address = read_address (unit, line_ptr);
1375 line_ptr += unit->addr_size;
1376 break;
1377 case DW_LNE_define_file:
1378 cur_file = read_string (abfd, line_ptr, &bytes_read);
1379 line_ptr += bytes_read;
1380 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1381 {
1382 struct fileinfo *tmp;
1383
1384 amt = table->num_files + FILE_ALLOC_CHUNK;
1385 amt *= sizeof (struct fileinfo);
1386 tmp = bfd_realloc (table->files, amt);
1387 if (tmp == NULL)
1388 {
1389 free (table->files);
1390 free (table->dirs);
1391 free (filename);
1392 return NULL;
1393 }
1394 table->files = tmp;
1395 }
1396 table->files[table->num_files].name = cur_file;
1397 table->files[table->num_files].dir =
1398 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1399 line_ptr += bytes_read;
1400 table->files[table->num_files].time =
1401 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1402 line_ptr += bytes_read;
1403 table->files[table->num_files].size =
1404 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1405 line_ptr += bytes_read;
1406 table->num_files++;
1407 break;
1408 case DW_LNE_set_discriminator:
1409 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1410 line_ptr += bytes_read;
1411 break;
1412 default:
1413 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1414 bfd_set_error (bfd_error_bad_value);
1415 free (filename);
1416 free (table->files);
1417 free (table->dirs);
1418 return NULL;
1419 }
1420 break;
1421 case DW_LNS_copy:
1422 add_line_info (table, address, filename, line, column, 0);
1423 if (address < low_pc)
1424 low_pc = address;
1425 if (address > high_pc)
1426 high_pc = address;
1427 break;
1428 case DW_LNS_advance_pc:
1429 address += lh.minimum_instruction_length
1430 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1431 line_ptr += bytes_read;
1432 break;
1433 case DW_LNS_advance_line:
1434 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1435 line_ptr += bytes_read;
1436 break;
1437 case DW_LNS_set_file:
1438 {
1439 unsigned int file;
1440
1441 /* The file and directory tables are 0
1442 based, the references are 1 based. */
1443 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1444 line_ptr += bytes_read;
1445 if (filename)
1446 free (filename);
1447 filename = concat_filename (table, file);
1448 break;
1449 }
1450 case DW_LNS_set_column:
1451 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1452 line_ptr += bytes_read;
1453 break;
1454 case DW_LNS_negate_stmt:
1455 is_stmt = (!is_stmt);
1456 break;
1457 case DW_LNS_set_basic_block:
1458 break;
1459 case DW_LNS_const_add_pc:
1460 address += lh.minimum_instruction_length
1461 * ((255 - lh.opcode_base) / lh.line_range);
1462 break;
1463 case DW_LNS_fixed_advance_pc:
1464 address += read_2_bytes (abfd, line_ptr);
1465 line_ptr += 2;
1466 break;
1467 default:
1468 {
1469 int i;
1470
1471 /* Unknown standard opcode, ignore it. */
1472 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1473 {
1474 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1475 line_ptr += bytes_read;
1476 }
1477 }
1478 }
1479 }
1480
1481 if (filename)
1482 free (filename);
1483 }
1484
1485 return table;
1486 }
1487
1488 /* If ADDR is within TABLE set the output parameters and return TRUE,
1489 otherwise return FALSE. The output parameters, FILENAME_PTR and
1490 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1491
1492 static bfd_boolean
1493 lookup_address_in_line_info_table (struct line_info_table *table,
1494 bfd_vma addr,
1495 struct funcinfo *function,
1496 const char **filename_ptr,
1497 unsigned int *linenumber_ptr)
1498 {
1499 /* Note: table->last_line should be a descendingly sorted list. */
1500 struct line_info* next_line = table->last_line;
1501 struct line_info* each_line = NULL;
1502 *filename_ptr = NULL;
1503
1504 if (!next_line)
1505 return FALSE;
1506
1507 each_line = next_line->prev_line;
1508
1509 /* Check for large addresses */
1510 if (addr > next_line->address)
1511 each_line = NULL; /* ensure we skip over the normal case */
1512
1513 /* Normal case: search the list; save */
1514 while (each_line && next_line)
1515 {
1516 /* If we have an address match, save this info. This allows us
1517 to return as good as results as possible for strange debugging
1518 info. */
1519 bfd_boolean addr_match = FALSE;
1520 if (each_line->address <= addr && addr < next_line->address)
1521 {
1522 addr_match = TRUE;
1523
1524 /* If this line appears to span functions, and addr is in the
1525 later function, return the first line of that function instead
1526 of the last line of the earlier one. This check is for GCC
1527 2.95, which emits the first line number for a function late. */
1528
1529 if (function != NULL)
1530 {
1531 bfd_vma lowest_pc;
1532 struct arange *arange;
1533
1534 /* Find the lowest address in the function's range list */
1535 lowest_pc = function->arange.low;
1536 for (arange = &function->arange;
1537 arange;
1538 arange = arange->next)
1539 {
1540 if (function->arange.low < lowest_pc)
1541 lowest_pc = function->arange.low;
1542 }
1543 /* Check for spanning function and set outgoing line info */
1544 if (addr >= lowest_pc
1545 && each_line->address < lowest_pc
1546 && next_line->address > lowest_pc)
1547 {
1548 *filename_ptr = next_line->filename;
1549 *linenumber_ptr = next_line->line;
1550 }
1551 else
1552 {
1553 *filename_ptr = each_line->filename;
1554 *linenumber_ptr = each_line->line;
1555 }
1556 }
1557 else
1558 {
1559 *filename_ptr = each_line->filename;
1560 *linenumber_ptr = each_line->line;
1561 }
1562 }
1563
1564 if (addr_match && !each_line->end_sequence)
1565 return TRUE; /* we have definitely found what we want */
1566
1567 next_line = each_line;
1568 each_line = each_line->prev_line;
1569 }
1570
1571 /* At this point each_line is NULL but next_line is not. If we found
1572 a candidate end-of-sequence point in the loop above, we can return
1573 that (compatibility with a bug in the Intel compiler); otherwise,
1574 assuming that we found the containing function for this address in
1575 this compilation unit, return the first line we have a number for
1576 (compatibility with GCC 2.95). */
1577 if (*filename_ptr == NULL && function != NULL)
1578 {
1579 *filename_ptr = next_line->filename;
1580 *linenumber_ptr = next_line->line;
1581 return TRUE;
1582 }
1583
1584 return FALSE;
1585 }
1586
1587 /* Read in the .debug_ranges section for future reference */
1588
1589 static bfd_boolean
1590 read_debug_ranges (struct comp_unit *unit)
1591 {
1592 struct dwarf2_debug *stash = unit->stash;
1593 return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
1594 stash->syms, 0,
1595 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
1596 }
1597
1598 /* Function table functions. */
1599
1600 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1601 Note that we need to find the function that has the smallest
1602 range that contains ADDR, to handle inlined functions without
1603 depending upon them being ordered in TABLE by increasing range. */
1604
1605 static bfd_boolean
1606 lookup_address_in_function_table (struct comp_unit *unit,
1607 bfd_vma addr,
1608 struct funcinfo **function_ptr,
1609 const char **functionname_ptr)
1610 {
1611 struct funcinfo* each_func;
1612 struct funcinfo* best_fit = NULL;
1613 struct arange *arange;
1614
1615 for (each_func = unit->function_table;
1616 each_func;
1617 each_func = each_func->prev_func)
1618 {
1619 for (arange = &each_func->arange;
1620 arange;
1621 arange = arange->next)
1622 {
1623 if (addr >= arange->low && addr < arange->high)
1624 {
1625 if (!best_fit ||
1626 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1627 best_fit = each_func;
1628 }
1629 }
1630 }
1631
1632 if (best_fit)
1633 {
1634 *functionname_ptr = best_fit->name;
1635 *function_ptr = best_fit;
1636 return TRUE;
1637 }
1638 else
1639 {
1640 return FALSE;
1641 }
1642 }
1643
1644 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1645 and LINENUMBER_PTR, and return TRUE. */
1646
1647 static bfd_boolean
1648 lookup_symbol_in_function_table (struct comp_unit *unit,
1649 asymbol *sym,
1650 bfd_vma addr,
1651 const char **filename_ptr,
1652 unsigned int *linenumber_ptr)
1653 {
1654 struct funcinfo* each_func;
1655 struct funcinfo* best_fit = NULL;
1656 struct arange *arange;
1657 const char *name = bfd_asymbol_name (sym);
1658 asection *sec = bfd_get_section (sym);
1659
1660 for (each_func = unit->function_table;
1661 each_func;
1662 each_func = each_func->prev_func)
1663 {
1664 for (arange = &each_func->arange;
1665 arange;
1666 arange = arange->next)
1667 {
1668 if ((!each_func->sec || each_func->sec == sec)
1669 && addr >= arange->low
1670 && addr < arange->high
1671 && each_func->name
1672 && strcmp (name, each_func->name) == 0
1673 && (!best_fit
1674 || ((arange->high - arange->low)
1675 < (best_fit->arange.high - best_fit->arange.low))))
1676 best_fit = each_func;
1677 }
1678 }
1679
1680 if (best_fit)
1681 {
1682 best_fit->sec = sec;
1683 *filename_ptr = best_fit->file;
1684 *linenumber_ptr = best_fit->line;
1685 return TRUE;
1686 }
1687 else
1688 return FALSE;
1689 }
1690
1691 /* Variable table functions. */
1692
1693 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1694 LINENUMBER_PTR, and return TRUE. */
1695
1696 static bfd_boolean
1697 lookup_symbol_in_variable_table (struct comp_unit *unit,
1698 asymbol *sym,
1699 bfd_vma addr,
1700 const char **filename_ptr,
1701 unsigned int *linenumber_ptr)
1702 {
1703 const char *name = bfd_asymbol_name (sym);
1704 asection *sec = bfd_get_section (sym);
1705 struct varinfo* each;
1706
1707 for (each = unit->variable_table; each; each = each->prev_var)
1708 if (each->stack == 0
1709 && each->file != NULL
1710 && each->name != NULL
1711 && each->addr == addr
1712 && (!each->sec || each->sec == sec)
1713 && strcmp (name, each->name) == 0)
1714 break;
1715
1716 if (each)
1717 {
1718 each->sec = sec;
1719 *filename_ptr = each->file;
1720 *linenumber_ptr = each->line;
1721 return TRUE;
1722 }
1723 else
1724 return FALSE;
1725 }
1726
1727 static char *
1728 find_abstract_instance_name (struct comp_unit *unit,
1729 struct attribute *attr_ptr)
1730 {
1731 bfd *abfd = unit->abfd;
1732 bfd_byte *info_ptr;
1733 unsigned int abbrev_number, bytes_read, i;
1734 struct abbrev_info *abbrev;
1735 bfd_uint64_t die_ref = attr_ptr->u.val;
1736 struct attribute attr;
1737 char *name = 0;
1738
1739 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1740 is an offset from the .debug_info section, not the current CU. */
1741 if (attr_ptr->form == DW_FORM_ref_addr)
1742 {
1743 /* We only support DW_FORM_ref_addr within the same file, so
1744 any relocations should be resolved already. */
1745 if (!die_ref)
1746 abort ();
1747
1748 info_ptr = unit->stash->sec_info_ptr + die_ref;
1749 }
1750 else
1751 info_ptr = unit->info_ptr_unit + die_ref;
1752 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1753 info_ptr += bytes_read;
1754
1755 if (abbrev_number)
1756 {
1757 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1758 if (! abbrev)
1759 {
1760 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1761 abbrev_number);
1762 bfd_set_error (bfd_error_bad_value);
1763 }
1764 else
1765 {
1766 for (i = 0; i < abbrev->num_attrs; ++i)
1767 {
1768 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1769 switch (attr.name)
1770 {
1771 case DW_AT_name:
1772 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1773 if (name == NULL)
1774 name = attr.u.str;
1775 break;
1776 case DW_AT_specification:
1777 name = find_abstract_instance_name (unit, &attr);
1778 break;
1779 case DW_AT_MIPS_linkage_name:
1780 name = attr.u.str;
1781 break;
1782 default:
1783 break;
1784 }
1785 }
1786 }
1787 }
1788 return (name);
1789 }
1790
1791 static void
1792 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1793 {
1794 bfd_byte *ranges_ptr;
1795 bfd_vma base_address = unit->base_address;
1796
1797 if (! unit->stash->dwarf_ranges_buffer)
1798 {
1799 if (! read_debug_ranges (unit))
1800 return;
1801 }
1802 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1803
1804 for (;;)
1805 {
1806 bfd_vma low_pc;
1807 bfd_vma high_pc;
1808
1809 low_pc = read_address (unit, ranges_ptr);
1810 ranges_ptr += unit->addr_size;
1811 high_pc = read_address (unit, ranges_ptr);
1812 ranges_ptr += unit->addr_size;
1813
1814 if (low_pc == 0 && high_pc == 0)
1815 break;
1816 if (low_pc == -1UL && high_pc != -1UL)
1817 base_address = high_pc;
1818 else
1819 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1820 }
1821 }
1822
1823 /* DWARF2 Compilation unit functions. */
1824
1825 /* Scan over each die in a comp. unit looking for functions to add
1826 to the function table and variables to the variable table. */
1827
1828 static bfd_boolean
1829 scan_unit_for_symbols (struct comp_unit *unit)
1830 {
1831 bfd *abfd = unit->abfd;
1832 bfd_byte *info_ptr = unit->first_child_die_ptr;
1833 int nesting_level = 1;
1834 struct funcinfo **nested_funcs;
1835 int nested_funcs_size;
1836
1837 /* Maintain a stack of in-scope functions and inlined functions, which we
1838 can use to set the caller_func field. */
1839 nested_funcs_size = 32;
1840 nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
1841 if (nested_funcs == NULL)
1842 return FALSE;
1843 nested_funcs[nesting_level] = 0;
1844
1845 while (nesting_level)
1846 {
1847 unsigned int abbrev_number, bytes_read, i;
1848 struct abbrev_info *abbrev;
1849 struct attribute attr;
1850 struct funcinfo *func;
1851 struct varinfo *var;
1852 bfd_vma low_pc = 0;
1853 bfd_vma high_pc = 0;
1854
1855 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1856 info_ptr += bytes_read;
1857
1858 if (! abbrev_number)
1859 {
1860 nesting_level--;
1861 continue;
1862 }
1863
1864 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1865 if (! abbrev)
1866 {
1867 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1868 abbrev_number);
1869 bfd_set_error (bfd_error_bad_value);
1870 free (nested_funcs);
1871 return FALSE;
1872 }
1873
1874 var = NULL;
1875 if (abbrev->tag == DW_TAG_subprogram
1876 || abbrev->tag == DW_TAG_entry_point
1877 || abbrev->tag == DW_TAG_inlined_subroutine)
1878 {
1879 bfd_size_type amt = sizeof (struct funcinfo);
1880 func = bfd_zalloc (abfd, amt);
1881 func->tag = abbrev->tag;
1882 func->prev_func = unit->function_table;
1883 unit->function_table = func;
1884 BFD_ASSERT (!unit->cached);
1885
1886 if (func->tag == DW_TAG_inlined_subroutine)
1887 for (i = nesting_level - 1; i >= 1; i--)
1888 if (nested_funcs[i])
1889 {
1890 func->caller_func = nested_funcs[i];
1891 break;
1892 }
1893 nested_funcs[nesting_level] = func;
1894 }
1895 else
1896 {
1897 func = NULL;
1898 if (abbrev->tag == DW_TAG_variable)
1899 {
1900 bfd_size_type amt = sizeof (struct varinfo);
1901 var = bfd_zalloc (abfd, amt);
1902 var->tag = abbrev->tag;
1903 var->stack = 1;
1904 var->prev_var = unit->variable_table;
1905 unit->variable_table = var;
1906 BFD_ASSERT (!unit->cached);
1907 }
1908
1909 /* No inline function in scope at this nesting level. */
1910 nested_funcs[nesting_level] = 0;
1911 }
1912
1913 for (i = 0; i < abbrev->num_attrs; ++i)
1914 {
1915 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1916
1917 if (func)
1918 {
1919 switch (attr.name)
1920 {
1921 case DW_AT_call_file:
1922 func->caller_file = concat_filename (unit->line_table, attr.u.val);
1923 break;
1924
1925 case DW_AT_call_line:
1926 func->caller_line = attr.u.val;
1927 break;
1928
1929 case DW_AT_abstract_origin:
1930 func->name = find_abstract_instance_name (unit, &attr);
1931 break;
1932
1933 case DW_AT_name:
1934 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1935 if (func->name == NULL)
1936 func->name = attr.u.str;
1937 break;
1938
1939 case DW_AT_MIPS_linkage_name:
1940 func->name = attr.u.str;
1941 break;
1942
1943 case DW_AT_low_pc:
1944 low_pc = attr.u.val;
1945 break;
1946
1947 case DW_AT_high_pc:
1948 high_pc = attr.u.val;
1949 break;
1950
1951 case DW_AT_ranges:
1952 read_rangelist (unit, &func->arange, attr.u.val);
1953 break;
1954
1955 case DW_AT_decl_file:
1956 func->file = concat_filename (unit->line_table,
1957 attr.u.val);
1958 break;
1959
1960 case DW_AT_decl_line:
1961 func->line = attr.u.val;
1962 break;
1963
1964 default:
1965 break;
1966 }
1967 }
1968 else if (var)
1969 {
1970 switch (attr.name)
1971 {
1972 case DW_AT_name:
1973 var->name = attr.u.str;
1974 break;
1975
1976 case DW_AT_decl_file:
1977 var->file = concat_filename (unit->line_table,
1978 attr.u.val);
1979 break;
1980
1981 case DW_AT_decl_line:
1982 var->line = attr.u.val;
1983 break;
1984
1985 case DW_AT_external:
1986 if (attr.u.val != 0)
1987 var->stack = 0;
1988 break;
1989
1990 case DW_AT_location:
1991 switch (attr.form)
1992 {
1993 case DW_FORM_block:
1994 case DW_FORM_block1:
1995 case DW_FORM_block2:
1996 case DW_FORM_block4:
1997 if (*attr.u.blk->data == DW_OP_addr)
1998 {
1999 var->stack = 0;
2000
2001 /* Verify that DW_OP_addr is the only opcode in the
2002 location, in which case the block size will be 1
2003 plus the address size. */
2004 /* ??? For TLS variables, gcc can emit
2005 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2006 which we don't handle here yet. */
2007 if (attr.u.blk->size == unit->addr_size + 1U)
2008 var->addr = bfd_get (unit->addr_size * 8,
2009 unit->abfd,
2010 attr.u.blk->data + 1);
2011 }
2012 break;
2013
2014 default:
2015 break;
2016 }
2017 break;
2018
2019 default:
2020 break;
2021 }
2022 }
2023 }
2024
2025 if (func && high_pc != 0)
2026 {
2027 arange_add (unit->abfd, &func->arange, low_pc, high_pc);
2028 }
2029
2030 if (abbrev->has_children)
2031 {
2032 nesting_level++;
2033
2034 if (nesting_level >= nested_funcs_size)
2035 {
2036 struct funcinfo **tmp;
2037
2038 nested_funcs_size *= 2;
2039 tmp = bfd_realloc (nested_funcs,
2040 (nested_funcs_size
2041 * sizeof (struct funcinfo *)));
2042 if (tmp == NULL)
2043 {
2044 free (nested_funcs);
2045 return FALSE;
2046 }
2047 nested_funcs = tmp;
2048 }
2049 nested_funcs[nesting_level] = 0;
2050 }
2051 }
2052
2053 free (nested_funcs);
2054 return TRUE;
2055 }
2056
2057 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2058 includes the compilation unit header that proceeds the DIE's, but
2059 does not include the length field that precedes each compilation
2060 unit header. END_PTR points one past the end of this comp unit.
2061 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2062
2063 This routine does not read the whole compilation unit; only enough
2064 to get to the line number information for the compilation unit. */
2065
2066 static struct comp_unit *
2067 parse_comp_unit (struct dwarf2_debug *stash,
2068 bfd_vma unit_length,
2069 bfd_byte *info_ptr_unit,
2070 unsigned int offset_size)
2071 {
2072 struct comp_unit* unit;
2073 unsigned int version;
2074 bfd_uint64_t abbrev_offset = 0;
2075 unsigned int addr_size;
2076 struct abbrev_info** abbrevs;
2077 unsigned int abbrev_number, bytes_read, i;
2078 struct abbrev_info *abbrev;
2079 struct attribute attr;
2080 bfd_byte *info_ptr = stash->info_ptr;
2081 bfd_byte *end_ptr = info_ptr + unit_length;
2082 bfd_size_type amt;
2083 bfd_vma low_pc = 0;
2084 bfd_vma high_pc = 0;
2085 bfd *abfd = stash->bfd;
2086
2087 version = read_2_bytes (abfd, info_ptr);
2088 info_ptr += 2;
2089 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2090 if (offset_size == 4)
2091 abbrev_offset = read_4_bytes (abfd, info_ptr);
2092 else
2093 abbrev_offset = read_8_bytes (abfd, info_ptr);
2094 info_ptr += offset_size;
2095 addr_size = read_1_byte (abfd, info_ptr);
2096 info_ptr += 1;
2097
2098 if (version != 2 && version != 3)
2099 {
2100 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version);
2101 bfd_set_error (bfd_error_bad_value);
2102 return 0;
2103 }
2104
2105 if (addr_size > sizeof (bfd_vma))
2106 {
2107 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2108 addr_size,
2109 (unsigned int) sizeof (bfd_vma));
2110 bfd_set_error (bfd_error_bad_value);
2111 return 0;
2112 }
2113
2114 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2115 {
2116 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
2117 bfd_set_error (bfd_error_bad_value);
2118 return 0;
2119 }
2120
2121 /* Read the abbrevs for this compilation unit into a table. */
2122 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2123 if (! abbrevs)
2124 return 0;
2125
2126 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2127 info_ptr += bytes_read;
2128 if (! abbrev_number)
2129 {
2130 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2131 abbrev_number);
2132 bfd_set_error (bfd_error_bad_value);
2133 return 0;
2134 }
2135
2136 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2137 if (! abbrev)
2138 {
2139 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2140 abbrev_number);
2141 bfd_set_error (bfd_error_bad_value);
2142 return 0;
2143 }
2144
2145 amt = sizeof (struct comp_unit);
2146 unit = bfd_zalloc (abfd, amt);
2147 unit->abfd = abfd;
2148 unit->version = version;
2149 unit->addr_size = addr_size;
2150 unit->offset_size = offset_size;
2151 unit->abbrevs = abbrevs;
2152 unit->end_ptr = end_ptr;
2153 unit->stash = stash;
2154 unit->info_ptr_unit = info_ptr_unit;
2155
2156 for (i = 0; i < abbrev->num_attrs; ++i)
2157 {
2158 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2159
2160 /* Store the data if it is of an attribute we want to keep in a
2161 partial symbol table. */
2162 switch (attr.name)
2163 {
2164 case DW_AT_stmt_list:
2165 unit->stmtlist = 1;
2166 unit->line_offset = attr.u.val;
2167 break;
2168
2169 case DW_AT_name:
2170 unit->name = attr.u.str;
2171 break;
2172
2173 case DW_AT_low_pc:
2174 low_pc = attr.u.val;
2175 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2176 this is the base address to use when reading location
2177 lists or range lists. */
2178 unit->base_address = low_pc;
2179 break;
2180
2181 case DW_AT_high_pc:
2182 high_pc = attr.u.val;
2183 break;
2184
2185 case DW_AT_ranges:
2186 read_rangelist (unit, &unit->arange, attr.u.val);
2187 break;
2188
2189 case DW_AT_comp_dir:
2190 {
2191 char *comp_dir = attr.u.str;
2192 if (comp_dir)
2193 {
2194 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2195 directory, get rid of it. */
2196 char *cp = strchr (comp_dir, ':');
2197
2198 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2199 comp_dir = cp + 1;
2200 }
2201 unit->comp_dir = comp_dir;
2202 break;
2203 }
2204
2205 default:
2206 break;
2207 }
2208 }
2209 if (high_pc != 0)
2210 {
2211 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
2212 }
2213
2214 unit->first_child_die_ptr = info_ptr;
2215 return unit;
2216 }
2217
2218 /* Return TRUE if UNIT may contain the address given by ADDR. When
2219 there are functions written entirely with inline asm statements, the
2220 range info in the compilation unit header may not be correct. We
2221 need to consult the line info table to see if a compilation unit
2222 really contains the given address. */
2223
2224 static bfd_boolean
2225 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2226 {
2227 struct arange *arange;
2228
2229 if (unit->error)
2230 return FALSE;
2231
2232 arange = &unit->arange;
2233 do
2234 {
2235 if (addr >= arange->low && addr < arange->high)
2236 return TRUE;
2237 arange = arange->next;
2238 }
2239 while (arange);
2240
2241 return FALSE;
2242 }
2243
2244 /* If UNIT contains ADDR, set the output parameters to the values for
2245 the line containing ADDR. The output parameters, FILENAME_PTR,
2246 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2247 to be filled in.
2248
2249 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2250 FALSE otherwise. */
2251
2252 static bfd_boolean
2253 comp_unit_find_nearest_line (struct comp_unit *unit,
2254 bfd_vma addr,
2255 const char **filename_ptr,
2256 const char **functionname_ptr,
2257 unsigned int *linenumber_ptr,
2258 struct dwarf2_debug *stash)
2259 {
2260 bfd_boolean line_p;
2261 bfd_boolean func_p;
2262 struct funcinfo *function;
2263
2264 if (unit->error)
2265 return FALSE;
2266
2267 if (! unit->line_table)
2268 {
2269 if (! unit->stmtlist)
2270 {
2271 unit->error = 1;
2272 return FALSE;
2273 }
2274
2275 unit->line_table = decode_line_info (unit, stash);
2276
2277 if (! unit->line_table)
2278 {
2279 unit->error = 1;
2280 return FALSE;
2281 }
2282
2283 if (unit->first_child_die_ptr < unit->end_ptr
2284 && ! scan_unit_for_symbols (unit))
2285 {
2286 unit->error = 1;
2287 return FALSE;
2288 }
2289 }
2290
2291 function = NULL;
2292 func_p = lookup_address_in_function_table (unit, addr,
2293 &function, functionname_ptr);
2294 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2295 stash->inliner_chain = function;
2296 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2297 function, filename_ptr,
2298 linenumber_ptr);
2299 return line_p || func_p;
2300 }
2301
2302 /* Check to see if line info is already decoded in a comp_unit.
2303 If not, decode it. Returns TRUE if no errors were encountered;
2304 FALSE otherwise. */
2305
2306 static bfd_boolean
2307 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2308 struct dwarf2_debug *stash)
2309 {
2310 if (unit->error)
2311 return FALSE;
2312
2313 if (! unit->line_table)
2314 {
2315 if (! unit->stmtlist)
2316 {
2317 unit->error = 1;
2318 return FALSE;
2319 }
2320
2321 unit->line_table = decode_line_info (unit, stash);
2322
2323 if (! unit->line_table)
2324 {
2325 unit->error = 1;
2326 return FALSE;
2327 }
2328
2329 if (unit->first_child_die_ptr < unit->end_ptr
2330 && ! scan_unit_for_symbols (unit))
2331 {
2332 unit->error = 1;
2333 return FALSE;
2334 }
2335 }
2336
2337 return TRUE;
2338 }
2339
2340 /* If UNIT contains SYM at ADDR, set the output parameters to the
2341 values for the line containing SYM. The output parameters,
2342 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2343 filled in.
2344
2345 Return TRUE if UNIT contains SYM, and no errors were encountered;
2346 FALSE otherwise. */
2347
2348 static bfd_boolean
2349 comp_unit_find_line (struct comp_unit *unit,
2350 asymbol *sym,
2351 bfd_vma addr,
2352 const char **filename_ptr,
2353 unsigned int *linenumber_ptr,
2354 struct dwarf2_debug *stash)
2355 {
2356 if (!comp_unit_maybe_decode_line_info (unit, stash))
2357 return FALSE;
2358
2359 if (sym->flags & BSF_FUNCTION)
2360 return lookup_symbol_in_function_table (unit, sym, addr,
2361 filename_ptr,
2362 linenumber_ptr);
2363
2364 return lookup_symbol_in_variable_table (unit, sym, addr,
2365 filename_ptr,
2366 linenumber_ptr);
2367 }
2368
2369 static struct funcinfo *
2370 reverse_funcinfo_list (struct funcinfo *head)
2371 {
2372 struct funcinfo *rhead;
2373 struct funcinfo *temp;
2374
2375 for (rhead = NULL; head; head = temp)
2376 {
2377 temp = head->prev_func;
2378 head->prev_func = rhead;
2379 rhead = head;
2380 }
2381 return rhead;
2382 }
2383
2384 static struct varinfo *
2385 reverse_varinfo_list (struct varinfo *head)
2386 {
2387 struct varinfo *rhead;
2388 struct varinfo *temp;
2389
2390 for (rhead = NULL; head; head = temp)
2391 {
2392 temp = head->prev_var;
2393 head->prev_var = rhead;
2394 rhead = head;
2395 }
2396 return rhead;
2397 }
2398
2399 /* Extract all interesting funcinfos and varinfos of a compilation
2400 unit into hash tables for faster lookup. Returns TRUE if no
2401 errors were enountered; FALSE otherwise. */
2402
2403 static bfd_boolean
2404 comp_unit_hash_info (struct dwarf2_debug *stash,
2405 struct comp_unit *unit,
2406 struct info_hash_table *funcinfo_hash_table,
2407 struct info_hash_table *varinfo_hash_table)
2408 {
2409 struct funcinfo* each_func;
2410 struct varinfo* each_var;
2411 bfd_boolean okay = TRUE;
2412
2413 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2414
2415 if (!comp_unit_maybe_decode_line_info (unit, stash))
2416 return FALSE;
2417
2418 BFD_ASSERT (!unit->cached);
2419
2420 /* To preserve the original search order, we went to visit the function
2421 infos in the reversed order of the list. However, making the list
2422 bi-directional use quite a bit of extra memory. So we reverse
2423 the list first, traverse the list in the now reversed order and
2424 finally reverse the list again to get back the original order. */
2425 unit->function_table = reverse_funcinfo_list (unit->function_table);
2426 for (each_func = unit->function_table;
2427 each_func && okay;
2428 each_func = each_func->prev_func)
2429 {
2430 /* Skip nameless functions. */
2431 if (each_func->name)
2432 /* There is no need to copy name string into hash table as
2433 name string is either in the dwarf string buffer or
2434 info in the stash. */
2435 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2436 (void*) each_func, FALSE);
2437 }
2438 unit->function_table = reverse_funcinfo_list (unit->function_table);
2439 if (!okay)
2440 return FALSE;
2441
2442 /* We do the same for variable infos. */
2443 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2444 for (each_var = unit->variable_table;
2445 each_var && okay;
2446 each_var = each_var->prev_var)
2447 {
2448 /* Skip stack vars and vars with no files or names. */
2449 if (each_var->stack == 0
2450 && each_var->file != NULL
2451 && each_var->name != NULL)
2452 /* There is no need to copy name string into hash table as
2453 name string is either in the dwarf string buffer or
2454 info in the stash. */
2455 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2456 (void*) each_var, FALSE);
2457 }
2458
2459 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2460 unit->cached = TRUE;
2461 return okay;
2462 }
2463
2464 /* Locate a section in a BFD containing debugging info. The search starts
2465 from the section after AFTER_SEC, or from the first section in the BFD if
2466 AFTER_SEC is NULL. The search works by examining the names of the
2467 sections. There are two permissiable names. The first is .debug_info.
2468 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2469 This is a variation on the .debug_info section which has a checksum
2470 describing the contents appended onto the name. This allows the linker to
2471 identify and discard duplicate debugging sections for different
2472 compilation units. */
2473 #define DWARF2_DEBUG_INFO ".debug_info"
2474 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2475 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2476
2477 static asection *
2478 find_debug_info (bfd *abfd, asection *after_sec)
2479 {
2480 asection * msec;
2481
2482 msec = after_sec != NULL ? after_sec->next : abfd->sections;
2483
2484 while (msec)
2485 {
2486 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2487 return msec;
2488
2489 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2490 return msec;
2491
2492 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2493 return msec;
2494
2495 msec = msec->next;
2496 }
2497
2498 return NULL;
2499 }
2500
2501 /* Unset vmas for adjusted sections in STASH. */
2502
2503 static void
2504 unset_sections (struct dwarf2_debug *stash)
2505 {
2506 unsigned int i;
2507 struct adjusted_section *p;
2508
2509 i = stash->adjusted_section_count;
2510 p = stash->adjusted_sections;
2511 for (; i > 0; i--, p++)
2512 p->section->vma = 0;
2513 }
2514
2515 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2516 VMAs in STASH for unset_sections. */
2517
2518 static bfd_boolean
2519 place_sections (bfd *abfd, struct dwarf2_debug *stash)
2520 {
2521 struct adjusted_section *p;
2522 unsigned int i;
2523
2524 if (stash->adjusted_section_count != 0)
2525 {
2526 i = stash->adjusted_section_count;
2527 p = stash->adjusted_sections;
2528 for (; i > 0; i--, p++)
2529 p->section->vma = p->adj_vma;
2530 }
2531 else
2532 {
2533 asection *sect;
2534 bfd_vma last_vma = 0, last_dwarf = 0;
2535 bfd_size_type amt;
2536 struct adjusted_section *p;
2537
2538 i = 0;
2539 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2540 {
2541 bfd_size_type sz;
2542 int is_debug_info;
2543
2544 if (sect->vma != 0)
2545 continue;
2546
2547 /* We need to adjust the VMAs of any .debug_info sections.
2548 Skip compressed ones, since no relocations could target
2549 them - they should not appear in object files anyway. */
2550 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2551 is_debug_info = 1;
2552 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2553 is_debug_info = 1;
2554 else
2555 is_debug_info = 0;
2556
2557 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2558 continue;
2559
2560 sz = sect->rawsize ? sect->rawsize : sect->size;
2561 if (sz == 0)
2562 continue;
2563
2564 i++;
2565 }
2566
2567 amt = i * sizeof (struct adjusted_section);
2568 p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
2569 if (! p)
2570 return FALSE;
2571
2572 stash->adjusted_sections = p;
2573 stash->adjusted_section_count = i;
2574
2575 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2576 {
2577 bfd_size_type sz;
2578 int is_debug_info;
2579
2580 if (sect->vma != 0)
2581 continue;
2582
2583 /* We need to adjust the VMAs of any .debug_info sections.
2584 Skip compressed ones, since no relocations could target
2585 them - they should not appear in object files anyway. */
2586 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2587 is_debug_info = 1;
2588 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2589 is_debug_info = 1;
2590 else
2591 is_debug_info = 0;
2592
2593 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2594 continue;
2595
2596 sz = sect->rawsize ? sect->rawsize : sect->size;
2597 if (sz == 0)
2598 continue;
2599
2600 p->section = sect;
2601 if (is_debug_info)
2602 {
2603 BFD_ASSERT (sect->alignment_power == 0);
2604 sect->vma = last_dwarf;
2605 last_dwarf += sz;
2606 }
2607 else if (last_vma != 0)
2608 {
2609 /* Align the new address to the current section
2610 alignment. */
2611 last_vma = ((last_vma
2612 + ~((bfd_vma) -1 << sect->alignment_power))
2613 & ((bfd_vma) -1 << sect->alignment_power));
2614 sect->vma = last_vma;
2615 last_vma += sect->vma + sz;
2616 }
2617 else
2618 last_vma += sect->vma + sz;
2619
2620 p->adj_vma = sect->vma;
2621
2622 p++;
2623 }
2624 }
2625
2626 return TRUE;
2627 }
2628
2629 /* Look up a funcinfo by name using the given info hash table. If found,
2630 also update the locations pointed to by filename_ptr and linenumber_ptr.
2631
2632 This function returns TRUE if a funcinfo that matches the given symbol
2633 and address is found with any error; otherwise it returns FALSE. */
2634
2635 static bfd_boolean
2636 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
2637 asymbol *sym,
2638 bfd_vma addr,
2639 const char **filename_ptr,
2640 unsigned int *linenumber_ptr)
2641 {
2642 struct funcinfo* each_func;
2643 struct funcinfo* best_fit = NULL;
2644 struct info_list_node *node;
2645 struct arange *arange;
2646 const char *name = bfd_asymbol_name (sym);
2647 asection *sec = bfd_get_section (sym);
2648
2649 for (node = lookup_info_hash_table (hash_table, name);
2650 node;
2651 node = node->next)
2652 {
2653 each_func = node->info;
2654 for (arange = &each_func->arange;
2655 arange;
2656 arange = arange->next)
2657 {
2658 if ((!each_func->sec || each_func->sec == sec)
2659 && addr >= arange->low
2660 && addr < arange->high
2661 && (!best_fit
2662 || ((arange->high - arange->low)
2663 < (best_fit->arange.high - best_fit->arange.low))))
2664 best_fit = each_func;
2665 }
2666 }
2667
2668 if (best_fit)
2669 {
2670 best_fit->sec = sec;
2671 *filename_ptr = best_fit->file;
2672 *linenumber_ptr = best_fit->line;
2673 return TRUE;
2674 }
2675
2676 return FALSE;
2677 }
2678
2679 /* Look up a varinfo by name using the given info hash table. If found,
2680 also update the locations pointed to by filename_ptr and linenumber_ptr.
2681
2682 This function returns TRUE if a varinfo that matches the given symbol
2683 and address is found with any error; otherwise it returns FALSE. */
2684
2685 static bfd_boolean
2686 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
2687 asymbol *sym,
2688 bfd_vma addr,
2689 const char **filename_ptr,
2690 unsigned int *linenumber_ptr)
2691 {
2692 const char *name = bfd_asymbol_name (sym);
2693 asection *sec = bfd_get_section (sym);
2694 struct varinfo* each;
2695 struct info_list_node *node;
2696
2697 for (node = lookup_info_hash_table (hash_table, name);
2698 node;
2699 node = node->next)
2700 {
2701 each = node->info;
2702 if (each->addr == addr
2703 && (!each->sec || each->sec == sec))
2704 {
2705 each->sec = sec;
2706 *filename_ptr = each->file;
2707 *linenumber_ptr = each->line;
2708 return TRUE;
2709 }
2710 }
2711
2712 return FALSE;
2713 }
2714
2715 /* Update the funcinfo and varinfo info hash tables if they are
2716 not up to date. Returns TRUE if there is no error; otherwise
2717 returns FALSE and disable the info hash tables. */
2718
2719 static bfd_boolean
2720 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
2721 {
2722 struct comp_unit *each;
2723
2724 /* Exit if hash tables are up-to-date. */
2725 if (stash->all_comp_units == stash->hash_units_head)
2726 return TRUE;
2727
2728 if (stash->hash_units_head)
2729 each = stash->hash_units_head->prev_unit;
2730 else
2731 each = stash->last_comp_unit;
2732
2733 while (each)
2734 {
2735 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
2736 stash->varinfo_hash_table))
2737 {
2738 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
2739 return FALSE;
2740 }
2741 each = each->prev_unit;
2742 }
2743
2744 stash->hash_units_head = stash->all_comp_units;
2745 return TRUE;
2746 }
2747
2748 /* Check consistency of info hash tables. This is for debugging only. */
2749
2750 static void ATTRIBUTE_UNUSED
2751 stash_verify_info_hash_table (struct dwarf2_debug *stash)
2752 {
2753 struct comp_unit *each_unit;
2754 struct funcinfo *each_func;
2755 struct varinfo *each_var;
2756 struct info_list_node *node;
2757 bfd_boolean found;
2758
2759 for (each_unit = stash->all_comp_units;
2760 each_unit;
2761 each_unit = each_unit->next_unit)
2762 {
2763 for (each_func = each_unit->function_table;
2764 each_func;
2765 each_func = each_func->prev_func)
2766 {
2767 if (!each_func->name)
2768 continue;
2769 node = lookup_info_hash_table (stash->funcinfo_hash_table,
2770 each_func->name);
2771 BFD_ASSERT (node);
2772 found = FALSE;
2773 while (node && !found)
2774 {
2775 found = node->info == each_func;
2776 node = node->next;
2777 }
2778 BFD_ASSERT (found);
2779 }
2780
2781 for (each_var = each_unit->variable_table;
2782 each_var;
2783 each_var = each_var->prev_var)
2784 {
2785 if (!each_var->name || !each_var->file || each_var->stack)
2786 continue;
2787 node = lookup_info_hash_table (stash->varinfo_hash_table,
2788 each_var->name);
2789 BFD_ASSERT (node);
2790 found = FALSE;
2791 while (node && !found)
2792 {
2793 found = node->info == each_var;
2794 node = node->next;
2795 }
2796 BFD_ASSERT (found);
2797 }
2798 }
2799 }
2800
2801 /* Check to see if we want to enable the info hash tables, which consume
2802 quite a bit of memory. Currently we only check the number times
2803 bfd_dwarf2_find_line is called. In the future, we may also want to
2804 take the number of symbols into account. */
2805
2806 static void
2807 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
2808 {
2809 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
2810
2811 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
2812 return;
2813
2814 /* FIXME: Maybe we should check the reduce_memory_overheads
2815 and optimize fields in the bfd_link_info structure ? */
2816
2817 /* Create hash tables. */
2818 stash->funcinfo_hash_table = create_info_hash_table (abfd);
2819 stash->varinfo_hash_table = create_info_hash_table (abfd);
2820 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
2821 {
2822 /* Turn off info hashes if any allocation above fails. */
2823 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
2824 return;
2825 }
2826 /* We need a forced update so that the info hash tables will
2827 be created even though there is no compilation unit. That
2828 happens if STASH_INFO_HASH_TRIGGER is 0. */
2829 stash_maybe_update_info_hash_tables (stash);
2830 stash->info_hash_status = STASH_INFO_HASH_ON;
2831 }
2832
2833 /* Find the file and line associated with a symbol and address using the
2834 info hash tables of a stash. If there is a match, the function returns
2835 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
2836 otherwise it returns FALSE. */
2837
2838 static bfd_boolean
2839 stash_find_line_fast (struct dwarf2_debug *stash,
2840 asymbol *sym,
2841 bfd_vma addr,
2842 const char **filename_ptr,
2843 unsigned int *linenumber_ptr)
2844 {
2845 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
2846
2847 if (sym->flags & BSF_FUNCTION)
2848 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
2849 filename_ptr, linenumber_ptr);
2850 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
2851 filename_ptr, linenumber_ptr);
2852 }
2853
2854 /* Find the source code location of SYMBOL. If SYMBOL is NULL
2855 then find the nearest source code location corresponding to
2856 the address SECTION + OFFSET.
2857 Returns TRUE if the line is found without error and fills in
2858 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
2859 NULL the FUNCTIONNAME_PTR is also filled in.
2860 SYMBOLS contains the symbol table for ABFD.
2861 ADDR_SIZE is the number of bytes in the initial .debug_info length
2862 field and in the abbreviation offset, or zero to indicate that the
2863 default value should be used. */
2864
2865 static bfd_boolean
2866 find_line (bfd *abfd,
2867 asection *section,
2868 bfd_vma offset,
2869 asymbol *symbol,
2870 asymbol **symbols,
2871 const char **filename_ptr,
2872 const char **functionname_ptr,
2873 unsigned int *linenumber_ptr,
2874 unsigned int addr_size,
2875 void **pinfo)
2876 {
2877 /* Read each compilation unit from the section .debug_info, and check
2878 to see if it contains the address we are searching for. If yes,
2879 lookup the address, and return the line number info. If no, go
2880 on to the next compilation unit.
2881
2882 We keep a list of all the previously read compilation units, and
2883 a pointer to the next un-read compilation unit. Check the
2884 previously read units before reading more. */
2885 struct dwarf2_debug *stash;
2886 /* What address are we looking for? */
2887 bfd_vma addr;
2888 struct comp_unit* each;
2889 bfd_vma found = FALSE;
2890 bfd_boolean do_line;
2891
2892 stash = *pinfo;
2893
2894 if (! stash)
2895 {
2896 bfd_size_type amt = sizeof (struct dwarf2_debug);
2897
2898 stash = bfd_zalloc (abfd, amt);
2899 if (! stash)
2900 return FALSE;
2901 }
2902
2903 /* In a relocatable file, 2 functions may have the same address.
2904 We change the section vma so that they won't overlap. */
2905 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2906 {
2907 if (! place_sections (abfd, stash))
2908 return FALSE;
2909 }
2910
2911 do_line = (section == NULL
2912 && offset == 0
2913 && functionname_ptr == NULL
2914 && symbol != NULL);
2915 if (do_line)
2916 {
2917 addr = symbol->value;
2918 section = bfd_get_section (symbol);
2919 }
2920 else if (section != NULL
2921 && functionname_ptr != NULL
2922 && symbol == NULL)
2923 addr = offset;
2924 else
2925 abort ();
2926
2927 if (section->output_section)
2928 addr += section->output_section->vma + section->output_offset;
2929 else
2930 addr += section->vma;
2931 *filename_ptr = NULL;
2932 if (! do_line)
2933 *functionname_ptr = NULL;
2934 *linenumber_ptr = 0;
2935
2936 if (! *pinfo)
2937 {
2938 bfd *debug_bfd;
2939 bfd_size_type total_size;
2940 asection *msec;
2941
2942 *pinfo = stash;
2943
2944 msec = find_debug_info (abfd, NULL);
2945 if (msec == NULL)
2946 {
2947 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
2948
2949 if (debug_filename == NULL)
2950 /* No dwarf2 info, and no gnu_debuglink to follow.
2951 Note that at this point the stash has been allocated, but
2952 contains zeros. This lets future calls to this function
2953 fail more quickly. */
2954 goto done;
2955
2956 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
2957 || ! bfd_check_format (debug_bfd, bfd_object)
2958 || (msec = find_debug_info (debug_bfd, NULL)) == NULL)
2959 {
2960 if (debug_bfd)
2961 bfd_close (debug_bfd);
2962 /* FIXME: Should we report our failure to follow the debuglink ? */
2963 free (debug_filename);
2964 goto done;
2965 }
2966 }
2967 else
2968 debug_bfd = abfd;
2969
2970 /* There can be more than one DWARF2 info section in a BFD these
2971 days. First handle the easy case when there's only one. If
2972 there's more than one, try case two: none of the sections is
2973 compressed. In that case, read them all in and produce one
2974 large stash. We do this in two passes - in the first pass we
2975 just accumulate the section sizes, and in the second pass we
2976 read in the section's contents. (The allows us to avoid
2977 reallocing the data as we add sections to the stash.) If
2978 some or all sections are compressed, then do things the slow
2979 way, with a bunch of reallocs. */
2980
2981 if (! find_debug_info (debug_bfd, msec))
2982 {
2983 /* Case 1: only one info section. */
2984 total_size = msec->size;
2985 if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
2986 symbols, 0,
2987 &stash->info_ptr_memory, &total_size))
2988 goto done;
2989 }
2990 else
2991 {
2992 int all_uncompressed = 1;
2993 for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
2994 {
2995 total_size += msec->size;
2996 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2997 all_uncompressed = 0;
2998 }
2999 if (all_uncompressed)
3000 {
3001 /* Case 2: multiple sections, but none is compressed. */
3002 stash->info_ptr_memory = bfd_malloc (total_size);
3003 if (stash->info_ptr_memory == NULL)
3004 goto done;
3005
3006 total_size = 0;
3007 for (msec = find_debug_info (debug_bfd, NULL);
3008 msec;
3009 msec = find_debug_info (debug_bfd, msec))
3010 {
3011 bfd_size_type size;
3012
3013 size = msec->size;
3014 if (size == 0)
3015 continue;
3016
3017 if (!(bfd_simple_get_relocated_section_contents
3018 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3019 symbols)))
3020 goto done;
3021
3022 total_size += size;
3023 }
3024 }
3025 else
3026 {
3027 /* Case 3: multiple sections, some or all compressed. */
3028 stash->info_ptr_memory = NULL;
3029 total_size = 0;
3030 for (msec = find_debug_info (debug_bfd, NULL);
3031 msec;
3032 msec = find_debug_info (debug_bfd, msec))
3033 {
3034 bfd_size_type size = msec->size;
3035 bfd_byte* buffer;
3036
3037 if (size == 0)
3038 continue;
3039
3040 buffer = (bfd_simple_get_relocated_section_contents
3041 (debug_bfd, msec, NULL, symbols));
3042 if (! buffer)
3043 goto done;
3044
3045 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
3046 {
3047 if (! bfd_uncompress_section_contents (&buffer, &size))
3048 {
3049 free (buffer);
3050 goto done;
3051 }
3052 }
3053 stash->info_ptr_memory = bfd_realloc (stash->info_ptr_memory,
3054 total_size + size);
3055 memcpy (stash->info_ptr_memory + total_size, buffer, size);
3056 free (buffer);
3057 total_size += size;
3058 }
3059 }
3060 }
3061
3062 stash->info_ptr = stash->info_ptr_memory;
3063 stash->info_ptr_end = stash->info_ptr + total_size;
3064 stash->sec = find_debug_info (debug_bfd, NULL);
3065 stash->sec_info_ptr = stash->info_ptr;
3066 stash->syms = symbols;
3067 stash->bfd = debug_bfd;
3068 }
3069
3070 /* A null info_ptr indicates that there is no dwarf2 info
3071 (or that an error occured while setting up the stash). */
3072 if (! stash->info_ptr)
3073 goto done;
3074
3075 stash->inliner_chain = NULL;
3076
3077 /* Check the previously read comp. units first. */
3078 if (do_line)
3079 {
3080 /* The info hash tables use quite a bit of memory. We may not want to
3081 always use them. We use some heuristics to decide if and when to
3082 turn it on. */
3083 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3084 stash_maybe_enable_info_hash_tables (abfd, stash);
3085
3086 /* Keep info hash table up to date if they are available. Note that we
3087 may disable the hash tables if there is any error duing update. */
3088 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3089 stash_maybe_update_info_hash_tables (stash);
3090
3091 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3092 {
3093 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3094 linenumber_ptr);
3095 if (found)
3096 goto done;
3097 }
3098 else
3099 {
3100 /* Check the previously read comp. units first. */
3101 for (each = stash->all_comp_units; each; each = each->next_unit)
3102 if ((symbol->flags & BSF_FUNCTION) == 0
3103 || comp_unit_contains_address (each, addr))
3104 {
3105 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3106 linenumber_ptr, stash);
3107 if (found)
3108 goto done;
3109 }
3110 }
3111 }
3112 else
3113 {
3114 for (each = stash->all_comp_units; each; each = each->next_unit)
3115 {
3116 found = (comp_unit_contains_address (each, addr)
3117 && comp_unit_find_nearest_line (each, addr,
3118 filename_ptr,
3119 functionname_ptr,
3120 linenumber_ptr,
3121 stash));
3122 if (found)
3123 goto done;
3124 }
3125 }
3126
3127 /* The DWARF2 spec says that the initial length field, and the
3128 offset of the abbreviation table, should both be 4-byte values.
3129 However, some compilers do things differently. */
3130 if (addr_size == 0)
3131 addr_size = 4;
3132 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3133
3134 /* Read each remaining comp. units checking each as they are read. */
3135 while (stash->info_ptr < stash->info_ptr_end)
3136 {
3137 bfd_vma length;
3138 unsigned int offset_size = addr_size;
3139 bfd_byte *info_ptr_unit = stash->info_ptr;
3140
3141 length = read_4_bytes (stash->bfd, stash->info_ptr);
3142 /* A 0xffffff length is the DWARF3 way of indicating
3143 we use 64-bit offsets, instead of 32-bit offsets. */
3144 if (length == 0xffffffff)
3145 {
3146 offset_size = 8;
3147 length = read_8_bytes (stash->bfd, stash->info_ptr + 4);
3148 stash->info_ptr += 12;
3149 }
3150 /* A zero length is the IRIX way of indicating 64-bit offsets,
3151 mostly because the 64-bit length will generally fit in 32
3152 bits, and the endianness helps. */
3153 else if (length == 0)
3154 {
3155 offset_size = 8;
3156 length = read_4_bytes (stash->bfd, stash->info_ptr + 4);
3157 stash->info_ptr += 8;
3158 }
3159 /* In the absence of the hints above, we assume 32-bit DWARF2
3160 offsets even for targets with 64-bit addresses, because:
3161 a) most of the time these targets will not have generated
3162 more than 2Gb of debug info and so will not need 64-bit
3163 offsets,
3164 and
3165 b) if they do use 64-bit offsets but they are not using
3166 the size hints that are tested for above then they are
3167 not conforming to the DWARF3 standard anyway. */
3168 else if (addr_size == 8)
3169 {
3170 offset_size = 4;
3171 stash->info_ptr += 4;
3172 }
3173 else
3174 stash->info_ptr += 4;
3175
3176 if (length > 0)
3177 {
3178 each = parse_comp_unit (stash, length, info_ptr_unit,
3179 offset_size);
3180 if (!each)
3181 /* The dwarf information is damaged, don't trust it any
3182 more. */
3183 break;
3184 stash->info_ptr += length;
3185
3186 if (stash->all_comp_units)
3187 stash->all_comp_units->prev_unit = each;
3188 else
3189 stash->last_comp_unit = each;
3190
3191 each->next_unit = stash->all_comp_units;
3192 stash->all_comp_units = each;
3193
3194 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3195 compilation units. If we don't have them (i.e.,
3196 unit->high == 0), we need to consult the line info table
3197 to see if a compilation unit contains the given
3198 address. */
3199 if (do_line)
3200 found = (((symbol->flags & BSF_FUNCTION) == 0
3201 || each->arange.high == 0
3202 || comp_unit_contains_address (each, addr))
3203 && comp_unit_find_line (each, symbol, addr,
3204 filename_ptr,
3205 linenumber_ptr,
3206 stash));
3207 else
3208 found = ((each->arange.high == 0
3209 || comp_unit_contains_address (each, addr))
3210 && comp_unit_find_nearest_line (each, addr,
3211 filename_ptr,
3212 functionname_ptr,
3213 linenumber_ptr,
3214 stash));
3215
3216 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3217 == stash->sec->size)
3218 {
3219 stash->sec = find_debug_info (stash->bfd, stash->sec);
3220 stash->sec_info_ptr = stash->info_ptr;
3221 }
3222
3223 if (found)
3224 goto done;
3225 }
3226 }
3227
3228 done:
3229 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3230 unset_sections (stash);
3231
3232 return found;
3233 }
3234
3235 /* The DWARF2 version of find_nearest_line.
3236 Return TRUE if the line is found without error. */
3237
3238 bfd_boolean
3239 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3240 asection *section,
3241 asymbol **symbols,
3242 bfd_vma offset,
3243 const char **filename_ptr,
3244 const char **functionname_ptr,
3245 unsigned int *linenumber_ptr,
3246 unsigned int addr_size,
3247 void **pinfo)
3248 {
3249 return find_line (abfd, section, offset, NULL, symbols, filename_ptr,
3250 functionname_ptr, linenumber_ptr, addr_size,
3251 pinfo);
3252 }
3253
3254 /* The DWARF2 version of find_line.
3255 Return TRUE if the line is found without error. */
3256
3257 bfd_boolean
3258 _bfd_dwarf2_find_line (bfd *abfd,
3259 asymbol **symbols,
3260 asymbol *symbol,
3261 const char **filename_ptr,
3262 unsigned int *linenumber_ptr,
3263 unsigned int addr_size,
3264 void **pinfo)
3265 {
3266 return find_line (abfd, NULL, 0, symbol, symbols, filename_ptr,
3267 NULL, linenumber_ptr, addr_size,
3268 pinfo);
3269 }
3270
3271 bfd_boolean
3272 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3273 const char **filename_ptr,
3274 const char **functionname_ptr,
3275 unsigned int *linenumber_ptr,
3276 void **pinfo)
3277 {
3278 struct dwarf2_debug *stash;
3279
3280 stash = *pinfo;
3281 if (stash)
3282 {
3283 struct funcinfo *func = stash->inliner_chain;
3284
3285 if (func && func->caller_func)
3286 {
3287 *filename_ptr = func->caller_file;
3288 *functionname_ptr = func->caller_func->name;
3289 *linenumber_ptr = func->caller_line;
3290 stash->inliner_chain = func->caller_func;
3291 return TRUE;
3292 }
3293 }
3294
3295 return FALSE;
3296 }
3297
3298 void
3299 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
3300 {
3301 struct comp_unit *each;
3302 struct dwarf2_debug *stash;
3303
3304 if (abfd == NULL || elf_tdata (abfd) == NULL)
3305 return;
3306
3307 stash = elf_tdata (abfd)->dwarf2_find_line_info;
3308
3309 if (stash == NULL)
3310 return;
3311
3312 for (each = stash->all_comp_units; each; each = each->next_unit)
3313 {
3314 struct abbrev_info **abbrevs = each->abbrevs;
3315 struct funcinfo *function_table = each->function_table;
3316 struct varinfo *variable_table = each->variable_table;
3317 size_t i;
3318
3319 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3320 {
3321 struct abbrev_info *abbrev = abbrevs[i];
3322
3323 while (abbrev)
3324 {
3325 free (abbrev->attrs);
3326 abbrev = abbrev->next;
3327 }
3328 }
3329
3330 if (each->line_table)
3331 {
3332 free (each->line_table->dirs);
3333 free (each->line_table->files);
3334 }
3335
3336 while (function_table)
3337 {
3338 if (function_table->file)
3339 {
3340 free (function_table->file);
3341 function_table->file = NULL;
3342 }
3343
3344 if (function_table->caller_file)
3345 {
3346 free (function_table->caller_file);
3347 function_table->caller_file = NULL;
3348 }
3349 function_table = function_table->prev_func;
3350 }
3351
3352 while (variable_table)
3353 {
3354 if (variable_table->file)
3355 {
3356 free (variable_table->file);
3357 variable_table->file = NULL;
3358 }
3359
3360 variable_table = variable_table->prev_var;
3361 }
3362 }
3363
3364 if (stash->dwarf_abbrev_buffer)
3365 free (stash->dwarf_abbrev_buffer);
3366 if (stash->dwarf_line_buffer)
3367 free (stash->dwarf_line_buffer);
3368 if (stash->dwarf_str_buffer)
3369 free (stash->dwarf_str_buffer);
3370 if (stash->dwarf_ranges_buffer)
3371 free (stash->dwarf_ranges_buffer);
3372 if (stash->info_ptr_memory)
3373 free (stash->info_ptr_memory);
3374 }
This page took 0.107593 seconds and 4 git commands to generate.