Bug Summary

File:src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c
Warning:line 1253, column 8
Value stored to 'basic_block' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name dwarf2.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/bfd -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/bfd -I . -D NETBSD_CORE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/bfd -I /usr/src/gnu/usr.bin/binutils-2.17/bfd/../include -I /usr/src/gnu/usr.bin/binutils-2.17/bfd/../intl -I ../intl -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/bfd -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c
1/* DWARF 2 support.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 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 2 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, MA 02110-1301, USA. */
31
32#include "bfd.h"
33#include "sysdep.h"
34#include "libiberty.h"
35#include "libbfd.h"
36#include "elf-bfd.h"
37#include "elf/dwarf2.h"
38
39/* The data in the .debug_line statement prologue looks like this. */
40
41struct line_head
42{
43 bfd_vma total_length;
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char default_is_stmt;
48 int line_base;
49 unsigned char line_range;
50 unsigned char opcode_base;
51 unsigned char *standard_opcode_lengths;
52};
53
54/* Attributes have a name and a value. */
55
56struct attribute
57{
58 enum dwarf_attribute name;
59 enum dwarf_form form;
60 union
61 {
62 char *str;
63 struct dwarf_block *blk;
64 bfd_uint64_t val;
65 bfd_int64_t sval;
66 }
67 u;
68};
69
70/* Blocks are a bunch of untyped bytes. */
71struct dwarf_block
72{
73 unsigned int size;
74 bfd_byte *data;
75};
76
77struct loadable_section
78{
79 asection *section;
80 bfd_vma adj_vma;
81};
82
83struct dwarf2_debug
84{
85 /* A list of all previously read comp_units. */
86 struct comp_unit *all_comp_units;
87
88 /* The next unread compilation unit within the .debug_info section.
89 Zero indicates that the .debug_info section has not been loaded
90 into a buffer yet. */
91 bfd_byte *info_ptr;
92
93 /* Pointer to the end of the .debug_info section memory buffer. */
94 bfd_byte *info_ptr_end;
95
96 /* Pointer to the section and address of the beginning of the
97 section. */
98 asection *sec;
99 bfd_byte *sec_info_ptr;
100
101 /* Pointer to the symbol table. */
102 asymbol **syms;
103
104 /* Pointer to the .debug_abbrev section loaded into memory. */
105 bfd_byte *dwarf_abbrev_buffer;
106
107 /* Length of the loaded .debug_abbrev section. */
108 unsigned long dwarf_abbrev_size;
109
110 /* Buffer for decode_line_info. */
111 bfd_byte *dwarf_line_buffer;
112
113 /* Length of the loaded .debug_line section. */
114 unsigned long dwarf_line_size;
115
116 /* Pointer to the .debug_str section loaded into memory. */
117 bfd_byte *dwarf_str_buffer;
118
119 /* Length of the loaded .debug_str section. */
120 unsigned long dwarf_str_size;
121
122 /* Pointer to the .debug_ranges section loaded into memory. */
123 bfd_byte *dwarf_ranges_buffer;
124
125 /* Length of the loaded .debug_ranges section. */
126 unsigned long dwarf_ranges_size;
127
128 /* If the most recent call to bfd_find_nearest_line was given an
129 address in an inlined function, preserve a pointer into the
130 calling chain for subsequent calls to bfd_find_inliner_info to
131 use. */
132 struct funcinfo *inliner_chain;
133
134 /* Number of loadable sections. */
135 unsigned int loadable_section_count;
136
137 /* Array of loadable sections. */
138 struct loadable_section *loadable_sections;
139};
140
141struct arange
142{
143 struct arange *next;
144 bfd_vma low;
145 bfd_vma high;
146};
147
148/* A minimal decoding of DWARF2 compilation units. We only decode
149 what's needed to get to the line number information. */
150
151struct comp_unit
152{
153 /* Chain the previously read compilation units. */
154 struct comp_unit *next_unit;
155
156 /* Keep the bfd convenient (for memory allocation). */
157 bfd *abfd;
158
159 /* The lowest and highest addresses contained in this compilation
160 unit as specified in the compilation unit header. */
161 struct arange arange;
162
163 /* The DW_AT_name attribute (for error messages). */
164 char *name;
165
166 /* The abbrev hash table. */
167 struct abbrev_info **abbrevs;
168
169 /* Note that an error was found by comp_unit_find_nearest_line. */
170 int error;
171
172 /* The DW_AT_comp_dir attribute. */
173 char *comp_dir;
174
175 /* TRUE if there is a line number table associated with this comp. unit. */
176 int stmtlist;
177
178 /* Pointer to the current comp_unit so that we can find a given entry
179 by its reference. */
180 bfd_byte *info_ptr_unit;
181
182 /* The offset into .debug_line of the line number table. */
183 unsigned long line_offset;
184
185 /* Pointer to the first child die for the comp unit. */
186 bfd_byte *first_child_die_ptr;
187
188 /* The end of the comp unit. */
189 bfd_byte *end_ptr;
190
191 /* The decoded line number, NULL if not yet decoded. */
192 struct line_info_table *line_table;
193
194 /* A list of the functions found in this comp. unit. */
195 struct funcinfo *function_table;
196
197 /* A list of the variables found in this comp. unit. */
198 struct varinfo *variable_table;
199
200 /* Pointer to dwarf2_debug structure. */
201 struct dwarf2_debug *stash;
202
203 /* Address size for this unit - from unit header. */
204 unsigned char addr_size;
205
206 /* Offset size for this unit - from unit header. */
207 unsigned char offset_size;
208
209 /* Base address for this unit - from DW_AT_low_pc attribute of
210 DW_TAG_compile_unit DIE */
211 bfd_vma base_address;
212};
213
214/* This data structure holds the information of an abbrev. */
215struct abbrev_info
216{
217 unsigned int number; /* Number identifying abbrev. */
218 enum dwarf_tag tag; /* DWARF tag. */
219 int has_children; /* Boolean. */
220 unsigned int num_attrs; /* Number of attributes. */
221 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
222 struct abbrev_info *next; /* Next in chain. */
223};
224
225struct attr_abbrev
226{
227 enum dwarf_attribute name;
228 enum dwarf_form form;
229};
230
231#ifndef ABBREV_HASH_SIZE121
232#define ABBREV_HASH_SIZE121 121
233#endif
234#ifndef ATTR_ALLOC_CHUNK4
235#define ATTR_ALLOC_CHUNK4 4
236#endif
237
238/* VERBATIM
239 The following function up to the END VERBATIM mark are
240 copied directly from dwarf2read.c. */
241
242/* Read dwarf information from a buffer. */
243
244static unsigned int
245read_1_byte (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), bfd_byte *buf)
246{
247 return bfd_get_8 (abfd, buf)(*(unsigned char *) (buf) & 0xff);
248}
249
250static int
251read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), bfd_byte *buf)
252{
253 return bfd_get_signed_8 (abfd, buf)(((*(unsigned char *) (buf) & 0xff) ^ 0x80) - 0x80);
254}
255
256static unsigned int
257read_2_bytes (bfd *abfd, bfd_byte *buf)
258{
259 return bfd_get_16 (abfd, buf)((*((abfd)->xvec->bfd_getx16)) (buf));
260}
261
262static unsigned int
263read_4_bytes (bfd *abfd, bfd_byte *buf)
264{
265 return bfd_get_32 (abfd, buf)((*((abfd)->xvec->bfd_getx32)) (buf));
266}
267
268static bfd_uint64_t
269read_8_bytes (bfd *abfd, bfd_byte *buf)
270{
271 return bfd_get_64 (abfd, buf)((*((abfd)->xvec->bfd_getx64)) (buf));
272}
273
274static bfd_byte *
275read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
276 bfd_byte *buf,
277 unsigned int size ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
278{
279 /* If the size of a host char is 8 bits, we can return a pointer
280 to the buffer, otherwise we have to copy the data to a buffer
281 allocated on the temporary obstack. */
282 return buf;
283}
284
285static char *
286read_string (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
287 bfd_byte *buf,
288 unsigned int *bytes_read_ptr)
289{
290 /* Return a pointer to the embedded string. */
291 char *str = (char *) buf;
292 if (*str == '\0')
293 {
294 *bytes_read_ptr = 1;
295 return NULL((void*)0);
296 }
297
298 *bytes_read_ptr = strlen (str) + 1;
299 return str;
300}
301
302static char *
303read_indirect_string (struct comp_unit* unit,
304 bfd_byte *buf,
305 unsigned int *bytes_read_ptr)
306{
307 bfd_uint64_t offset;
308 struct dwarf2_debug *stash = unit->stash;
309 char *str;
310
311 if (unit->offset_size == 4)
312 offset = read_4_bytes (unit->abfd, buf);
313 else
314 offset = read_8_bytes (unit->abfd, buf);
315 *bytes_read_ptr = unit->offset_size;
316
317 if (! stash->dwarf_str_buffer)
318 {
319 asection *msec;
320 bfd *abfd = unit->abfd;
321 bfd_size_type sz;
322
323 msec = bfd_get_section_by_name (abfd, ".debug_str");
324 if (! msec)
325 {
326 (*_bfd_error_handler)
327 (_("Dwarf Error: Can't find .debug_str section.")("Dwarf Error: Can't find .debug_str section."));
328 bfd_set_error (bfd_error_bad_value);
329 return NULL((void*)0);
330 }
331
332 sz = msec->rawsize ? msec->rawsize : msec->size;
333 stash->dwarf_str_size = sz;
334 stash->dwarf_str_buffer = bfd_alloc (abfd, sz);
335 if (! stash->dwarf_str_buffer)
336 return NULL((void*)0);
337
338 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
339 0, sz))
340 return NULL((void*)0);
341 }
342
343 if (offset >= stash->dwarf_str_size)
344 {
345 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu).")("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."
)
,
346 (unsigned long) offset, stash->dwarf_str_size);
347 bfd_set_error (bfd_error_bad_value);
348 return NULL((void*)0);
349 }
350
351 str = (char *) stash->dwarf_str_buffer + offset;
352 if (*str == '\0')
353 return NULL((void*)0);
354 return str;
355}
356
357/* END VERBATIM */
358
359static bfd_uint64_t
360read_address (struct comp_unit *unit, bfd_byte *buf)
361{
362 int signed_vma = get_elf_backend_data (unit->abfd)((const struct elf_backend_data *) (unit->abfd)->xvec->
backend_data)
->sign_extend_vma;
363
364 if (signed_vma)
365 {
366 switch (unit->addr_size)
367 {
368 case 8:
369 return bfd_get_signed_64 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx_signed_64)) (buf));
370 case 4:
371 return bfd_get_signed_32 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx_signed_32)) (buf));
372 case 2:
373 return bfd_get_signed_16 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx_signed_16)) (buf));
374 default:
375 abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
, 375, __PRETTY_FUNCTION__)
;
376 }
377 }
378 else
379 {
380 switch (unit->addr_size)
381 {
382 case 8:
383 return bfd_get_64 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx64)) (buf));
384 case 4:
385 return bfd_get_32 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx32)) (buf));
386 case 2:
387 return bfd_get_16 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx16)) (buf));
388 default:
389 abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
, 389, __PRETTY_FUNCTION__)
;
390 }
391 }
392}
393
394/* Lookup an abbrev_info structure in the abbrev hash table. */
395
396static struct abbrev_info *
397lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
398{
399 unsigned int hash_number;
400 struct abbrev_info *abbrev;
401
402 hash_number = number % ABBREV_HASH_SIZE121;
403 abbrev = abbrevs[hash_number];
404
405 while (abbrev)
406 {
407 if (abbrev->number == number)
408 return abbrev;
409 else
410 abbrev = abbrev->next;
411 }
412
413 return NULL((void*)0);
414}
415
416/* In DWARF version 2, the description of the debugging information is
417 stored in a separate .debug_abbrev section. Before we read any
418 dies from a section we read in all abbreviations and install them
419 in a hash table. */
420
421static struct abbrev_info**
422read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
423{
424 struct abbrev_info **abbrevs;
425 bfd_byte *abbrev_ptr;
426 struct abbrev_info *cur_abbrev;
427 unsigned int abbrev_number, bytes_read, abbrev_name;
428 unsigned int abbrev_form, hash_number;
429 bfd_size_type amt;
430
431 if (! stash->dwarf_abbrev_buffer)
432 {
433 asection *msec;
434
435 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
436 if (! msec)
437 {
438 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section.")("Dwarf Error: Can't find .debug_abbrev section."));
439 bfd_set_error (bfd_error_bad_value);
440 return 0;
441 }
442
443 stash->dwarf_abbrev_size = msec->size;
444 stash->dwarf_abbrev_buffer
445 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL((void*)0),
446 stash->syms);
447 if (! stash->dwarf_abbrev_buffer)
448 return 0;
449 }
450
451 if (offset >= stash->dwarf_abbrev_size)
452 {
453 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu).")("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."
)
,
454 (unsigned long) offset, stash->dwarf_abbrev_size);
455 bfd_set_error (bfd_error_bad_value);
456 return 0;
457 }
458
459 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE121;
460 abbrevs = bfd_zalloc (abfd, amt);
461
462 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
463 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
464 abbrev_ptr += bytes_read;
465
466 /* Loop until we reach an abbrev number of 0. */
467 while (abbrev_number)
468 {
469 amt = sizeof (struct abbrev_info);
470 cur_abbrev = bfd_zalloc (abfd, amt);
471
472 /* Read in abbrev header. */
473 cur_abbrev->number = abbrev_number;
474 cur_abbrev->tag = (enum dwarf_tag)
475 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
476 abbrev_ptr += bytes_read;
477 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
478 abbrev_ptr += 1;
479
480 /* Now read in declarations. */
481 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
482 abbrev_ptr += bytes_read;
483 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
484 abbrev_ptr += bytes_read;
485
486 while (abbrev_name)
487 {
488 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK4) == 0)
489 {
490 struct attr_abbrev *tmp;
491
492 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK4;
493 amt *= sizeof (struct attr_abbrev);
494 tmp = bfd_realloc (cur_abbrev->attrs, amt);
495 if (tmp == NULL((void*)0))
496 {
497 size_t i;
498
499 for (i = 0; i < ABBREV_HASH_SIZE121; i++)
500 {
501 struct abbrev_info *abbrev = abbrevs[i];
502
503 while (abbrev)
504 {
505 free (abbrev->attrs);
506 abbrev = abbrev->next;
507 }
508 }
509 return NULL((void*)0);
510 }
511 cur_abbrev->attrs = tmp;
512 }
513
514 cur_abbrev->attrs[cur_abbrev->num_attrs].name
515 = (enum dwarf_attribute) abbrev_name;
516 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
517 = (enum dwarf_form) abbrev_form;
518 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
519 abbrev_ptr += bytes_read;
520 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
521 abbrev_ptr += bytes_read;
522 }
523
524 hash_number = abbrev_number % ABBREV_HASH_SIZE121;
525 cur_abbrev->next = abbrevs[hash_number];
526 abbrevs[hash_number] = cur_abbrev;
527
528 /* Get next abbreviation.
529 Under Irix6 the abbreviations for a compilation unit are not
530 always properly terminated with an abbrev number of 0.
531 Exit loop if we encounter an abbreviation which we have
532 already read (which means we are about to read the abbreviations
533 for the next compile unit) or if the end of the abbreviation
534 table is reached. */
535 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
536 >= stash->dwarf_abbrev_size)
537 break;
538 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
539 abbrev_ptr += bytes_read;
540 if (lookup_abbrev (abbrev_number,abbrevs) != NULL((void*)0))
541 break;
542 }
543
544 return abbrevs;
545}
546
547/* Read an attribute value described by an attribute form. */
548
549static bfd_byte *
550read_attribute_value (struct attribute *attr,
551 unsigned form,
552 struct comp_unit *unit,
553 bfd_byte *info_ptr)
554{
555 bfd *abfd = unit->abfd;
556 unsigned int bytes_read;
557 struct dwarf_block *blk;
558 bfd_size_type amt;
559
560 attr->form = (enum dwarf_form) form;
561
562 switch (form)
563 {
564 case DW_FORM_addr:
565 /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
566 case DW_FORM_ref_addr:
567 attr->u.val = read_address (unit, info_ptr);
568 info_ptr += unit->addr_size;
569 break;
570 case DW_FORM_block2:
571 amt = sizeof (struct dwarf_block);
572 blk = bfd_alloc (abfd, amt);
573 blk->size = read_2_bytes (abfd, info_ptr);
574 info_ptr += 2;
575 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
576 info_ptr += blk->size;
577 attr->u.blk = blk;
578 break;
579 case DW_FORM_block4:
580 amt = sizeof (struct dwarf_block);
581 blk = bfd_alloc (abfd, amt);
582 blk->size = read_4_bytes (abfd, info_ptr);
583 info_ptr += 4;
584 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
585 info_ptr += blk->size;
586 attr->u.blk = blk;
587 break;
588 case DW_FORM_data2:
589 attr->u.val = read_2_bytes (abfd, info_ptr);
590 info_ptr += 2;
591 break;
592 case DW_FORM_data4:
593 attr->u.val = read_4_bytes (abfd, info_ptr);
594 info_ptr += 4;
595 break;
596 case DW_FORM_data8:
597 attr->u.val = read_8_bytes (abfd, info_ptr);
598 info_ptr += 8;
599 break;
600 case DW_FORM_string:
601 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
602 info_ptr += bytes_read;
603 break;
604 case DW_FORM_strp:
605 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
606 info_ptr += bytes_read;
607 break;
608 case DW_FORM_block:
609 amt = sizeof (struct dwarf_block);
610 blk = bfd_alloc (abfd, amt);
611 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
612 info_ptr += bytes_read;
613 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
614 info_ptr += blk->size;
615 attr->u.blk = blk;
616 break;
617 case DW_FORM_block1:
618 amt = sizeof (struct dwarf_block);
619 blk = bfd_alloc (abfd, amt);
620 blk->size = read_1_byte (abfd, info_ptr);
621 info_ptr += 1;
622 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
623 info_ptr += blk->size;
624 attr->u.blk = blk;
625 break;
626 case DW_FORM_data1:
627 attr->u.val = read_1_byte (abfd, info_ptr);
628 info_ptr += 1;
629 break;
630 case DW_FORM_flag:
631 attr->u.val = read_1_byte (abfd, info_ptr);
632 info_ptr += 1;
633 break;
634 case DW_FORM_sdata:
635 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
636 info_ptr += bytes_read;
637 break;
638 case DW_FORM_udata:
639 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
640 info_ptr += bytes_read;
641 break;
642 case DW_FORM_ref1:
643 attr->u.val = read_1_byte (abfd, info_ptr);
644 info_ptr += 1;
645 break;
646 case DW_FORM_ref2:
647 attr->u.val = read_2_bytes (abfd, info_ptr);
648 info_ptr += 2;
649 break;
650 case DW_FORM_ref4:
651 attr->u.val = read_4_bytes (abfd, info_ptr);
652 info_ptr += 4;
653 break;
654 case DW_FORM_ref8:
655 attr->u.val = read_8_bytes (abfd, info_ptr);
656 info_ptr += 8;
657 break;
658 case DW_FORM_ref_udata:
659 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
660 info_ptr += bytes_read;
661 break;
662 case DW_FORM_indirect:
663 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
664 info_ptr += bytes_read;
665 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
666 break;
667 default:
668 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u.")("Dwarf Error: Invalid or unhandled FORM value: %u."),
669 form);
670 bfd_set_error (bfd_error_bad_value);
671 }
672 return info_ptr;
673}
674
675/* Read an attribute described by an abbreviated attribute. */
676
677static bfd_byte *
678read_attribute (struct attribute *attr,
679 struct attr_abbrev *abbrev,
680 struct comp_unit *unit,
681 bfd_byte *info_ptr)
682{
683 attr->name = abbrev->name;
684 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
685 return info_ptr;
686}
687
688/* Source line information table routines. */
689
690#define FILE_ALLOC_CHUNK5 5
691#define DIR_ALLOC_CHUNK5 5
692
693struct line_info
694{
695 struct line_info* prev_line;
696 bfd_vma address;
697 char *filename;
698 unsigned int line;
699 unsigned int column;
700 int end_sequence; /* End of (sequential) code sequence. */
701};
702
703struct fileinfo
704{
705 char *name;
706 unsigned int dir;
707 unsigned int time;
708 unsigned int size;
709};
710
711struct line_info_table
712{
713 bfd* abfd;
714 unsigned int num_files;
715 unsigned int num_dirs;
716 char *comp_dir;
717 char **dirs;
718 struct fileinfo* files;
719 struct line_info* last_line; /* largest VMA */
720 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
721};
722
723/* Remember some information about each function. If the function is
724 inlined (DW_TAG_inlined_subroutine) it may have two additional
725 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
726 source code location where this function was inlined. */
727
728struct funcinfo
729{
730 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
731 struct funcinfo *caller_func; /* Pointer to function one scope higher */
732 char *caller_file; /* Source location file name where caller_func inlines this func */
733 int caller_line; /* Source location line number where caller_func inlines this func */
734 char *file; /* Source location file name */
735 int line; /* Source location line number */
736 int tag;
737 char *name;
738 struct arange arange;
739 asection *sec; /* Where the symbol is defined */
740};
741
742struct varinfo
743{
744 /* Pointer to previous variable in list of all variables */
745 struct varinfo *prev_var;
746 /* Source location file name */
747 char *file;
748 /* Source location line number */
749 int line;
750 int tag;
751 char *name;
752 bfd_vma addr;
753 /* Where the symbol is defined */
754 asection *sec;
755 /* Is this a stack variable? */
756 unsigned int stack: 1;
757};
758
759/* Return TRUE if NEW_LINE should sort after LINE. */
760
761static inline bfd_boolean
762new_line_sorts_after (struct line_info *new_line, struct line_info *line)
763{
764 return (new_line->address > line->address
765 || (new_line->address == line->address
766 && new_line->end_sequence < line->end_sequence));
767}
768
769
770/* Adds a new entry to the line_info list in the line_info_table, ensuring
771 that the list is sorted. Note that the line_info list is sorted from
772 highest to lowest VMA (with possible duplicates); that is,
773 line_info->prev_line always accesses an equal or smaller VMA. */
774
775static void
776add_line_info (struct line_info_table *table,
777 bfd_vma address,
778 char *filename,
779 unsigned int line,
780 unsigned int column,
781 int end_sequence)
782{
783 bfd_size_type amt = sizeof (struct line_info);
784 struct line_info* info = bfd_alloc (table->abfd, amt);
785
786 /* Set member data of 'info'. */
787 info->address = address;
788 info->line = line;
789 info->column = column;
790 info->end_sequence = end_sequence;
791
792 if (filename && filename[0])
793 {
794 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
795 if (info->filename)
796 strcpy (info->filename, filename);
797 }
798 else
799 info->filename = NULL((void*)0);
800
801 /* Find the correct location for 'info'. Normally we will receive
802 new line_info data 1) in order and 2) with increasing VMAs.
803 However some compilers break the rules (cf. decode_line_info) and
804 so we include some heuristics for quickly finding the correct
805 location for 'info'. In particular, these heuristics optimize for
806 the common case in which the VMA sequence that we receive is a
807 list of locally sorted VMAs such as
808 p...z a...j (where a < j < p < z)
809
810 Note: table->lcl_head is used to head an *actual* or *possible*
811 sequence within the list (such as a...j) that is not directly
812 headed by table->last_line
813
814 Note: we may receive duplicate entries from 'decode_line_info'. */
815
816 if (!table->last_line
817 || new_line_sorts_after (info, table->last_line))
818 {
819 /* Normal case: add 'info' to the beginning of the list */
820 info->prev_line = table->last_line;
821 table->last_line = info;
822
823 /* lcl_head: initialize to head a *possible* sequence at the end. */
824 if (!table->lcl_head)
825 table->lcl_head = info;
826 }
827 else if (!new_line_sorts_after (info, table->lcl_head)
828 && (!table->lcl_head->prev_line
829 || new_line_sorts_after (info, table->lcl_head->prev_line)))
830 {
831 /* Abnormal but easy: lcl_head is the head of 'info'. */
832 info->prev_line = table->lcl_head->prev_line;
833 table->lcl_head->prev_line = info;
834 }
835 else
836 {
837 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
838 heads for 'info'. Reset 'lcl_head'. */
839 struct line_info* li2 = table->last_line; /* always non-NULL */
840 struct line_info* li1 = li2->prev_line;
841
842 while (li1)
843 {
844 if (!new_line_sorts_after (info, li2)
845 && new_line_sorts_after (info, li1))
846 break;
847
848 li2 = li1; /* always non-NULL */
849 li1 = li1->prev_line;
850 }
851 table->lcl_head = li2;
852 info->prev_line = table->lcl_head->prev_line;
853 table->lcl_head->prev_line = info;
854 }
855}
856
857/* Extract a fully qualified filename from a line info table.
858 The returned string has been malloc'ed and it is the caller's
859 responsibility to free it. */
860
861static char *
862concat_filename (struct line_info_table *table, unsigned int file)
863{
864 char *filename;
865
866 if (file - 1 >= table->num_files)
867 {
868 /* FILE == 0 means unknown. */
869 if (file)
870 (*_bfd_error_handler)
871 (_("Dwarf Error: mangled line number section (bad file number).")("Dwarf Error: mangled line number section (bad file number)."
)
);
872 return strdup ("<unknown>");
873 }
874
875 filename = table->files[file - 1].name;
876
877 if (! IS_ABSOLUTE_PATH (filename)((((filename)[0]) == '/')))
878 {
879 char *dirname = (table->files[file - 1].dir
880 ? table->dirs[table->files[file - 1].dir - 1]
881 : table->comp_dir);
882
883 /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
884 The best we can do is return the filename part. */
885 if (dirname != NULL((void*)0))
886 {
887 unsigned int len = strlen (dirname) + strlen (filename) + 2;
888 char * name;
889
890 name = bfd_malloc (len);
891 if (name)
892 sprintf (name, "%s/%s", dirname, filename);
893 return name;
894 }
895 }
896
897 return strdup (filename);
898}
899
900static void
901arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
902{
903 struct arange *arange;
904
905 /* If the first arange is empty, use it. */
906 if (first_arange->high == 0)
907 {
908 first_arange->low = low_pc;
909 first_arange->high = high_pc;
910 return;
911 }
912
913 /* Next see if we can cheaply extend an existing range. */
914 arange = first_arange;
915 do
916 {
917 if (low_pc == arange->high)
918 {
919 arange->high = high_pc;
920 return;
921 }
922 if (high_pc == arange->low)
923 {
924 arange->low = low_pc;
925 return;
926 }
927 arange = arange->next;
928 }
929 while (arange);
930
931 /* Need to allocate a new arange and insert it into the arange list.
932 Order isn't significant, so just insert after the first arange. */
933 arange = bfd_zalloc (abfd, sizeof (*arange));
934 arange->low = low_pc;
935 arange->high = high_pc;
936 arange->next = first_arange->next;
937 first_arange->next = arange;
938}
939
940/* Decode the line number information for UNIT. */
941
942static struct line_info_table*
943decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
944{
945 bfd *abfd = unit->abfd;
946 struct line_info_table* table;
947 bfd_byte *line_ptr;
948 bfd_byte *line_end;
949 struct line_head lh;
950 unsigned int i, bytes_read, offset_size;
951 char *cur_file, *cur_dir;
952 unsigned char op_code, extended_op, adj_opcode;
953 bfd_size_type amt;
954
955 if (! stash->dwarf_line_buffer)
956 {
957 asection *msec;
958
959 msec = bfd_get_section_by_name (abfd, ".debug_line");
960 if (! msec)
961 {
962 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section.")("Dwarf Error: Can't find .debug_line section."));
963 bfd_set_error (bfd_error_bad_value);
964 return 0;
965 }
966
967 stash->dwarf_line_size = msec->size;
968 stash->dwarf_line_buffer
969 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL((void*)0),
970 stash->syms);
971 if (! stash->dwarf_line_buffer)
972 return 0;
973 }
974
975 /* It is possible to get a bad value for the line_offset. Validate
976 it here so that we won't get a segfault below. */
977 if (unit->line_offset >= stash->dwarf_line_size)
978 {
979 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu).")("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."
)
,
980 unit->line_offset, stash->dwarf_line_size);
981 bfd_set_error (bfd_error_bad_value);
982 return 0;
983 }
984
985 amt = sizeof (struct line_info_table);
986 table = bfd_alloc (abfd, amt);
987 table->abfd = abfd;
988 table->comp_dir = unit->comp_dir;
989
990 table->num_files = 0;
991 table->files = NULL((void*)0);
992
993 table->num_dirs = 0;
994 table->dirs = NULL((void*)0);
995
996 table->files = NULL((void*)0);
997 table->last_line = NULL((void*)0);
998 table->lcl_head = NULL((void*)0);
999
1000 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1001
1002 /* Read in the prologue. */
1003 lh.total_length = read_4_bytes (abfd, line_ptr);
1004 line_ptr += 4;
1005 offset_size = 4;
1006 if (lh.total_length == 0xffffffff)
1007 {
1008 lh.total_length = read_8_bytes (abfd, line_ptr);
1009 line_ptr += 8;
1010 offset_size = 8;
1011 }
1012 else if (lh.total_length == 0 && unit->addr_size == 8)
1013 {
1014 /* Handle (non-standard) 64-bit DWARF2 formats. */
1015 lh.total_length = read_4_bytes (abfd, line_ptr);
1016 line_ptr += 4;
1017 offset_size = 8;
1018 }
1019 line_end = line_ptr + lh.total_length;
1020 lh.version = read_2_bytes (abfd, line_ptr);
1021 line_ptr += 2;
1022 if (offset_size == 4)
1023 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1024 else
1025 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1026 line_ptr += offset_size;
1027 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1028 line_ptr += 1;
1029 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1030 line_ptr += 1;
1031 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1032 line_ptr += 1;
1033 lh.line_range = read_1_byte (abfd, line_ptr);
1034 line_ptr += 1;
1035 lh.opcode_base = read_1_byte (abfd, line_ptr);
1036 line_ptr += 1;
1037 amt = lh.opcode_base * sizeof (unsigned char);
1038 lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1039
1040 lh.standard_opcode_lengths[0] = 1;
1041
1042 for (i = 1; i < lh.opcode_base; ++i)
1043 {
1044 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1045 line_ptr += 1;
1046 }
1047
1048 /* Read directory table. */
1049 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL((void*)0))
1050 {
1051 line_ptr += bytes_read;
1052
1053 if ((table->num_dirs % DIR_ALLOC_CHUNK5) == 0)
1054 {
1055 char **tmp;
1056
1057 amt = table->num_dirs + DIR_ALLOC_CHUNK5;
1058 amt *= sizeof (char *);
1059
1060 tmp = bfd_realloc (table->dirs, amt);
1061 if (tmp == NULL((void*)0))
1062 {
1063 free (table->dirs);
1064 return NULL((void*)0);
1065 }
1066 table->dirs = tmp;
1067 }
1068
1069 table->dirs[table->num_dirs++] = cur_dir;
1070 }
1071
1072 line_ptr += bytes_read;
1073
1074 /* Read file name table. */
1075 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL((void*)0))
1076 {
1077 line_ptr += bytes_read;
1078
1079 if ((table->num_files % FILE_ALLOC_CHUNK5) == 0)
1080 {
1081 struct fileinfo *tmp;
1082
1083 amt = table->num_files + FILE_ALLOC_CHUNK5;
1084 amt *= sizeof (struct fileinfo);
1085
1086 tmp = bfd_realloc (table->files, amt);
1087 if (tmp == NULL((void*)0))
1088 {
1089 free (table->files);
1090 free (table->dirs);
1091 return NULL((void*)0);
1092 }
1093 table->files = tmp;
1094 }
1095
1096 table->files[table->num_files].name = cur_file;
1097 table->files[table->num_files].dir =
1098 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1099 line_ptr += bytes_read;
1100 table->files[table->num_files].time =
1101 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1102 line_ptr += bytes_read;
1103 table->files[table->num_files].size =
1104 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1105 line_ptr += bytes_read;
1106 table->num_files++;
1107 }
1108
1109 line_ptr += bytes_read;
1110
1111 /* Read the statement sequences until there's nothing left. */
1112 while (line_ptr < line_end)
1113 {
1114 /* State machine registers. */
1115 bfd_vma address = 0;
1116 char * filename = table->num_files ? concat_filename (table, 1) : NULL((void*)0);
1117 unsigned int line = 1;
1118 unsigned int column = 0;
1119 int is_stmt = lh.default_is_stmt;
1120 int basic_block = 0;
1121 int end_sequence = 0;
1122 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1123 compilers generate address sequences that are wildly out of
1124 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1125 for ia64-Linux). Thus, to determine the low and high
1126 address, we must compare on every DW_LNS_copy, etc. */
1127 bfd_vma low_pc = (bfd_vma) -1;
1128 bfd_vma high_pc = 0;
1129
1130 /* Decode the table. */
1131 while (! end_sequence)
1132 {
1133 op_code = read_1_byte (abfd, line_ptr);
1134 line_ptr += 1;
1135
1136 if (op_code >= lh.opcode_base)
1137 {
1138 /* Special operand. */
1139 adj_opcode = op_code - lh.opcode_base;
1140 address += (adj_opcode / lh.line_range)
1141 * lh.minimum_instruction_length;
1142 line += lh.line_base + (adj_opcode % lh.line_range);
1143 /* Append row to matrix using current values. */
1144 add_line_info (table, address, filename, line, column, 0);
1145 basic_block = 1;
1146 if (address < low_pc)
1147 low_pc = address;
1148 if (address > high_pc)
1149 high_pc = address;
1150 }
1151 else switch (op_code)
1152 {
1153 case DW_LNS_extended_op:
1154 /* Ignore length. */
1155 line_ptr += 1;
1156 extended_op = read_1_byte (abfd, line_ptr);
1157 line_ptr += 1;
1158
1159 switch (extended_op)
1160 {
1161 case DW_LNE_end_sequence:
1162 end_sequence = 1;
1163 add_line_info (table, address, filename, line, column,
1164 end_sequence);
1165 if (address < low_pc)
1166 low_pc = address;
1167 if (address > high_pc)
1168 high_pc = address;
1169 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1170 break;
1171 case DW_LNE_set_address:
1172 address = read_address (unit, line_ptr);
1173 line_ptr += unit->addr_size;
1174 break;
1175 case DW_LNE_define_file:
1176 cur_file = read_string (abfd, line_ptr, &bytes_read);
1177 line_ptr += bytes_read;
1178 if ((table->num_files % FILE_ALLOC_CHUNK5) == 0)
1179 {
1180 struct fileinfo *tmp;
1181
1182 amt = table->num_files + FILE_ALLOC_CHUNK5;
1183 amt *= sizeof (struct fileinfo);
1184 tmp = bfd_realloc (table->files, amt);
1185 if (tmp == NULL((void*)0))
1186 {
1187 free (table->files);
1188 free (table->dirs);
1189 free (filename);
1190 return NULL((void*)0);
1191 }
1192 table->files = tmp;
1193 }
1194 table->files[table->num_files].name = cur_file;
1195 table->files[table->num_files].dir =
1196 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1197 line_ptr += bytes_read;
1198 table->files[table->num_files].time =
1199 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1200 line_ptr += bytes_read;
1201 table->files[table->num_files].size =
1202 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1203 line_ptr += bytes_read;
1204 table->num_files++;
1205 break;
1206 default:
1207 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section.")("Dwarf Error: mangled line number section."));
1208 bfd_set_error (bfd_error_bad_value);
1209 free (filename);
1210 free (table->files);
1211 free (table->dirs);
1212 return NULL((void*)0);
1213 }
1214 break;
1215 case DW_LNS_copy:
1216 add_line_info (table, address, filename, line, column, 0);
1217 basic_block = 0;
1218 if (address < low_pc)
1219 low_pc = address;
1220 if (address > high_pc)
1221 high_pc = address;
1222 break;
1223 case DW_LNS_advance_pc:
1224 address += lh.minimum_instruction_length
1225 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1226 line_ptr += bytes_read;
1227 break;
1228 case DW_LNS_advance_line:
1229 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1230 line_ptr += bytes_read;
1231 break;
1232 case DW_LNS_set_file:
1233 {
1234 unsigned int file;
1235
1236 /* The file and directory tables are 0
1237 based, the references are 1 based. */
1238 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1239 line_ptr += bytes_read;
1240 if (filename)
1241 free (filename);
1242 filename = concat_filename (table, file);
1243 break;
1244 }
1245 case DW_LNS_set_column:
1246 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1247 line_ptr += bytes_read;
1248 break;
1249 case DW_LNS_negate_stmt:
1250 is_stmt = (!is_stmt);
1251 break;
1252 case DW_LNS_set_basic_block:
1253 basic_block = 1;
Value stored to 'basic_block' is never read
1254 break;
1255 case DW_LNS_const_add_pc:
1256 address += lh.minimum_instruction_length
1257 * ((255 - lh.opcode_base) / lh.line_range);
1258 break;
1259 case DW_LNS_fixed_advance_pc:
1260 address += read_2_bytes (abfd, line_ptr);
1261 line_ptr += 2;
1262 break;
1263 default:
1264 {
1265 int i;
1266
1267 /* Unknown standard opcode, ignore it. */
1268 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1269 {
1270 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1271 line_ptr += bytes_read;
1272 }
1273 }
1274 }
1275 }
1276
1277 if (filename)
1278 free (filename);
1279 }
1280
1281 return table;
1282}
1283
1284/* If ADDR is within TABLE set the output parameters and return TRUE,
1285 otherwise return FALSE. The output parameters, FILENAME_PTR and
1286 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1287
1288static bfd_boolean
1289lookup_address_in_line_info_table (struct line_info_table *table,
1290 bfd_vma addr,
1291 struct funcinfo *function,
1292 const char **filename_ptr,
1293 unsigned int *linenumber_ptr)
1294{
1295 /* Note: table->last_line should be a descendingly sorted list. */
1296 struct line_info* next_line = table->last_line;
1297 struct line_info* each_line = NULL((void*)0);
1298 *filename_ptr = NULL((void*)0);
1299
1300 if (!next_line)
1301 return FALSE0;
1302
1303 each_line = next_line->prev_line;
1304
1305 /* Check for large addresses */
1306 if (addr > next_line->address)
1307 each_line = NULL((void*)0); /* ensure we skip over the normal case */
1308
1309 /* Normal case: search the list; save */
1310 while (each_line && next_line)
1311 {
1312 /* If we have an address match, save this info. This allows us
1313 to return as good as results as possible for strange debugging
1314 info. */
1315 bfd_boolean addr_match = FALSE0;
1316 if (each_line->address <= addr && addr < next_line->address)
1317 {
1318 addr_match = TRUE1;
1319
1320 /* If this line appears to span functions, and addr is in the
1321 later function, return the first line of that function instead
1322 of the last line of the earlier one. This check is for GCC
1323 2.95, which emits the first line number for a function late. */
1324
1325 if (function != NULL((void*)0))
1326 {
1327 bfd_vma lowest_pc;
1328 struct arange *arange;
1329
1330 /* Find the lowest address in the function's range list */
1331 lowest_pc = function->arange.low;
1332 for (arange = &function->arange;
1333 arange;
1334 arange = arange->next)
1335 {
1336 if (function->arange.low < lowest_pc)
1337 lowest_pc = function->arange.low;
1338 }
1339 /* Check for spanning function and set outgoing line info */
1340 if (addr >= lowest_pc
1341 && each_line->address < lowest_pc
1342 && next_line->address > lowest_pc)
1343 {
1344 *filename_ptr = next_line->filename;
1345 *linenumber_ptr = next_line->line;
1346 }
1347 else
1348 {
1349 *filename_ptr = each_line->filename;
1350 *linenumber_ptr = each_line->line;
1351 }
1352 }
1353 else
1354 {
1355 *filename_ptr = each_line->filename;
1356 *linenumber_ptr = each_line->line;
1357 }
1358 }
1359
1360 if (addr_match && !each_line->end_sequence)
1361 return TRUE1; /* we have definitely found what we want */
1362
1363 next_line = each_line;
1364 each_line = each_line->prev_line;
1365 }
1366
1367 /* At this point each_line is NULL but next_line is not. If we found
1368 a candidate end-of-sequence point in the loop above, we can return
1369 that (compatibility with a bug in the Intel compiler); otherwise,
1370 assuming that we found the containing function for this address in
1371 this compilation unit, return the first line we have a number for
1372 (compatibility with GCC 2.95). */
1373 if (*filename_ptr == NULL((void*)0) && function != NULL((void*)0))
1374 {
1375 *filename_ptr = next_line->filename;
1376 *linenumber_ptr = next_line->line;
1377 return TRUE1;
1378 }
1379
1380 return FALSE0;
1381}
1382
1383/* Read in the .debug_ranges section for future reference */
1384
1385static bfd_boolean
1386read_debug_ranges (struct comp_unit *unit)
1387{
1388 struct dwarf2_debug *stash = unit->stash;
1389 if (! stash->dwarf_ranges_buffer)
1390 {
1391 bfd *abfd = unit->abfd;
1392 asection *msec;
1393
1394 msec = bfd_get_section_by_name (abfd, ".debug_ranges");
1395 if (! msec)
1396 {
1397 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section.")("Dwarf Error: Can't find .debug_ranges section."));
1398 bfd_set_error (bfd_error_bad_value);
1399 return FALSE0;
1400 }
1401
1402 stash->dwarf_ranges_size = msec->size;
1403 stash->dwarf_ranges_buffer
1404 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL((void*)0),
1405 stash->syms);
1406 if (! stash->dwarf_ranges_buffer)
1407 return FALSE0;
1408 }
1409 return TRUE1;
1410}
1411
1412/* Function table functions. */
1413
1414/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1415 Note that we need to find the function that has the smallest
1416 range that contains ADDR, to handle inlined functions without
1417 depending upon them being ordered in TABLE by increasing range. */
1418
1419static bfd_boolean
1420lookup_address_in_function_table (struct comp_unit *unit,
1421 bfd_vma addr,
1422 struct funcinfo **function_ptr,
1423 const char **functionname_ptr)
1424{
1425 struct funcinfo* each_func;
1426 struct funcinfo* best_fit = NULL((void*)0);
1427 struct arange *arange;
1428
1429 for (each_func = unit->function_table;
1430 each_func;
1431 each_func = each_func->prev_func)
1432 {
1433 for (arange = &each_func->arange;
1434 arange;
1435 arange = arange->next)
1436 {
1437 if (addr >= arange->low && addr < arange->high)
1438 {
1439 if (!best_fit ||
1440 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1441 best_fit = each_func;
1442 }
1443 }
1444 }
1445
1446 if (best_fit)
1447 {
1448 *functionname_ptr = best_fit->name;
1449 *function_ptr = best_fit;
1450 return TRUE1;
1451 }
1452 else
1453 {
1454 return FALSE0;
1455 }
1456}
1457
1458/* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1459 and LINENUMBER_PTR, and return TRUE. */
1460
1461static bfd_boolean
1462lookup_symbol_in_function_table (struct comp_unit *unit,
1463 asymbol *sym,
1464 bfd_vma addr,
1465 const char **filename_ptr,
1466 unsigned int *linenumber_ptr)
1467{
1468 struct funcinfo* each_func;
1469 struct funcinfo* best_fit = NULL((void*)0);
1470 struct arange *arange;
1471 const char *name = bfd_asymbol_name (sym)((sym)->name);
1472 asection *sec = bfd_get_section (sym)((sym)->section);
1473
1474 for (each_func = unit->function_table;
1475 each_func;
1476 each_func = each_func->prev_func)
1477 {
1478 for (arange = &each_func->arange;
1479 arange;
1480 arange = arange->next)
1481 {
1482 if ((!each_func->sec || each_func->sec == sec)
1483 && addr >= arange->low
1484 && addr < arange->high
1485 && each_func->name
1486 && strcmp (name, each_func->name) == 0
1487 && (!best_fit
1488 || ((arange->high - arange->low)
1489 < (best_fit->arange.high - best_fit->arange.low))))
1490 best_fit = each_func;
1491 }
1492 }
1493
1494 if (best_fit)
1495 {
1496 best_fit->sec = sec;
1497 *filename_ptr = best_fit->file;
1498 *linenumber_ptr = best_fit->line;
1499 return TRUE1;
1500 }
1501 else
1502 return FALSE0;
1503}
1504
1505/* Variable table functions. */
1506
1507/* If SYM is within variable table of UNIT, set FILENAME_PTR and
1508 LINENUMBER_PTR, and return TRUE. */
1509
1510static bfd_boolean
1511lookup_symbol_in_variable_table (struct comp_unit *unit,
1512 asymbol *sym,
1513 bfd_vma addr,
1514 const char **filename_ptr,
1515 unsigned int *linenumber_ptr)
1516{
1517 const char *name = bfd_asymbol_name (sym)((sym)->name);
1518 asection *sec = bfd_get_section (sym)((sym)->section);
1519 struct varinfo* each;
1520
1521 for (each = unit->variable_table; each; each = each->prev_var)
1522 if (each->stack == 0
1523 && each->file != NULL((void*)0)
1524 && each->name != NULL((void*)0)
1525 && each->addr == addr
1526 && (!each->sec || each->sec == sec)
1527 && strcmp (name, each->name) == 0)
1528 break;
1529
1530 if (each)
1531 {
1532 each->sec = sec;
1533 *filename_ptr = each->file;
1534 *linenumber_ptr = each->line;
1535 return TRUE1;
1536 }
1537 else
1538 return FALSE0;
1539}
1540
1541static char *
1542find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
1543{
1544 bfd *abfd = unit->abfd;
1545 bfd_byte *info_ptr;
1546 unsigned int abbrev_number, bytes_read, i;
1547 struct abbrev_info *abbrev;
1548 struct attribute attr;
1549 char *name = 0;
1550
1551 info_ptr = unit->info_ptr_unit + die_ref;
1552 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1553 info_ptr += bytes_read;
1554
1555 if (abbrev_number)
1556 {
1557 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1558 if (! abbrev)
1559 {
1560 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u.")("Dwarf Error: Could not find abbrev number %u."),
1561 abbrev_number);
1562 bfd_set_error (bfd_error_bad_value);
1563 }
1564 else
1565 {
1566 for (i = 0; i < abbrev->num_attrs; ++i)
1567 {
1568 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1569 switch (attr.name)
1570 {
1571 case DW_AT_name:
1572 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1573 if (name == NULL((void*)0))
1574 name = attr.u.str;
1575 break;
1576 case DW_AT_specification:
1577 name = find_abstract_instance_name (unit, attr.u.val);
1578 break;
1579 case DW_AT_MIPS_linkage_name:
1580 name = attr.u.str;
1581 break;
1582 default:
1583 break;
1584 }
1585 }
1586 }
1587 }
1588 return (name);
1589}
1590
1591static void
1592read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1593{
1594 bfd_byte *ranges_ptr;
1595 bfd_vma base_address = unit->base_address;
1596
1597 if (! unit->stash->dwarf_ranges_buffer)
1598 {
1599 if (! read_debug_ranges (unit))
1600 return;
1601 }
1602 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1603
1604 for (;;)
1605 {
1606 bfd_vma low_pc;
1607 bfd_vma high_pc;
1608
1609 if (unit->addr_size == 4)
1610 {
1611 low_pc = read_4_bytes (unit->abfd, ranges_ptr);
1612 ranges_ptr += 4;
1613 high_pc = read_4_bytes (unit->abfd, ranges_ptr);
1614 ranges_ptr += 4;
1615 }
1616 else
1617 {
1618 low_pc = read_8_bytes (unit->abfd, ranges_ptr);
1619 ranges_ptr += 8;
1620 high_pc = read_8_bytes (unit->abfd, ranges_ptr);
1621 ranges_ptr += 8;
1622 }
1623 if (low_pc == 0 && high_pc == 0)
1624 break;
1625 if (low_pc == -1UL && high_pc != -1UL)
1626 base_address = high_pc;
1627 else
1628 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1629 }
1630}
1631
1632/* DWARF2 Compilation unit functions. */
1633
1634/* Scan over each die in a comp. unit looking for functions to add
1635 to the function table and variables to the variable table. */
1636
1637static bfd_boolean
1638scan_unit_for_symbols (struct comp_unit *unit)
1639{
1640 bfd *abfd = unit->abfd;
1641 bfd_byte *info_ptr = unit->first_child_die_ptr;
1642 int nesting_level = 1;
1643 struct funcinfo **nested_funcs;
1644 int nested_funcs_size;
1645
1646 /* Maintain a stack of in-scope functions and inlined functions, which we
1647 can use to set the caller_func field. */
1648 nested_funcs_size = 32;
1649 nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
1650 if (nested_funcs == NULL((void*)0))
1651 return FALSE0;
1652 nested_funcs[nesting_level] = 0;
1653
1654 while (nesting_level)
1655 {
1656 unsigned int abbrev_number, bytes_read, i;
1657 struct abbrev_info *abbrev;
1658 struct attribute attr;
1659 struct funcinfo *func;
1660 struct varinfo *var;
1661 bfd_vma low_pc = 0;
1662 bfd_vma high_pc = 0;
1663
1664 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1665 info_ptr += bytes_read;
1666
1667 if (! abbrev_number)
1668 {
1669 nesting_level--;
1670 continue;
1671 }
1672
1673 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1674 if (! abbrev)
1675 {
1676 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u.")("Dwarf Error: Could not find abbrev number %u."),
1677 abbrev_number);
1678 bfd_set_error (bfd_error_bad_value);
1679 free (nested_funcs);
1680 return FALSE0;
1681 }
1682
1683 var = NULL((void*)0);
1684 if (abbrev->tag == DW_TAG_subprogram
1685 || abbrev->tag == DW_TAG_entry_point
1686 || abbrev->tag == DW_TAG_inlined_subroutine)
1687 {
1688 bfd_size_type amt = sizeof (struct funcinfo);
1689 func = bfd_zalloc (abfd, amt);
1690 func->tag = abbrev->tag;
1691 func->prev_func = unit->function_table;
1692 unit->function_table = func;
1693
1694 if (func->tag == DW_TAG_inlined_subroutine)
1695 for (i = nesting_level - 1; i >= 1; i--)
1696 if (nested_funcs[i])
1697 {
1698 func->caller_func = nested_funcs[i];
1699 break;
1700 }
1701 nested_funcs[nesting_level] = func;
1702 }
1703 else
1704 {
1705 func = NULL((void*)0);
1706 if (abbrev->tag == DW_TAG_variable)
1707 {
1708 bfd_size_type amt = sizeof (struct varinfo);
1709 var = bfd_zalloc (abfd, amt);
1710 var->tag = abbrev->tag;
1711 var->stack = 1;
1712 var->prev_var = unit->variable_table;
1713 unit->variable_table = var;
1714 }
1715
1716 /* No inline function in scope at this nesting level. */
1717 nested_funcs[nesting_level] = 0;
1718 }
1719
1720 for (i = 0; i < abbrev->num_attrs; ++i)
1721 {
1722 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1723
1724 if (func)
1725 {
1726 switch (attr.name)
1727 {
1728 case DW_AT_call_file:
1729 func->caller_file = concat_filename (unit->line_table, attr.u.val);
1730 break;
1731
1732 case DW_AT_call_line:
1733 func->caller_line = attr.u.val;
1734 break;
1735
1736 case DW_AT_abstract_origin:
1737 func->name = find_abstract_instance_name (unit, attr.u.val);
1738 break;
1739
1740 case DW_AT_name:
1741 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1742 if (func->name == NULL((void*)0))
1743 func->name = attr.u.str;
1744 break;
1745
1746 case DW_AT_MIPS_linkage_name:
1747 func->name = attr.u.str;
1748 break;
1749
1750 case DW_AT_low_pc:
1751 low_pc = attr.u.val;
1752 break;
1753
1754 case DW_AT_high_pc:
1755 high_pc = attr.u.val;
1756 break;
1757
1758 case DW_AT_ranges:
1759 read_rangelist (unit, &func->arange, attr.u.val);
1760 break;
1761
1762 case DW_AT_decl_file:
1763 func->file = concat_filename (unit->line_table,
1764 attr.u.val);
1765 break;
1766
1767 case DW_AT_decl_line:
1768 func->line = attr.u.val;
1769 break;
1770
1771 default:
1772 break;
1773 }
1774 }
1775 else if (var)
1776 {
1777 switch (attr.name)
1778 {
1779 case DW_AT_name:
1780 var->name = attr.u.str;
1781 break;
1782
1783 case DW_AT_decl_file:
1784 var->file = concat_filename (unit->line_table,
1785 attr.u.val);
1786 break;
1787
1788 case DW_AT_decl_line:
1789 var->line = attr.u.val;
1790 break;
1791
1792 case DW_AT_external:
1793 if (attr.u.val != 0)
1794 var->stack = 0;
1795 break;
1796
1797 case DW_AT_location:
1798 switch (attr.form)
1799 {
1800 case DW_FORM_block:
1801 case DW_FORM_block1:
1802 case DW_FORM_block2:
1803 case DW_FORM_block4:
1804 if (*attr.u.blk->data == DW_OP_addr)
1805 {
1806 var->stack = 0;
1807
1808 /* Verify that DW_OP_addr is the only opcode in the
1809 location, in which case the block size will be 1
1810 plus the address size. */
1811 /* ??? For TLS variables, gcc can emit
1812 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
1813 which we don't handle here yet. */
1814 if (attr.u.blk->size == unit->addr_size + 1U)
1815 var->addr = bfd_get (unit->addr_size * 8,((unit->addr_size * 8) == 8 ? (bfd_vma) (*(unsigned char *
) (attr.u.blk->data + 1) & 0xff) : (unit->addr_size
* 8) == 16 ? ((*((unit->abfd)->xvec->bfd_getx16)) (
attr.u.blk->data + 1)) : (unit->addr_size * 8) == 32 ? (
(*((unit->abfd)->xvec->bfd_getx32)) (attr.u.blk->
data + 1)) : (unit->addr_size * 8) == 64 ? ((*((unit->abfd
)->xvec->bfd_getx64)) (attr.u.blk->data + 1)) : (_bfd_abort
("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c", 1817, __PRETTY_FUNCTION__
), (bfd_vma) - 1))
1816 unit->abfd,((unit->addr_size * 8) == 8 ? (bfd_vma) (*(unsigned char *
) (attr.u.blk->data + 1) & 0xff) : (unit->addr_size
* 8) == 16 ? ((*((unit->abfd)->xvec->bfd_getx16)) (
attr.u.blk->data + 1)) : (unit->addr_size * 8) == 32 ? (
(*((unit->abfd)->xvec->bfd_getx32)) (attr.u.blk->
data + 1)) : (unit->addr_size * 8) == 64 ? ((*((unit->abfd
)->xvec->bfd_getx64)) (attr.u.blk->data + 1)) : (_bfd_abort
("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c", 1817, __PRETTY_FUNCTION__
), (bfd_vma) - 1))
1817 attr.u.blk->data + 1)((unit->addr_size * 8) == 8 ? (bfd_vma) (*(unsigned char *
) (attr.u.blk->data + 1) & 0xff) : (unit->addr_size
* 8) == 16 ? ((*((unit->abfd)->xvec->bfd_getx16)) (
attr.u.blk->data + 1)) : (unit->addr_size * 8) == 32 ? (
(*((unit->abfd)->xvec->bfd_getx32)) (attr.u.blk->
data + 1)) : (unit->addr_size * 8) == 64 ? ((*((unit->abfd
)->xvec->bfd_getx64)) (attr.u.blk->data + 1)) : (_bfd_abort
("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c", 1817, __PRETTY_FUNCTION__
), (bfd_vma) - 1))
;
1818 }
1819 break;
1820
1821 default:
1822 break;
1823 }
1824 break;
1825
1826 default:
1827 break;
1828 }
1829 }
1830 }
1831
1832 if (func && high_pc != 0)
1833 {
1834 arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1835 }
1836
1837 if (abbrev->has_children)
1838 {
1839 nesting_level++;
1840
1841 if (nesting_level >= nested_funcs_size)
1842 {
1843 struct funcinfo **tmp;
1844
1845 nested_funcs_size *= 2;
1846 tmp = bfd_realloc (nested_funcs,
1847 (nested_funcs_size
1848 * sizeof (struct funcinfo *)));
1849 if (tmp == NULL((void*)0))
1850 {
1851 free (nested_funcs);
1852 return FALSE0;
1853 }
1854 nested_funcs = tmp;
1855 }
1856 nested_funcs[nesting_level] = 0;
1857 }
1858 }
1859
1860 free (nested_funcs);
1861 return TRUE1;
1862}
1863
1864/* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1865 includes the compilation unit header that proceeds the DIE's, but
1866 does not include the length field that precedes each compilation
1867 unit header. END_PTR points one past the end of this comp unit.
1868 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1869
1870 This routine does not read the whole compilation unit; only enough
1871 to get to the line number information for the compilation unit. */
1872
1873static struct comp_unit *
1874parse_comp_unit (bfd *abfd,
1875 struct dwarf2_debug *stash,
1876 bfd_vma unit_length,
1877 bfd_byte *info_ptr_unit,
1878 unsigned int offset_size)
1879{
1880 struct comp_unit* unit;
1881 unsigned int version;
1882 bfd_uint64_t abbrev_offset = 0;
1883 unsigned int addr_size;
1884 struct abbrev_info** abbrevs;
1885 unsigned int abbrev_number, bytes_read, i;
1886 struct abbrev_info *abbrev;
1887 struct attribute attr;
1888 bfd_byte *info_ptr = stash->info_ptr;
1889 bfd_byte *end_ptr = info_ptr + unit_length;
1890 bfd_size_type amt;
1891 bfd_vma low_pc = 0;
1892 bfd_vma high_pc = 0;
1893
1894 version = read_2_bytes (abfd, info_ptr);
1895 info_ptr += 2;
1896 BFD_ASSERT (offset_size == 4 || offset_size == 8)do { if (!(offset_size == 4 || offset_size == 8)) bfd_assert(
"/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c",1896); } while
(0)
;
1897 if (offset_size == 4)
1898 abbrev_offset = read_4_bytes (abfd, info_ptr);
1899 else
1900 abbrev_offset = read_8_bytes (abfd, info_ptr);
1901 info_ptr += offset_size;
1902 addr_size = read_1_byte (abfd, info_ptr);
1903 info_ptr += 1;
1904
1905 if (version != 2)
1906 {
1907 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information.")("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."
)
, version);
1908 bfd_set_error (bfd_error_bad_value);
1909 return 0;
1910 }
1911
1912 if (addr_size > sizeof (bfd_vma))
1913 {
1914 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'.")("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."
)
,
1915 addr_size,
1916 (unsigned int) sizeof (bfd_vma));
1917 bfd_set_error (bfd_error_bad_value);
1918 return 0;
1919 }
1920
1921 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1922 {
1923 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1924 bfd_set_error (bfd_error_bad_value);
1925 return 0;
1926 }
1927
1928 /* Read the abbrevs for this compilation unit into a table. */
1929 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1930 if (! abbrevs)
1931 return 0;
1932
1933 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1934 info_ptr += bytes_read;
1935 if (! abbrev_number)
1936 {
1937 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u.")("Dwarf Error: Bad abbrev number: %u."),
1938 abbrev_number);
1939 bfd_set_error (bfd_error_bad_value);
1940 return 0;
1941 }
1942
1943 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1944 if (! abbrev)
1945 {
1946 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u.")("Dwarf Error: Could not find abbrev number %u."),
1947 abbrev_number);
1948 bfd_set_error (bfd_error_bad_value);
1949 return 0;
1950 }
1951
1952 amt = sizeof (struct comp_unit);
1953 unit = bfd_zalloc (abfd, amt);
1954 unit->abfd = abfd;
1955 unit->addr_size = addr_size;
1956 unit->offset_size = offset_size;
1957 unit->abbrevs = abbrevs;
1958 unit->end_ptr = end_ptr;
1959 unit->stash = stash;
1960 unit->info_ptr_unit = info_ptr_unit;
1961
1962 for (i = 0; i < abbrev->num_attrs; ++i)
1963 {
1964 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1965
1966 /* Store the data if it is of an attribute we want to keep in a
1967 partial symbol table. */
1968 switch (attr.name)
1969 {
1970 case DW_AT_stmt_list:
1971 unit->stmtlist = 1;
1972 unit->line_offset = attr.u.val;
1973 break;
1974
1975 case DW_AT_name:
1976 unit->name = attr.u.str;
1977 break;
1978
1979 case DW_AT_low_pc:
1980 low_pc = attr.u.val;
1981 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
1982 this is the base address to use when reading location
1983 lists or range lists. */
1984 unit->base_address = low_pc;
1985 break;
1986
1987 case DW_AT_high_pc:
1988 high_pc = attr.u.val;
1989 break;
1990
1991 case DW_AT_ranges:
1992 read_rangelist (unit, &unit->arange, attr.u.val);
1993 break;
1994
1995 case DW_AT_comp_dir:
1996 {
1997 char *comp_dir = attr.u.str;
1998 if (comp_dir)
1999 {
2000 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2001 directory, get rid of it. */
2002 char *cp = strchr (comp_dir, ':');
2003
2004 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2005 comp_dir = cp + 1;
2006 }
2007 unit->comp_dir = comp_dir;
2008 break;
2009 }
2010
2011 default:
2012 break;
2013 }
2014 }
2015 if (high_pc != 0)
2016 {
2017 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
2018 }
2019
2020 unit->first_child_die_ptr = info_ptr;
2021 return unit;
2022}
2023
2024/* Return TRUE if UNIT may contain the address given by ADDR. When
2025 there are functions written entirely with inline asm statements, the
2026 range info in the compilation unit header may not be correct. We
2027 need to consult the line info table to see if a compilation unit
2028 really contains the given address. */
2029
2030static bfd_boolean
2031comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2032{
2033 struct arange *arange;
2034
2035 if (unit->error)
2036 return FALSE0;
2037
2038 arange = &unit->arange;
2039 do
2040 {
2041 if (addr >= arange->low && addr < arange->high)
2042 return TRUE1;
2043 arange = arange->next;
2044 }
2045 while (arange);
2046
2047 return FALSE0;
2048}
2049
2050/* If UNIT contains ADDR, set the output parameters to the values for
2051 the line containing ADDR. The output parameters, FILENAME_PTR,
2052 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2053 to be filled in.
2054
2055 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2056 FALSE otherwise. */
2057
2058static bfd_boolean
2059comp_unit_find_nearest_line (struct comp_unit *unit,
2060 bfd_vma addr,
2061 const char **filename_ptr,
2062 const char **functionname_ptr,
2063 unsigned int *linenumber_ptr,
2064 struct dwarf2_debug *stash)
2065{
2066 bfd_boolean line_p;
2067 bfd_boolean func_p;
2068 struct funcinfo *function;
2069
2070 if (unit->error)
2071 return FALSE0;
2072
2073 if (! unit->line_table)
2074 {
2075 if (! unit->stmtlist)
2076 {
2077 unit->error = 1;
2078 return FALSE0;
2079 }
2080
2081 unit->line_table = decode_line_info (unit, stash);
2082
2083 if (! unit->line_table)
2084 {
2085 unit->error = 1;
2086 return FALSE0;
2087 }
2088
2089 if (unit->first_child_die_ptr < unit->end_ptr
2090 && ! scan_unit_for_symbols (unit))
2091 {
2092 unit->error = 1;
2093 return FALSE0;
2094 }
2095 }
2096
2097 function = NULL((void*)0);
2098 func_p = lookup_address_in_function_table (unit, addr,
2099 &function, functionname_ptr);
2100 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2101 stash->inliner_chain = function;
2102 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2103 function, filename_ptr,
2104 linenumber_ptr);
2105 return line_p || func_p;
2106}
2107
2108/* If UNIT contains SYM at ADDR, set the output parameters to the
2109 values for the line containing SYM. The output parameters,
2110 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2111 filled in.
2112
2113 Return TRUE if UNIT contains SYM, and no errors were encountered;
2114 FALSE otherwise. */
2115
2116static bfd_boolean
2117comp_unit_find_line (struct comp_unit *unit,
2118 asymbol *sym,
2119 bfd_vma addr,
2120 const char **filename_ptr,
2121 unsigned int *linenumber_ptr,
2122 struct dwarf2_debug *stash)
2123{
2124 if (unit->error)
2125 return FALSE0;
2126
2127 if (! unit->line_table)
2128 {
2129 if (! unit->stmtlist)
2130 {
2131 unit->error = 1;
2132 return FALSE0;
2133 }
2134
2135 unit->line_table = decode_line_info (unit, stash);
2136
2137 if (! unit->line_table)
2138 {
2139 unit->error = 1;
2140 return FALSE0;
2141 }
2142
2143 if (unit->first_child_die_ptr < unit->end_ptr
2144 && ! scan_unit_for_symbols (unit))
2145 {
2146 unit->error = 1;
2147 return FALSE0;
2148 }
2149 }
2150
2151 if (sym->flags & BSF_FUNCTION0x10)
2152 return lookup_symbol_in_function_table (unit, sym, addr,
2153 filename_ptr,
2154 linenumber_ptr);
2155 else
2156 return lookup_symbol_in_variable_table (unit, sym, addr,
2157 filename_ptr,
2158 linenumber_ptr);
2159}
2160
2161/* Locate a section in a BFD containing debugging info. The search starts
2162 from the section after AFTER_SEC, or from the first section in the BFD if
2163 AFTER_SEC is NULL. The search works by examining the names of the
2164 sections. There are two permissiable names. The first is .debug_info.
2165 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2166 This is a variation on the .debug_info section which has a checksum
2167 describing the contents appended onto the name. This allows the linker to
2168 identify and discard duplicate debugging sections for different
2169 compilation units. */
2170#define DWARF2_DEBUG_INFO".debug_info" ".debug_info"
2171#define GNU_LINKONCE_INFO".gnu.linkonce.wi." ".gnu.linkonce.wi."
2172
2173static asection *
2174find_debug_info (bfd *abfd, asection *after_sec)
2175{
2176 asection * msec;
2177
2178 if (after_sec)
2179 msec = after_sec->next;
2180 else
2181 msec = abfd->sections;
2182
2183 while (msec)
2184 {
2185 if (strcmp (msec->name, DWARF2_DEBUG_INFO".debug_info") == 0)
2186 return msec;
2187
2188 if (strncmp (msec->name, GNU_LINKONCE_INFO".gnu.linkonce.wi.", strlen (GNU_LINKONCE_INFO".gnu.linkonce.wi.")) == 0)
2189 return msec;
2190
2191 msec = msec->next;
2192 }
2193
2194 return NULL((void*)0);
2195}
2196
2197/* Unset vmas for loadable sections in STASH. */
2198
2199static void
2200unset_sections (struct dwarf2_debug *stash)
2201{
2202 unsigned int i;
2203 struct loadable_section *p;
2204
2205 i = stash->loadable_section_count;
2206 p = stash->loadable_sections;
2207 for (; i > 0; i--, p++)
2208 p->section->vma = 0;
2209}
2210
2211/* Set unique vmas for loadable sections in ABFD and save vmas in
2212 STASH for unset_sections. */
2213
2214static bfd_boolean
2215place_sections (bfd *abfd, struct dwarf2_debug *stash)
2216{
2217 struct loadable_section *p;
2218 unsigned int i;
2219
2220 if (stash->loadable_section_count != 0)
2221 {
2222 i = stash->loadable_section_count;
2223 p = stash->loadable_sections;
2224 for (; i > 0; i--, p++)
2225 p->section->vma = p->adj_vma;
2226 }
2227 else
2228 {
2229 asection *sect;
2230 bfd_vma last_vma = 0;
2231 bfd_size_type amt;
2232 struct loadable_section *p;
2233
2234 i = 0;
2235 for (sect = abfd->sections; sect != NULL((void*)0); sect = sect->next)
2236 {
2237 bfd_size_type sz;
2238
2239 if (sect->vma != 0 || (sect->flags & SEC_LOAD0x002) == 0)
2240 continue;
2241
2242 sz = sect->rawsize ? sect->rawsize : sect->size;
2243 if (sz == 0)
2244 continue;
2245
2246 i++;
2247 }
2248
2249 amt = i * sizeof (struct loadable_section);
2250 p = (struct loadable_section *) bfd_zalloc (abfd, amt);
2251 if (! p)
2252 return FALSE0;
2253
2254 stash->loadable_sections = p;
2255 stash->loadable_section_count = i;
2256
2257 for (sect = abfd->sections; sect != NULL((void*)0); sect = sect->next)
2258 {
2259 bfd_size_type sz;
2260
2261 if (sect->vma != 0 || (sect->flags & SEC_LOAD0x002) == 0)
2262 continue;
2263
2264 sz = sect->rawsize ? sect->rawsize : sect->size;
2265 if (sz == 0)
2266 continue;
2267
2268 p->section = sect;
2269 if (last_vma != 0)
2270 {
2271 /* Align the new address to the current section
2272 alignment. */
2273 last_vma = ((last_vma
2274 + ~((bfd_vma) -1 << sect->alignment_power))
2275 & ((bfd_vma) -1 << sect->alignment_power));
2276 sect->vma = last_vma;
2277 }
2278 p->adj_vma = sect->vma;
2279 last_vma += sect->vma + sz;
2280
2281 p++;
2282 }
2283 }
2284
2285 return TRUE1;
2286}
2287
2288/* The DWARF2 version of find_nearest_line. Return TRUE if the line
2289 is found without error. ADDR_SIZE is the number of bytes in the
2290 initial .debug_info length field and in the abbreviation offset.
2291 You may use zero to indicate that the default value should be
2292 used. */
2293
2294bfd_boolean
2295_bfd_dwarf2_find_nearest_line (bfd *abfd,
2296 asection *section,
2297 asymbol **symbols,
2298 bfd_vma offset,
2299 const char **filename_ptr,
2300 const char **functionname_ptr,
2301 unsigned int *linenumber_ptr,
2302 unsigned int addr_size,
2303 void **pinfo)
2304{
2305 /* Read each compilation unit from the section .debug_info, and check
2306 to see if it contains the address we are searching for. If yes,
2307 lookup the address, and return the line number info. If no, go
2308 on to the next compilation unit.
2309
2310 We keep a list of all the previously read compilation units, and
2311 a pointer to the next un-read compilation unit. Check the
2312 previously read units before reading more. */
2313 struct dwarf2_debug *stash;
2314
2315 /* What address are we looking for? */
2316 bfd_vma addr;
2317
2318 struct comp_unit* each;
2319
2320 bfd_vma found = FALSE0;
2321
2322 stash = *pinfo;
2323
2324 if (! stash)
2325 {
2326 bfd_size_type amt = sizeof (struct dwarf2_debug);
2327
2328 stash = bfd_zalloc (abfd, amt);
2329 if (! stash)
2330 return FALSE0;
2331 }
2332
2333 /* In a relocatable file, 2 functions may have the same address.
2334 We change the section vma so that they won't overlap. */
2335 if ((abfd->flags & (EXEC_P0x02 | DYNAMIC0x40)) == 0)
2336 {
2337 if (! place_sections (abfd, stash))
2338 return FALSE0;
2339 }
2340
2341 addr = offset;
2342 if (section->output_section)
2343 addr += section->output_section->vma + section->output_offset;
2344 else
2345 addr += section->vma;
2346 *filename_ptr = NULL((void*)0);
2347 *functionname_ptr = NULL((void*)0);
2348 *linenumber_ptr = 0;
2349
2350 /* The DWARF2 spec says that the initial length field, and the
2351 offset of the abbreviation table, should both be 4-byte values.
2352 However, some compilers do things differently. */
2353 if (addr_size == 0)
2354 addr_size = 4;
2355 BFD_ASSERT (addr_size == 4 || addr_size == 8)do { if (!(addr_size == 4 || addr_size == 8)) bfd_assert("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
,2355); } while (0)
;
2356
2357 if (! *pinfo)
2358 {
2359 bfd_size_type total_size;
2360 asection *msec;
2361
2362 *pinfo = stash;
2363
2364 msec = find_debug_info (abfd, NULL((void*)0));
2365 if (! msec)
2366 /* No dwarf2 info. Note that at this point the stash
2367 has been allocated, but contains zeros, this lets
2368 future calls to this function fail quicker. */
2369 goto done;
2370
2371 /* There can be more than one DWARF2 info section in a BFD these days.
2372 Read them all in and produce one large stash. We do this in two
2373 passes - in the first pass we just accumulate the section sizes.
2374 In the second pass we read in the section's contents. The allows
2375 us to avoid reallocing the data as we add sections to the stash. */
2376 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2377 total_size += msec->size;
2378
2379 stash->info_ptr = bfd_alloc (abfd, total_size);
2380 if (stash->info_ptr == NULL((void*)0))
2381 goto done;
2382
2383 stash->info_ptr_end = stash->info_ptr;
2384
2385 for (msec = find_debug_info (abfd, NULL((void*)0));
2386 msec;
2387 msec = find_debug_info (abfd, msec))
2388 {
2389 bfd_size_type size;
2390 bfd_size_type start;
2391
2392 size = msec->size;
2393 if (size == 0)
2394 continue;
2395
2396 start = stash->info_ptr_end - stash->info_ptr;
2397
2398 if ((bfd_simple_get_relocated_section_contents
2399 (abfd, msec, stash->info_ptr + start, symbols)) == NULL((void*)0))
2400 continue;
2401
2402 stash->info_ptr_end = stash->info_ptr + start + size;
2403 }
2404
2405 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size)do { if (!(stash->info_ptr_end == stash->info_ptr + total_size
)) bfd_assert("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
,2405); } while (0)
;
2406
2407 stash->sec = find_debug_info (abfd, NULL((void*)0));
2408 stash->sec_info_ptr = stash->info_ptr;
2409 stash->syms = symbols;
2410 }
2411
2412 /* A null info_ptr indicates that there is no dwarf2 info
2413 (or that an error occured while setting up the stash). */
2414 if (! stash->info_ptr)
2415 goto done;
2416
2417 stash->inliner_chain = NULL((void*)0);
2418
2419 /* Check the previously read comp. units first. */
2420 for (each = stash->all_comp_units; each; each = each->next_unit)
2421 if (comp_unit_contains_address (each, addr)
2422 && comp_unit_find_nearest_line (each, addr, filename_ptr,
2423 functionname_ptr,
2424 linenumber_ptr, stash))
2425 {
2426 found = TRUE1;
2427 goto done;
2428 }
2429
2430 /* Read each remaining comp. units checking each as they are read. */
2431 while (stash->info_ptr < stash->info_ptr_end)
2432 {
2433 bfd_vma length;
2434 unsigned int offset_size = addr_size;
2435 bfd_byte *info_ptr_unit = stash->info_ptr;
2436
2437 length = read_4_bytes (abfd, stash->info_ptr);
2438 /* A 0xffffff length is the DWARF3 way of indicating we use
2439 64-bit offsets, instead of 32-bit offsets. */
2440 if (length == 0xffffffff)
2441 {
2442 offset_size = 8;
2443 length = read_8_bytes (abfd, stash->info_ptr + 4);
2444 stash->info_ptr += 12;
2445 }
2446 /* A zero length is the IRIX way of indicating 64-bit offsets,
2447 mostly because the 64-bit length will generally fit in 32
2448 bits, and the endianness helps. */
2449 else if (length == 0)
2450 {
2451 offset_size = 8;
2452 length = read_4_bytes (abfd, stash->info_ptr + 4);
2453 stash->info_ptr += 8;
2454 }
2455 /* In the absence of the hints above, we assume addr_size-sized
2456 offsets, for backward-compatibility with pre-DWARF3 64-bit
2457 platforms. */
2458 else if (addr_size == 8)
2459 {
2460 length = read_8_bytes (abfd, stash->info_ptr);
2461 stash->info_ptr += 8;
2462 }
2463 else
2464 stash->info_ptr += 4;
2465
2466 if (length > 0)
2467 {
2468 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2469 offset_size);
2470 stash->info_ptr += length;
2471
2472 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2473 == stash->sec->size)
2474 {
2475 stash->sec = find_debug_info (abfd, stash->sec);
2476 stash->sec_info_ptr = stash->info_ptr;
2477 }
2478
2479 if (each)
2480 {
2481 each->next_unit = stash->all_comp_units;
2482 stash->all_comp_units = each;
2483
2484 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2485 compilation units. If we don't have them (i.e.,
2486 unit->high == 0), we need to consult the line info
2487 table to see if a compilation unit contains the given
2488 address. */
2489 if ((each->arange.high == 0
2490 || comp_unit_contains_address (each, addr))
2491 && comp_unit_find_nearest_line (each, addr,
2492 filename_ptr,
2493 functionname_ptr,
2494 linenumber_ptr,
2495 stash))
2496 {
2497 found = TRUE1;
2498 goto done;
2499 }
2500 }
2501 }
2502 }
2503
2504done:
2505 if ((abfd->flags & (EXEC_P0x02 | DYNAMIC0x40)) == 0)
2506 unset_sections (stash);
2507
2508 return found;
2509}
2510
2511/* The DWARF2 version of find_line. Return TRUE if the line is found
2512 without error. */
2513
2514bfd_boolean
2515_bfd_dwarf2_find_line (bfd *abfd,
2516 asymbol **symbols,
2517 asymbol *symbol,
2518 const char **filename_ptr,
2519 unsigned int *linenumber_ptr,
2520 unsigned int addr_size,
2521 void **pinfo)
2522{
2523 /* Read each compilation unit from the section .debug_info, and check
2524 to see if it contains the address we are searching for. If yes,
2525 lookup the address, and return the line number info. If no, go
2526 on to the next compilation unit.
2527
2528 We keep a list of all the previously read compilation units, and
2529 a pointer to the next un-read compilation unit. Check the
2530 previously read units before reading more. */
2531 struct dwarf2_debug *stash;
2532
2533 /* What address are we looking for? */
2534 bfd_vma addr;
2535
2536 struct comp_unit* each;
2537
2538 asection *section;
2539
2540 bfd_boolean found = FALSE0;
2541
2542 section = bfd_get_section (symbol)((symbol)->section);
2543
2544 stash = *pinfo;
2545
2546 if (! stash)
2547 {
2548 bfd_size_type amt = sizeof (struct dwarf2_debug);
2549
2550 stash = bfd_zalloc (abfd, amt);
2551 if (! stash)
2552 return FALSE0;
2553 }
2554
2555 /* In a relocatable file, 2 functions may have the same address.
2556 We change the section vma so that they won't overlap. */
2557 if (!stash && (abfd->flags & (EXEC_P0x02 | DYNAMIC0x40)) == 0)
2558 {
2559 if (! place_sections (abfd, stash))
2560 return FALSE0;
2561 }
2562
2563 addr = symbol->value;
2564 if (section->output_section)
2565 addr += section->output_section->vma + section->output_offset;
2566 else
2567 addr += section->vma;
2568
2569 *filename_ptr = NULL((void*)0);
2570 *filename_ptr = NULL((void*)0);
2571 *linenumber_ptr = 0;
2572
2573 if (! *pinfo)
2574 {
2575 bfd_size_type total_size;
2576 asection *msec;
2577
2578 *pinfo = stash;
2579
2580 msec = find_debug_info (abfd, NULL((void*)0));
2581 if (! msec)
2582 /* No dwarf2 info. Note that at this point the stash
2583 has been allocated, but contains zeros, this lets
2584 future calls to this function fail quicker. */
2585 goto done;
2586
2587 /* There can be more than one DWARF2 info section in a BFD these days.
2588 Read them all in and produce one large stash. We do this in two
2589 passes - in the first pass we just accumulate the section sizes.
2590 In the second pass we read in the section's contents. The allows
2591 us to avoid reallocing the data as we add sections to the stash. */
2592 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2593 total_size += msec->size;
2594
2595 stash->info_ptr = bfd_alloc (abfd, total_size);
2596 if (stash->info_ptr == NULL((void*)0))
2597 goto done;
2598
2599 stash->info_ptr_end = stash->info_ptr;
2600
2601 for (msec = find_debug_info (abfd, NULL((void*)0));
2602 msec;
2603 msec = find_debug_info (abfd, msec))
2604 {
2605 bfd_size_type size;
2606 bfd_size_type start;
2607
2608 size = msec->size;
2609 if (size == 0)
2610 continue;
2611
2612 start = stash->info_ptr_end - stash->info_ptr;
2613
2614 if ((bfd_simple_get_relocated_section_contents
2615 (abfd, msec, stash->info_ptr + start, symbols)) == NULL((void*)0))
2616 continue;
2617
2618 stash->info_ptr_end = stash->info_ptr + start + size;
2619 }
2620
2621 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size)do { if (!(stash->info_ptr_end == stash->info_ptr + total_size
)) bfd_assert("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
,2621); } while (0)
;
2622
2623 stash->sec = find_debug_info (abfd, NULL((void*)0));
2624 stash->sec_info_ptr = stash->info_ptr;
2625 stash->syms = symbols;
2626 }
2627
2628 /* A null info_ptr indicates that there is no dwarf2 info
2629 (or that an error occured while setting up the stash). */
2630 if (! stash->info_ptr)
2631 goto done;
2632
2633 stash->inliner_chain = NULL((void*)0);
2634
2635 /* Check the previously read comp. units first. */
2636 for (each = stash->all_comp_units; each; each = each->next_unit)
2637 if ((symbol->flags & BSF_FUNCTION0x10) == 0
2638 || comp_unit_contains_address (each, addr))
2639 {
2640 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
2641 linenumber_ptr, stash);
2642 if (found)
2643 goto done;
2644 }
2645
2646 /* The DWARF2 spec says that the initial length field, and the
2647 offset of the abbreviation table, should both be 4-byte values.
2648 However, some compilers do things differently. */
2649 if (addr_size == 0)
2650 addr_size = 4;
2651 BFD_ASSERT (addr_size == 4 || addr_size == 8)do { if (!(addr_size == 4 || addr_size == 8)) bfd_assert("/usr/src/gnu/usr.bin/binutils-2.17/bfd/dwarf2.c"
,2651); } while (0)
;
2652
2653 /* Read each remaining comp. units checking each as they are read. */
2654 while (stash->info_ptr < stash->info_ptr_end)
2655 {
2656 bfd_vma length;
2657 unsigned int offset_size = addr_size;
2658 bfd_byte *info_ptr_unit = stash->info_ptr;
2659
2660 length = read_4_bytes (abfd, stash->info_ptr);
2661 /* A 0xffffff length is the DWARF3 way of indicating we use
2662 64-bit offsets, instead of 32-bit offsets. */
2663 if (length == 0xffffffff)
2664 {
2665 offset_size = 8;
2666 length = read_8_bytes (abfd, stash->info_ptr + 4);
2667 stash->info_ptr += 12;
2668 }
2669 /* A zero length is the IRIX way of indicating 64-bit offsets,
2670 mostly because the 64-bit length will generally fit in 32
2671 bits, and the endianness helps. */
2672 else if (length == 0)
2673 {
2674 offset_size = 8;
2675 length = read_4_bytes (abfd, stash->info_ptr + 4);
2676 stash->info_ptr += 8;
2677 }
2678 /* In the absence of the hints above, we assume addr_size-sized
2679 offsets, for backward-compatibility with pre-DWARF3 64-bit
2680 platforms. */
2681 else if (addr_size == 8)
2682 {
2683 length = read_8_bytes (abfd, stash->info_ptr);
2684 stash->info_ptr += 8;
2685 }
2686 else
2687 stash->info_ptr += 4;
2688
2689 if (length > 0)
2690 {
2691 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2692 offset_size);
2693 stash->info_ptr += length;
2694
2695 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2696 == stash->sec->size)
2697 {
2698 stash->sec = find_debug_info (abfd, stash->sec);
2699 stash->sec_info_ptr = stash->info_ptr;
2700 }
2701
2702 if (each)
2703 {
2704 each->next_unit = stash->all_comp_units;
2705 stash->all_comp_units = each;
2706
2707 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2708 compilation units. If we don't have them (i.e.,
2709 unit->high == 0), we need to consult the line info
2710 table to see if a compilation unit contains the given
2711 address. */
2712 found = (((symbol->flags & BSF_FUNCTION0x10) == 0
2713 || each->arange.high <= 0
2714 || comp_unit_contains_address (each, addr))
2715 && comp_unit_find_line (each, symbol, addr,
2716 filename_ptr,
2717 linenumber_ptr,
2718 stash));
2719 if (found)
2720 goto done;
2721 }
2722 }
2723 }
2724
2725done:
2726 if ((abfd->flags & (EXEC_P0x02 | DYNAMIC0x40)) == 0)
2727 unset_sections (stash);
2728
2729 return found;
2730}
2731
2732bfd_boolean
2733_bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
2734 const char **filename_ptr,
2735 const char **functionname_ptr,
2736 unsigned int *linenumber_ptr,
2737 void **pinfo)
2738{
2739 struct dwarf2_debug *stash;
2740
2741 stash = *pinfo;
2742 if (stash)
2743 {
2744 struct funcinfo *func = stash->inliner_chain;
2745 if (func && func->caller_func)
2746 {
2747 *filename_ptr = func->caller_file;
2748 *functionname_ptr = func->caller_func->name;
2749 *linenumber_ptr = func->caller_line;
2750 stash->inliner_chain = func->caller_func;
2751 return (TRUE1);
2752 }
2753 }
2754
2755 return (FALSE0);
2756}
2757
2758void
2759_bfd_dwarf2_cleanup_debug_info (bfd *abfd)
2760{
2761 struct comp_unit *each;
2762 struct dwarf2_debug *stash;
2763
2764 if (abfd == NULL((void*)0) || elf_tdata (abfd)((abfd) -> tdata.elf_obj_data) == NULL((void*)0))
2765 return;
2766
2767 stash = elf_tdata (abfd)((abfd) -> tdata.elf_obj_data)->dwarf2_find_line_info;
2768
2769 if (stash == NULL((void*)0))
2770 return;
2771
2772 for (each = stash->all_comp_units; each; each = each->next_unit)
2773 {
2774 struct abbrev_info **abbrevs = each->abbrevs;
2775 size_t i;
2776
2777 for (i = 0; i < ABBREV_HASH_SIZE121; i++)
2778 {
2779 struct abbrev_info *abbrev = abbrevs[i];
2780
2781 while (abbrev)
2782 {
2783 free (abbrev->attrs);
2784 abbrev = abbrev->next;
2785 }
2786 }
2787
2788 if (each->line_table)
2789 {
2790 free (each->line_table->dirs);
2791 free (each->line_table->files);
2792 }
2793 }
2794
2795 free (stash->dwarf_abbrev_buffer);
2796 free (stash->dwarf_line_buffer);
2797 free (stash->dwarf_ranges_buffer);
2798}