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