Coverage Report

Created: 2025-07-08 11:15

/src/binutils-gdb/bfd/dwarf2.c
Line
Count
Source (jump to first uncovered line)
1
/* DWARF 2 support.
2
   Copyright (C) 1994-2025 Free Software Foundation, Inc.
3
4
   Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
5
   (gavin@cygnus.com).
6
7
   From the dwarf2read.c header:
8
   Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
9
   Inc.  with support from Florida State University (under contract
10
   with the Ada Joint Program Office), and Silicon Graphics, Inc.
11
   Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
12
   based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13
   support in dwarfread.c
14
15
   This file is part of BFD.
16
17
   This program is free software; you can redistribute it and/or modify
18
   it under the terms of the GNU General Public License as published by
19
   the Free Software Foundation; either version 3 of the License, or (at
20
   your option) any later version.
21
22
   This program is distributed in the hope that it will be useful, but
23
   WITHOUT ANY WARRANTY; without even the implied warranty of
24
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
   General Public License for more details.
26
27
   You should have received a copy of the GNU General Public License
28
   along with this program; if not, write to the Free Software
29
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
30
   MA 02110-1301, USA.  */
31
32
#include "sysdep.h"
33
#include "bfd.h"
34
#include "libiberty.h"
35
#include "demangle.h"
36
#include "libbfd.h"
37
#include "elf-bfd.h"
38
#include "dwarf2.h"
39
#include "hashtab.h"
40
#include "splay-tree.h"
41
42
/* The data in the .debug_line statement prologue looks like this.  */
43
44
struct line_head
45
{
46
  bfd_vma total_length;
47
  unsigned short version;
48
  bfd_vma prologue_length;
49
  unsigned char minimum_instruction_length;
50
  unsigned char maximum_ops_per_insn;
51
  unsigned char default_is_stmt;
52
  int line_base;
53
  unsigned char line_range;
54
  unsigned char opcode_base;
55
  unsigned char *standard_opcode_lengths;
56
};
57
58
/* Attributes have a name and a value.  */
59
60
struct attribute
61
{
62
  enum dwarf_attribute name;
63
  enum dwarf_form form;
64
  union
65
  {
66
    char *str;
67
    struct dwarf_block *blk;
68
    uint64_t val;
69
    int64_t sval;
70
  }
71
  u;
72
};
73
74
/* Blocks are a bunch of untyped bytes.  */
75
struct dwarf_block
76
{
77
  unsigned int size;
78
  bfd_byte *data;
79
};
80
81
struct adjusted_section
82
{
83
  asection *section;
84
  bfd_vma adj_vma;
85
  bfd_vma orig_vma;
86
};
87
88
/* A trie to map quickly from address range to compilation unit.
89
90
   This is a fairly standard radix-256 trie, used to quickly locate which
91
   compilation unit any given address belongs to.  Given that each compilation
92
   unit may register hundreds of very small and unaligned ranges (which may
93
   potentially overlap, due to inlining and other concerns), and a large
94
   program may end up containing hundreds of thousands of such ranges, we cannot
95
   scan through them linearly without undue slowdown.
96
97
   We use a hybrid trie to avoid memory explosion: There are two types of trie
98
   nodes, leaves and interior nodes.  (Almost all nodes are leaves, so they
99
   take up the bulk of the memory usage.) Leaves contain a simple array of
100
   ranges (high/low address) and which compilation unit contains those ranges,
101
   and when we get to a leaf, we scan through it linearly.  Interior nodes
102
   contain pointers to 256 other nodes, keyed by the next byte of the address.
103
   So for a 64-bit address like 0x1234567abcd, we would start at the root and go
104
   down child[0x00]->child[0x00]->child[0x01]->child[0x23]->child[0x45] etc.,
105
   until we hit a leaf.  (Nodes are, in general, leaves until they exceed the
106
   default allocation of 16 elements, at which point they are converted to
107
   interior node if possible.) This gives us near-constant lookup times;
108
   the only thing that can be costly is if there are lots of overlapping ranges
109
   within a single 256-byte segment of the binary, in which case we have to
110
   scan through them all to find the best match.
111
112
   For a binary with few ranges, we will in practice only have a single leaf
113
   node at the root, containing a simple array.  Thus, the scheme is efficient
114
   for both small and large binaries.
115
 */
116
117
/* Experiments have shown 16 to be a memory-efficient default leaf size.
118
   The only case where a leaf will hold more memory than this, is at the
119
   bottomost level (covering 256 bytes in the binary), where we'll expand
120
   the leaf to be able to hold more ranges if needed.
121
 */
122
653k
#define TRIE_LEAF_SIZE 16
123
124
/* All trie_node pointers will really be trie_leaf or trie_interior,
125
   but they have this common head.  */
126
struct trie_node
127
{
128
  /* If zero, we are an interior node.
129
     Otherwise, how many ranges we have room for in this leaf.  */
130
  unsigned int num_room_in_leaf;
131
};
132
133
struct trie_leaf
134
{
135
  struct trie_node head;
136
  unsigned int num_stored_in_leaf;
137
  struct {
138
    struct comp_unit *unit;
139
    bfd_vma low_pc, high_pc;
140
  } ranges[];
141
};
142
143
struct trie_interior
144
{
145
  struct trie_node head;
146
  struct trie_node *children[256];
147
};
148
149
static struct trie_node *alloc_trie_leaf (bfd *abfd)
150
326k
{
151
326k
  struct trie_leaf *leaf;
152
326k
  size_t amt = sizeof (*leaf) + TRIE_LEAF_SIZE * sizeof (leaf->ranges[0]);
153
326k
  leaf = bfd_zalloc (abfd, amt);
154
326k
  if (leaf == NULL)
155
0
    return NULL;
156
326k
  leaf->head.num_room_in_leaf = TRIE_LEAF_SIZE;
157
326k
  return &leaf->head;
158
326k
}
159
160
struct addr_range
161
{
162
  bfd_byte *start;
163
  bfd_byte *end;
164
};
165
166
/* Return true if address range do intersect.  */
167
168
static bool
169
addr_range_intersects (struct addr_range *r1, struct addr_range *r2)
170
110k
{
171
110k
  return (r1->start <= r2->start && r2->start < r1->end)
172
110k
    || (r1->start <= (r2->end - 1) && (r2->end - 1) < r1->end);
173
110k
}
174
175
/* Compare function for splay tree of addr_ranges.  */
176
177
static int
178
splay_tree_compare_addr_range (splay_tree_key xa, splay_tree_key xb)
179
55.2k
{
180
55.2k
  struct addr_range *r1 = (struct addr_range *) xa;
181
55.2k
  struct addr_range *r2 = (struct addr_range *) xb;
182
183
55.2k
  if (addr_range_intersects (r1, r2) || addr_range_intersects (r2, r1))
184
0
    return 0;
185
55.2k
  else if (r1->end <= r2->start)
186
27.6k
    return -1;
187
27.6k
  else
188
27.6k
    return 1;
189
55.2k
}
190
191
/* Splay tree release function for keys (addr_range).  */
192
193
static void
194
splay_tree_free_addr_range (splay_tree_key key)
195
15.5k
{
196
15.5k
  free ((struct addr_range *)key);
197
15.5k
}
198
199
struct dwarf2_debug_file
200
{
201
  /* The actual bfd from which debug info was loaded.  Might be
202
     different to orig_bfd because of gnu_debuglink sections.  */
203
  bfd *bfd_ptr;
204
205
  /* Pointer to the symbol table.  */
206
  asymbol **syms;
207
208
  /* The current info pointer for the .debug_info section being parsed.  */
209
  bfd_byte *info_ptr;
210
211
  /* A pointer to the memory block allocated for .debug_info sections.  */
212
  bfd_byte *dwarf_info_buffer;
213
214
  /* Length of the loaded .debug_info sections.  */
215
  bfd_size_type dwarf_info_size;
216
217
  /* Pointer to the .debug_abbrev section loaded into memory.  */
218
  bfd_byte *dwarf_abbrev_buffer;
219
220
  /* Length of the loaded .debug_abbrev section.  */
221
  bfd_size_type dwarf_abbrev_size;
222
223
  /* Buffer for decode_line_info.  */
224
  bfd_byte *dwarf_line_buffer;
225
226
  /* Length of the loaded .debug_line section.  */
227
  bfd_size_type dwarf_line_size;
228
229
  /* Pointer to the .debug_str section loaded into memory.  */
230
  bfd_byte *dwarf_str_buffer;
231
232
  /* Length of the loaded .debug_str section.  */
233
  bfd_size_type dwarf_str_size;
234
235
  /* Pointer to the .debug_str_offsets section loaded into memory.  */
236
  bfd_byte *dwarf_str_offsets_buffer;
237
238
  /* Length of the loaded .debug_str_offsets section.  */
239
  bfd_size_type dwarf_str_offsets_size;
240
241
  /* Pointer to the .debug_addr section loaded into memory.  */
242
  bfd_byte *dwarf_addr_buffer;
243
244
  /* Length of the loaded .debug_addr section.  */
245
  bfd_size_type dwarf_addr_size;
246
247
  /* Pointer to the .debug_line_str section loaded into memory.  */
248
  bfd_byte *dwarf_line_str_buffer;
249
250
  /* Length of the loaded .debug_line_str section.  */
251
  bfd_size_type dwarf_line_str_size;
252
253
  /* Pointer to the .debug_ranges section loaded into memory.  */
254
  bfd_byte *dwarf_ranges_buffer;
255
256
  /* Length of the loaded .debug_ranges section.  */
257
  bfd_size_type dwarf_ranges_size;
258
259
  /* Pointer to the .debug_rnglists section loaded into memory.  */
260
  bfd_byte *dwarf_rnglists_buffer;
261
262
  /* Length of the loaded .debug_rnglists section.  */
263
  bfd_size_type dwarf_rnglists_size;
264
265
  /* A list of all previously read comp_units.  */
266
  struct comp_unit *all_comp_units;
267
268
  /* A list of all previously read comp_units with no ranges (yet).  */
269
  struct comp_unit *all_comp_units_without_ranges;
270
271
  /* Last comp unit in list above.  */
272
  struct comp_unit *last_comp_unit;
273
274
  /* Line table at line_offset zero.  */
275
  struct line_info_table *line_table;
276
277
  /* Hash table to map offsets to decoded abbrevs.  */
278
  htab_t abbrev_offsets;
279
280
  /* Root of a trie to map addresses to compilation units.  */
281
  struct trie_node *trie_root;
282
283
  /* Splay tree to map info_ptr address to compilation units.  */
284
  splay_tree comp_unit_tree;
285
};
286
287
struct dwarf2_debug
288
{
289
  /* Names of the debug sections.  */
290
  const struct dwarf_debug_section *debug_sections;
291
292
  /* Per-file stuff.  */
293
  struct dwarf2_debug_file f, alt;
294
295
  /* If the most recent call to bfd_find_nearest_line was given an
296
     address in an inlined function, preserve a pointer into the
297
     calling chain for subsequent calls to bfd_find_inliner_info to
298
     use.  */
299
  struct funcinfo *inliner_chain;
300
301
  /* Section VMAs at the time the stash was built.  */
302
  bfd_vma *sec_vma;
303
  /* Number of sections in the SEC_VMA table.  */
304
  unsigned int sec_vma_count;
305
306
  /* Number of sections whose VMA we must adjust.  */
307
  int adjusted_section_count;
308
309
  /* Array of sections with adjusted VMA.  */
310
  struct adjusted_section *adjusted_sections;
311
312
  /* Used to validate the cached debug data.  */
313
  unsigned int orig_bfd_id;
314
315
  /* Number of times find_line is called.  This is used in
316
     the heuristic for enabling the info hash tables.  */
317
  int info_hash_count;
318
319
66.8k
#define STASH_INFO_HASH_TRIGGER    100
320
321
  /* Hash table mapping symbol names to function infos.  */
322
  struct info_hash_table *funcinfo_hash_table;
323
324
  /* Hash table mapping symbol names to variable infos.  */
325
  struct info_hash_table *varinfo_hash_table;
326
327
  /* Head of comp_unit list in the last hash table update.  */
328
  struct comp_unit *hash_units_head;
329
330
  /* Status of info hash.  */
331
  int info_hash_status;
332
239k
#define STASH_INFO_HASH_OFF    0
333
478k
#define STASH_INFO_HASH_ON     1
334
297
#define STASH_INFO_HASH_DISABLED   2
335
336
  /* True if we opened bfd_ptr.  */
337
  bool close_on_cleanup;
338
};
339
340
struct arange
341
{
342
  struct arange *next;
343
  bfd_vma low;
344
  bfd_vma high;
345
};
346
347
/* A minimal decoding of DWARF2 compilation units.  We only decode
348
   what's needed to get to the line number information.  */
349
350
struct comp_unit
351
{
352
  /* Chain the previously read compilation units.  */
353
  struct comp_unit *next_unit;
354
355
  /* Chain the previously read compilation units that have no ranges yet.
356
     We scan these separately when we have a trie over the ranges.
357
     Unused if arange.high != 0. */
358
  struct comp_unit *next_unit_without_ranges;
359
360
  /* Likewise, chain the compilation unit read after this one.
361
     The comp units are stored in reversed reading order.  */
362
  struct comp_unit *prev_unit;
363
364
  /* Keep the bfd convenient (for memory allocation).  */
365
  bfd *abfd;
366
367
  /* The lowest and highest addresses contained in this compilation
368
     unit as specified in the compilation unit header.  */
369
  struct arange arange;
370
371
  /* The DW_AT_name attribute (for error messages).  */
372
  char *name;
373
374
  /* The abbrev hash table.  */
375
  struct abbrev_info **abbrevs;
376
377
  /* DW_AT_language.  */
378
  int lang;
379
380
  /* Note that an error was found by comp_unit_find_nearest_line.  */
381
  int error;
382
383
  /* The DW_AT_comp_dir attribute.  */
384
  char *comp_dir;
385
386
  /* TRUE if there is a line number table associated with this comp. unit.  */
387
  int stmtlist;
388
389
  /* Pointer to the current comp_unit so that we can find a given entry
390
     by its reference.  */
391
  bfd_byte *info_ptr_unit;
392
393
  /* The offset into .debug_line of the line number table.  */
394
  unsigned long line_offset;
395
396
  /* Pointer to the first child die for the comp unit.  */
397
  bfd_byte *first_child_die_ptr;
398
399
  /* The end of the comp unit.  */
400
  bfd_byte *end_ptr;
401
402
  /* The decoded line number, NULL if not yet decoded.  */
403
  struct line_info_table *line_table;
404
405
  /* A list of the functions found in this comp. unit.  */
406
  struct funcinfo *function_table;
407
408
  /* A table of function information references searchable by address.  */
409
  struct lookup_funcinfo *lookup_funcinfo_table;
410
411
  /* Number of functions in the function_table and sorted_function_table.  */
412
  bfd_size_type number_of_functions;
413
414
  /* A list of the variables found in this comp. unit.  */
415
  struct varinfo *variable_table;
416
417
  /* Pointers to dwarf2_debug structures.  */
418
  struct dwarf2_debug *stash;
419
  struct dwarf2_debug_file *file;
420
421
  /* DWARF format version for this unit - from unit header.  */
422
  int version;
423
424
  /* Address size for this unit - from unit header.  */
425
  unsigned char addr_size;
426
427
  /* Offset size for this unit - from unit header.  */
428
  unsigned char offset_size;
429
430
  /* Base address for this unit - from DW_AT_low_pc attribute of
431
     DW_TAG_compile_unit DIE */
432
  bfd_vma base_address;
433
434
  /* TRUE if symbols are cached in hash table for faster lookup by name.  */
435
  bool cached;
436
437
  /* Used when iterating over trie leaves to know which units we have
438
     already seen in this iteration.  */
439
  bool mark;
440
441
 /* Base address of debug_addr section.  */
442
  size_t dwarf_addr_offset;
443
444
  /* Base address of string offset table.  */
445
  size_t dwarf_str_offset;
446
};
447
448
/* This data structure holds the information of an abbrev.  */
449
struct abbrev_info
450
{
451
  unsigned int         number;    /* Number identifying abbrev.  */
452
  enum dwarf_tag       tag;   /* DWARF tag.  */
453
  bool                 has_children;  /* TRUE if the abbrev has children.  */
454
  unsigned int         num_attrs; /* Number of attributes.  */
455
  struct attr_abbrev * attrs;   /* An array of attribute descriptions.  */
456
  struct abbrev_info * next;    /* Next in chain.  */
457
};
458
459
struct attr_abbrev
460
{
461
  enum dwarf_attribute name;
462
  enum dwarf_form form;
463
  bfd_vma implicit_const;
464
};
465
466
/* Map of uncompressed DWARF debug section name to compressed one.  It
467
   is terminated by NULL uncompressed_name.  */
468
469
const struct dwarf_debug_section dwarf_debug_sections[] =
470
{
471
  { ".debug_abbrev",    ".zdebug_abbrev" },
472
  { ".debug_aranges",   ".zdebug_aranges" },
473
  { ".debug_frame",   ".zdebug_frame" },
474
  { ".debug_info",    ".zdebug_info" },
475
  { ".debug_info",    ".zdebug_info" },
476
  { ".debug_line",    ".zdebug_line" },
477
  { ".debug_loc",   ".zdebug_loc" },
478
  { ".debug_macinfo",   ".zdebug_macinfo" },
479
  { ".debug_macro",   ".zdebug_macro" },
480
  { ".debug_pubnames",    ".zdebug_pubnames" },
481
  { ".debug_pubtypes",    ".zdebug_pubtypes" },
482
  { ".debug_ranges",    ".zdebug_ranges" },
483
  { ".debug_rnglists",    ".zdebug_rnglist" },
484
  { ".debug_static_func", ".zdebug_static_func" },
485
  { ".debug_static_vars", ".zdebug_static_vars" },
486
  { ".debug_str",   ".zdebug_str", },
487
  { ".debug_str",   ".zdebug_str", },
488
  { ".debug_str_offsets", ".zdebug_str_offsets", },
489
  { ".debug_addr",    ".zdebug_addr", },
490
  { ".debug_line_str",    ".zdebug_line_str", },
491
  { ".debug_types",   ".zdebug_types" },
492
  /* GNU DWARF 1 extensions */
493
  { ".debug_sfnames",   ".zdebug_sfnames" },
494
  { ".debug_srcinfo",   ".zebug_srcinfo" },
495
  /* SGI/MIPS DWARF 2 extensions */
496
  { ".debug_funcnames",   ".zdebug_funcnames" },
497
  { ".debug_typenames",   ".zdebug_typenames" },
498
  { ".debug_varnames",    ".zdebug_varnames" },
499
  { ".debug_weaknames",   ".zdebug_weaknames" },
500
  { NULL,     NULL },
501
};
502
503
/* NB/ Numbers in this enum must match up with indices
504
   into the dwarf_debug_sections[] array above.  */
505
enum dwarf_debug_section_enum
506
{
507
  debug_abbrev = 0,
508
  debug_aranges,
509
  debug_frame,
510
  debug_info,
511
  debug_info_alt,
512
  debug_line,
513
  debug_loc,
514
  debug_macinfo,
515
  debug_macro,
516
  debug_pubnames,
517
  debug_pubtypes,
518
  debug_ranges,
519
  debug_rnglists,
520
  debug_static_func,
521
  debug_static_vars,
522
  debug_str,
523
  debug_str_alt,
524
  debug_str_offsets,
525
  debug_addr,
526
  debug_line_str,
527
  debug_types,
528
  debug_sfnames,
529
  debug_srcinfo,
530
  debug_funcnames,
531
  debug_typenames,
532
  debug_varnames,
533
  debug_weaknames,
534
  debug_max
535
};
536
537
/* A static assertion.  */
538
extern int dwarf_debug_section_assert[ARRAY_SIZE (dwarf_debug_sections)
539
              == debug_max + 1 ? 1 : -1];
540
541
#ifndef ABBREV_HASH_SIZE
542
4.83M
#define ABBREV_HASH_SIZE 121
543
#endif
544
#ifndef ATTR_ALLOC_CHUNK
545
1.79M
#define ATTR_ALLOC_CHUNK 4
546
#endif
547
548
/* Variable and function hash tables.  This is used to speed up look-up
549
   in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
550
   In order to share code between variable and function infos, we use
551
   a list of untyped pointer for all variable/function info associated with
552
   a symbol.  We waste a bit of memory for list with one node but that
553
   simplifies the code.  */
554
555
struct info_list_node
556
{
557
  struct info_list_node *next;
558
  void *info;
559
};
560
561
/* Info hash entry.  */
562
struct info_hash_entry
563
{
564
  struct bfd_hash_entry root;
565
  struct info_list_node *head;
566
};
567
568
struct info_hash_table
569
{
570
  struct bfd_hash_table base;
571
};
572
573
/* Function to create a new entry in info hash table.  */
574
575
static struct bfd_hash_entry *
576
info_hash_table_newfunc (struct bfd_hash_entry *entry,
577
       struct bfd_hash_table *table,
578
       const char *string)
579
42.1k
{
580
42.1k
  struct info_hash_entry *ret = (struct info_hash_entry *) entry;
581
582
  /* Allocate the structure if it has not already been allocated by a
583
     derived class.  */
584
42.1k
  if (ret == NULL)
585
42.1k
    {
586
42.1k
      ret = (struct info_hash_entry *) bfd_hash_allocate (table,
587
42.1k
                sizeof (* ret));
588
42.1k
      if (ret == NULL)
589
0
  return NULL;
590
42.1k
    }
591
592
  /* Call the allocation method of the base class.  */
593
42.1k
  ret = ((struct info_hash_entry *)
594
42.1k
   bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
595
596
  /* Initialize the local fields here.  */
597
42.1k
  if (ret)
598
42.1k
    ret->head = NULL;
599
600
42.1k
  return (struct bfd_hash_entry *) ret;
601
42.1k
}
602
603
/* Function to create a new info hash table.  It returns a pointer to the
604
   newly created table or NULL if there is any error.  We need abfd
605
   solely for memory allocation.  */
606
607
static struct info_hash_table *
608
create_info_hash_table (bfd *abfd)
609
1.05k
{
610
1.05k
  struct info_hash_table *hash_table;
611
612
1.05k
  hash_table = ((struct info_hash_table *)
613
1.05k
    bfd_alloc (abfd, sizeof (struct info_hash_table)));
614
1.05k
  if (!hash_table)
615
0
    return hash_table;
616
617
1.05k
  if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
618
1.05k
          sizeof (struct info_hash_entry)))
619
0
    {
620
0
      bfd_release (abfd, hash_table);
621
0
      return NULL;
622
0
    }
623
624
1.05k
  return hash_table;
625
1.05k
}
626
627
/* Insert an info entry into an info hash table.  We do not check of
628
   duplicate entries.  Also, the caller need to guarantee that the
629
   right type of info in inserted as info is passed as a void* pointer.
630
   This function returns true if there is no error.  */
631
632
static bool
633
insert_info_hash_table (struct info_hash_table *hash_table,
634
      const char *key,
635
      void *info,
636
      bool copy_p)
637
82.5k
{
638
82.5k
  struct info_hash_entry *entry;
639
82.5k
  struct info_list_node *node;
640
641
82.5k
  entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
642
82.5k
                 key, true, copy_p);
643
82.5k
  if (!entry)
644
0
    return false;
645
646
82.5k
  node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
647
82.5k
                  sizeof (*node));
648
82.5k
  if (!node)
649
0
    return false;
650
651
82.5k
  node->info = info;
652
82.5k
  node->next = entry->head;
653
82.5k
  entry->head = node;
654
655
82.5k
  return true;
656
82.5k
}
657
658
/* Look up an info entry list from an info hash table.  Return NULL
659
   if there is none.  */
660
661
static struct info_list_node *
662
lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
663
54.2k
{
664
54.2k
  struct info_hash_entry *entry;
665
666
54.2k
  entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
667
54.2k
                 false, false);
668
54.2k
  return entry ? entry->head : NULL;
669
54.2k
}
670
671
/* Read a section into its appropriate place in the dwarf2_debug
672
   struct (indicated by SECTION_BUFFER and SECTION_SIZE).  If SYMS is
673
   not NULL, use bfd_simple_get_relocated_section_contents to read the
674
   section contents, otherwise use bfd_get_section_contents.  Fail if
675
   the located section does not contain at least OFFSET bytes.  */
676
677
static bool
678
read_section (bfd *abfd,
679
        const struct dwarf_debug_section *sec,
680
        asymbol **syms,
681
        uint64_t offset,
682
        bfd_byte **section_buffer,
683
        bfd_size_type *section_size)
684
1.20M
{
685
1.20M
  const char *section_name = sec->uncompressed_name;
686
1.20M
  bfd_byte *contents = *section_buffer;
687
688
  /* The section may have already been read.  */
689
1.20M
  if (contents == NULL)
690
21.2k
    {
691
21.2k
      bfd_size_type amt;
692
21.2k
      asection *msec;
693
694
21.2k
      msec = bfd_get_section_by_name (abfd, section_name);
695
21.2k
      if (msec == NULL)
696
9.75k
  {
697
9.75k
    section_name = sec->compressed_name;
698
9.75k
          msec = bfd_get_section_by_name (abfd, section_name);
699
9.75k
  }
700
21.2k
      if (msec == NULL)
701
9.74k
  {
702
9.74k
    _bfd_error_handler (_("DWARF error: can't find %s section."),
703
9.74k
            sec->uncompressed_name);
704
9.74k
    bfd_set_error (bfd_error_bad_value);
705
9.74k
    return false;
706
9.74k
  }
707
708
11.4k
      if ((msec->flags & SEC_HAS_CONTENTS) == 0)
709
15
  {
710
15
    _bfd_error_handler (_("DWARF error: section %s has no contents"),
711
15
            section_name);
712
15
    bfd_set_error (bfd_error_no_contents);
713
15
    return false;
714
15
  }
715
716
11.4k
      if (bfd_section_size_insane (abfd, msec))
717
2.10k
  {
718
    /* PR 26946 */
719
2.10k
    _bfd_error_handler (_("DWARF error: section %s is too big"),
720
2.10k
            section_name);
721
2.10k
    return false;
722
2.10k
  }
723
9.36k
      amt = bfd_get_section_limit_octets (abfd, msec);
724
9.36k
      *section_size = amt;
725
      /* Paranoia - alloc one extra so that we can make sure a string
726
   section is NUL terminated.  */
727
9.36k
      amt += 1;
728
9.36k
      if (amt == 0)
729
0
  {
730
    /* Paranoia - this should never happen.  */
731
0
    bfd_set_error (bfd_error_no_memory);
732
0
    return false;
733
0
  }
734
9.36k
      contents = (bfd_byte *) bfd_malloc (amt);
735
9.36k
      if (contents == NULL)
736
0
  return false;
737
9.36k
      if (syms
738
9.36k
    ? !bfd_simple_get_relocated_section_contents (abfd, msec, contents,
739
8.51k
              syms)
740
9.36k
    : !bfd_get_section_contents (abfd, msec, contents, 0, *section_size))
741
1.11k
  {
742
1.11k
    free (contents);
743
1.11k
    return false;
744
1.11k
  }
745
8.24k
      contents[*section_size] = 0;
746
8.24k
      *section_buffer = contents;
747
8.24k
    }
748
749
  /* It is possible to get a bad value for the offset into the section
750
     that the client wants.  Validate it here to avoid trouble later.  */
751
1.19M
  if (offset != 0 && offset >= *section_size)
752
2.22k
    {
753
      /* xgettext: c-format */
754
2.22k
      _bfd_error_handler (_("DWARF error: offset (%" PRIu64 ")"
755
2.22k
          " greater than or equal to %s size (%" PRIu64 ")"),
756
2.22k
        (uint64_t) offset, section_name,
757
2.22k
        (uint64_t) *section_size);
758
2.22k
      bfd_set_error (bfd_error_bad_value);
759
2.22k
      return false;
760
2.22k
    }
761
762
1.19M
  return true;
763
1.19M
}
764
765
/* Read dwarf information from a buffer.  */
766
767
static inline uint64_t
768
read_n_bytes (bfd *abfd, bfd_byte **ptr, bfd_byte *end, int n)
769
16.4M
{
770
16.4M
  bfd_byte *buf = *ptr;
771
16.4M
  if (end - buf < n)
772
405
    {
773
405
      *ptr = end;
774
405
      return 0;
775
405
    }
776
16.4M
  *ptr = buf + n;
777
16.4M
  return bfd_get (n * 8, abfd, buf);
778
16.4M
}
779
780
static unsigned int
781
read_1_byte (bfd *abfd, bfd_byte **ptr, bfd_byte *end)
782
12.2M
{
783
12.2M
  return read_n_bytes (abfd, ptr, end, 1);
784
12.2M
}
785
786
static int
787
read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte **ptr, bfd_byte *end)
788
12.2k
{
789
12.2k
  bfd_byte *buf = *ptr;
790
12.2k
  if (end - buf < 1)
791
0
    {
792
0
      *ptr = end;
793
0
      return 0;
794
0
    }
795
12.2k
  *ptr = buf + 1;
796
12.2k
  return bfd_get_signed_8 (abfd, buf);
797
12.2k
}
798
799
static unsigned int
800
read_2_bytes (bfd *abfd, bfd_byte **ptr, bfd_byte *end)
801
642k
{
802
642k
  return read_n_bytes (abfd, ptr, end, 2);
803
642k
}
804
805
static unsigned int
806
read_3_bytes (bfd *abfd, bfd_byte **ptr, bfd_byte *end)
807
92
{
808
92
  unsigned int val = read_1_byte (abfd, ptr, end);
809
92
  val <<= 8;
810
92
  val |= read_1_byte (abfd, ptr, end);
811
92
  val <<= 8;
812
92
  val |= read_1_byte (abfd, ptr, end);
813
92
  if (bfd_little_endian (abfd))
814
81
    val = (((val >> 16) & 0xff)
815
81
     | (val & 0xff00)
816
81
     | ((val & 0xff) << 16));
817
92
  return val;
818
92
}
819
820
static unsigned int
821
read_4_bytes (bfd *abfd, bfd_byte **ptr, bfd_byte *end)
822
3.55M
{
823
3.55M
  return read_n_bytes (abfd, ptr, end, 4);
824
3.55M
}
825
826
static uint64_t
827
read_8_bytes (bfd *abfd, bfd_byte **ptr, bfd_byte *end)
828
834
{
829
834
  return read_n_bytes (abfd, ptr, end, 8);
830
834
}
831
832
static struct dwarf_block *
833
read_blk (bfd *abfd, bfd_byte **ptr, bfd_byte *end, size_t size)
834
617k
{
835
617k
  bfd_byte *buf = *ptr;
836
617k
  struct dwarf_block *block;
837
838
617k
  block = (struct dwarf_block *) bfd_alloc (abfd, sizeof (*block));
839
617k
  if (block == NULL)
840
0
    return NULL;
841
842
617k
  if (size > (size_t) (end - buf))
843
53
    {
844
53
      *ptr = end;
845
53
      block->data = NULL;
846
53
      block->size = 0;
847
53
    }
848
617k
  else
849
617k
    {
850
617k
      *ptr = buf + size;
851
617k
      block->data = buf;
852
617k
      block->size = size;
853
617k
    }
854
617k
  return block;
855
617k
}
856
857
/* Scans a NUL terminated string starting at *PTR, returning a pointer to it.
858
   Bytes at or beyond BUF_END will not be read.  Returns NULL if the
859
   terminator is not found or if the string is empty.  *PTR is
860
   incremented over the bytes scanned, including the terminator.  */
861
862
static char *
863
read_string (bfd_byte **ptr,
864
       bfd_byte *buf_end)
865
514k
{
866
514k
  bfd_byte *buf = *ptr;
867
514k
  bfd_byte *str = buf;
868
869
3.68M
  while (buf < buf_end)
870
3.68M
    if (*buf++ == 0)
871
513k
      {
872
513k
  if (str == buf - 1)
873
23.6k
    break;
874
490k
  *ptr = buf;
875
490k
  return (char *) str;
876
513k
      }
877
878
23.6k
  *ptr = buf;
879
23.6k
  return NULL;
880
514k
}
881
882
/* Reads an offset from *PTR and then locates the string at this offset
883
   inside the debug string section.  Returns a pointer to the string.
884
   Increments *PTR by the number of bytes read for the offset.  This
885
   value is set even if the function fails.  Bytes at or beyond
886
   BUF_END will not be read.  Returns NULL if there was a problem, or
887
   if the string is empty.  Does not check for NUL termination of the
888
   string.  */
889
890
static char *
891
read_indirect_string (struct comp_unit *unit,
892
          bfd_byte **ptr,
893
          bfd_byte *buf_end)
894
1.16M
{
895
1.16M
  uint64_t offset;
896
1.16M
  struct dwarf2_debug *stash = unit->stash;
897
1.16M
  struct dwarf2_debug_file *file = unit->file;
898
1.16M
  char *str;
899
900
1.16M
  if (unit->offset_size > (size_t) (buf_end - *ptr))
901
5
    {
902
5
      *ptr = buf_end;
903
5
      return NULL;
904
5
    }
905
906
1.16M
  if (unit->offset_size == 4)
907
1.16M
    offset = read_4_bytes (unit->abfd, ptr, buf_end);
908
0
  else
909
0
    offset = read_8_bytes (unit->abfd, ptr, buf_end);
910
911
1.16M
  if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
912
1.16M
          file->syms, offset,
913
1.16M
          &file->dwarf_str_buffer, &file->dwarf_str_size))
914
13.3k
    return NULL;
915
916
1.14M
  str = (char *) file->dwarf_str_buffer + offset;
917
1.14M
  if (*str == '\0')
918
82.7k
    return NULL;
919
1.06M
  return str;
920
1.14M
}
921
922
/* Like read_indirect_string but from .debug_line_str section.  */
923
924
static char *
925
read_indirect_line_string (struct comp_unit *unit,
926
         bfd_byte **ptr,
927
         bfd_byte *buf_end)
928
4.90k
{
929
4.90k
  uint64_t offset;
930
4.90k
  struct dwarf2_debug *stash = unit->stash;
931
4.90k
  struct dwarf2_debug_file *file = unit->file;
932
4.90k
  char *str;
933
934
4.90k
  if (unit->offset_size > (size_t) (buf_end - *ptr))
935
1
    {
936
1
      *ptr = buf_end;
937
1
      return NULL;
938
1
    }
939
940
4.90k
  if (unit->offset_size == 4)
941
4.90k
    offset = read_4_bytes (unit->abfd, ptr, buf_end);
942
0
  else
943
0
    offset = read_8_bytes (unit->abfd, ptr, buf_end);
944
945
4.90k
  if (! read_section (unit->abfd, &stash->debug_sections[debug_line_str],
946
4.90k
          file->syms, offset,
947
4.90k
          &file->dwarf_line_str_buffer,
948
4.90k
          &file->dwarf_line_str_size))
949
321
    return NULL;
950
951
4.58k
  str = (char *) file->dwarf_line_str_buffer + offset;
952
4.58k
  if (*str == '\0')
953
320
    return NULL;
954
4.26k
  return str;
955
4.58k
}
956
957
/* Like read_indirect_string but uses a .debug_str located in
958
   an alternate file pointed to by the .gnu_debugaltlink section.
959
   Used to impement DW_FORM_GNU_strp_alt.  */
960
961
static char *
962
read_alt_indirect_string (struct comp_unit *unit,
963
        bfd_byte **ptr,
964
        bfd_byte *buf_end)
965
0
{
966
0
  uint64_t offset;
967
0
  struct dwarf2_debug *stash = unit->stash;
968
0
  char *str;
969
970
0
  if (unit->offset_size > (size_t) (buf_end - *ptr))
971
0
    {
972
0
      *ptr = buf_end;
973
0
      return NULL;
974
0
    }
975
976
0
  if (unit->offset_size == 4)
977
0
    offset = read_4_bytes (unit->abfd, ptr, buf_end);
978
0
  else
979
0
    offset = read_8_bytes (unit->abfd, ptr, buf_end);
980
981
0
  if (stash->alt.bfd_ptr == NULL)
982
0
    {
983
0
      bfd *debug_bfd;
984
0
      char *debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
985
986
0
      if (debug_filename == NULL)
987
0
  return NULL;
988
989
0
      debug_bfd = bfd_openr (debug_filename, NULL);
990
0
      free (debug_filename);
991
0
      if (debug_bfd == NULL)
992
  /* FIXME: Should we report our failure to follow the debuglink ?  */
993
0
  return NULL;
994
995
0
      if (!bfd_check_format (debug_bfd, bfd_object))
996
0
  {
997
0
    bfd_close (debug_bfd);
998
0
    return NULL;
999
0
  }
1000
0
      stash->alt.bfd_ptr = debug_bfd;
1001
0
    }
1002
1003
0
  if (! read_section (unit->stash->alt.bfd_ptr,
1004
0
          stash->debug_sections + debug_str_alt,
1005
0
          stash->alt.syms, offset,
1006
0
          &stash->alt.dwarf_str_buffer,
1007
0
          &stash->alt.dwarf_str_size))
1008
0
    return NULL;
1009
1010
0
  str = (char *) stash->alt.dwarf_str_buffer + offset;
1011
0
  if (*str == '\0')
1012
0
    return NULL;
1013
1014
0
  return str;
1015
0
}
1016
1017
/* Resolve an alternate reference from UNIT at OFFSET.
1018
   Returns a pointer into the loaded alternate CU upon success
1019
   or NULL upon failure.  */
1020
1021
static bfd_byte *
1022
read_alt_indirect_ref (struct comp_unit *unit, uint64_t offset)
1023
0
{
1024
0
  struct dwarf2_debug *stash = unit->stash;
1025
1026
0
  if (stash->alt.bfd_ptr == NULL)
1027
0
    {
1028
0
      bfd *debug_bfd;
1029
0
      char *debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
1030
1031
0
      if (debug_filename == NULL)
1032
0
  return NULL;
1033
1034
0
      debug_bfd = bfd_openr (debug_filename, NULL);
1035
0
      free (debug_filename);
1036
0
      if (debug_bfd == NULL)
1037
  /* FIXME: Should we report our failure to follow the debuglink ?  */
1038
0
  return NULL;
1039
1040
0
      if (!bfd_check_format (debug_bfd, bfd_object))
1041
0
  {
1042
0
    bfd_close (debug_bfd);
1043
0
    return NULL;
1044
0
  }
1045
0
      stash->alt.bfd_ptr = debug_bfd;
1046
0
    }
1047
1048
0
  if (! read_section (unit->stash->alt.bfd_ptr,
1049
0
          stash->debug_sections + debug_info_alt,
1050
0
          stash->alt.syms, offset,
1051
0
          &stash->alt.dwarf_info_buffer,
1052
0
          &stash->alt.dwarf_info_size))
1053
0
    return NULL;
1054
1055
0
  return stash->alt.dwarf_info_buffer + offset;
1056
0
}
1057
1058
static uint64_t
1059
read_address (struct comp_unit *unit, bfd_byte **ptr, bfd_byte *buf_end)
1060
6.59M
{
1061
6.59M
  bfd_byte *buf = *ptr;
1062
6.59M
  int signed_vma = 0;
1063
1064
6.59M
  if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
1065
6.59M
    signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
1066
1067
6.59M
  if (unit->addr_size > (size_t) (buf_end - buf))
1068
17
    {
1069
17
      *ptr = buf_end;
1070
17
      return 0;
1071
17
    }
1072
1073
6.59M
  *ptr = buf + unit->addr_size;
1074
6.59M
  if (signed_vma)
1075
228
    {
1076
228
      switch (unit->addr_size)
1077
228
  {
1078
228
  case 8:
1079
228
    return bfd_get_signed_64 (unit->abfd, buf);
1080
0
  case 4:
1081
0
    return bfd_get_signed_32 (unit->abfd, buf);
1082
0
  case 2:
1083
0
    return bfd_get_signed_16 (unit->abfd, buf);
1084
0
  default:
1085
0
    abort ();
1086
228
  }
1087
228
    }
1088
6.59M
  else
1089
6.59M
    {
1090
6.59M
      switch (unit->addr_size)
1091
6.59M
  {
1092
844k
  case 8:
1093
844k
    return bfd_get_64 (unit->abfd, buf);
1094
5.74M
  case 4:
1095
5.74M
    return bfd_get_32 (unit->abfd, buf);
1096
23
  case 2:
1097
23
    return bfd_get_16 (unit->abfd, buf);
1098
0
  default:
1099
0
    abort ();
1100
6.59M
  }
1101
6.59M
    }
1102
6.59M
}
1103
1104
/* Lookup an abbrev_info structure in the abbrev hash table.  */
1105
1106
static struct abbrev_info *
1107
lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
1108
2.62M
{
1109
2.62M
  unsigned int hash_number;
1110
2.62M
  struct abbrev_info *abbrev;
1111
1112
2.62M
  hash_number = number % ABBREV_HASH_SIZE;
1113
2.62M
  abbrev = abbrevs[hash_number];
1114
1115
2.62M
  while (abbrev)
1116
2.31M
    {
1117
2.31M
      if (abbrev->number == number)
1118
2.31M
  return abbrev;
1119
345
      else
1120
345
  abbrev = abbrev->next;
1121
2.31M
    }
1122
1123
313k
  return NULL;
1124
2.62M
}
1125
1126
/* We keep a hash table to map .debug_abbrev section offsets to the
1127
   array of abbrevs, so that compilation units using the same set of
1128
   abbrevs do not waste memory.  */
1129
1130
struct abbrev_offset_entry
1131
{
1132
  size_t offset;
1133
  struct abbrev_info **abbrevs;
1134
};
1135
1136
static hashval_t
1137
hash_abbrev (const void *p)
1138
33.9k
{
1139
33.9k
  const struct abbrev_offset_entry *ent = p;
1140
33.9k
  return htab_hash_pointer ((void *) ent->offset);
1141
33.9k
}
1142
1143
static int
1144
eq_abbrev (const void *pa, const void *pb)
1145
13.2k
{
1146
13.2k
  const struct abbrev_offset_entry *a = pa;
1147
13.2k
  const struct abbrev_offset_entry *b = pb;
1148
13.2k
  return a->offset == b->offset;
1149
13.2k
}
1150
1151
static void
1152
del_abbrev (void *p)
1153
15.4k
{
1154
15.4k
  struct abbrev_offset_entry *ent = p;
1155
15.4k
  struct abbrev_info **abbrevs = ent->abbrevs;
1156
15.4k
  size_t i;
1157
1158
1.88M
  for (i = 0; i < ABBREV_HASH_SIZE; i++)
1159
1.86M
    {
1160
1.86M
      struct abbrev_info *abbrev = abbrevs[i];
1161
1162
2.18M
      while (abbrev)
1163
313k
  {
1164
313k
    free (abbrev->attrs);
1165
313k
    abbrev = abbrev->next;
1166
313k
  }
1167
1.86M
    }
1168
15.4k
  free (ent);
1169
15.4k
}
1170
1171
/* In DWARF version 2, the description of the debugging information is
1172
   stored in a separate .debug_abbrev section.  Before we read any
1173
   dies from a section we read in all abbreviations and install them
1174
   in a hash table.  */
1175
1176
static struct abbrev_info**
1177
read_abbrevs (bfd *abfd, uint64_t offset, struct dwarf2_debug *stash,
1178
        struct dwarf2_debug_file *file)
1179
15.7k
{
1180
15.7k
  struct abbrev_info **abbrevs;
1181
15.7k
  bfd_byte *abbrev_ptr;
1182
15.7k
  bfd_byte *abbrev_end;
1183
15.7k
  struct abbrev_info *cur_abbrev;
1184
15.7k
  unsigned int abbrev_number, abbrev_name;
1185
15.7k
  unsigned int abbrev_form, hash_number;
1186
15.7k
  size_t amt;
1187
15.7k
  void **slot;
1188
15.7k
  struct abbrev_offset_entry ent = { offset, NULL };
1189
1190
15.7k
  if (ent.offset != offset)
1191
0
    return NULL;
1192
1193
15.7k
  slot = htab_find_slot (file->abbrev_offsets, &ent, INSERT);
1194
15.7k
  if (slot == NULL)
1195
0
    return NULL;
1196
15.7k
  if (*slot != NULL)
1197
261
    return ((struct abbrev_offset_entry *) (*slot))->abbrevs;
1198
1199
15.4k
  if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
1200
15.4k
          file->syms, offset,
1201
15.4k
          &file->dwarf_abbrev_buffer,
1202
15.4k
          &file->dwarf_abbrev_size))
1203
54
    return NULL;
1204
1205
15.4k
  amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
1206
15.4k
  abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
1207
15.4k
  if (abbrevs == NULL)
1208
0
    return NULL;
1209
1210
15.4k
  abbrev_ptr = file->dwarf_abbrev_buffer + offset;
1211
15.4k
  abbrev_end = file->dwarf_abbrev_buffer + file->dwarf_abbrev_size;
1212
15.4k
  abbrev_number = _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1213
15.4k
           false, abbrev_end);
1214
1215
  /* Loop until we reach an abbrev number of 0.  */
1216
328k
  while (abbrev_number)
1217
313k
    {
1218
313k
      amt = sizeof (struct abbrev_info);
1219
313k
      cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
1220
313k
      if (cur_abbrev == NULL)
1221
0
  goto fail;
1222
1223
      /* Read in abbrev header.  */
1224
313k
      cur_abbrev->number = abbrev_number;
1225
313k
      cur_abbrev->tag = (enum dwarf_tag)
1226
313k
  _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1227
313k
             false, abbrev_end);
1228
313k
      cur_abbrev->has_children = read_1_byte (abfd, &abbrev_ptr, abbrev_end);
1229
1230
      /* Now read in declarations.  */
1231
313k
      for (;;)
1232
1.63M
  {
1233
    /* Initialize it just to avoid a GCC false warning.  */
1234
1.63M
    bfd_vma implicit_const = -1;
1235
1236
1.63M
    abbrev_name = _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1237
1.63M
                 false, abbrev_end);
1238
1.63M
    abbrev_form = _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1239
1.63M
                 false, abbrev_end);
1240
1.63M
    if (abbrev_form == DW_FORM_implicit_const)
1241
1.05k
      implicit_const = _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1242
1.05k
                true, abbrev_end);
1243
1.63M
    if (abbrev_name == 0)
1244
313k
      break;
1245
1246
1.32M
    if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
1247
469k
      {
1248
469k
        struct attr_abbrev *tmp;
1249
1250
469k
        amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
1251
469k
        amt *= sizeof (struct attr_abbrev);
1252
469k
        tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
1253
469k
        if (tmp == NULL)
1254
0
    goto fail;
1255
469k
        cur_abbrev->attrs = tmp;
1256
469k
      }
1257
1258
1.32M
    cur_abbrev->attrs[cur_abbrev->num_attrs].name
1259
1.32M
      = (enum dwarf_attribute) abbrev_name;
1260
1.32M
    cur_abbrev->attrs[cur_abbrev->num_attrs].form
1261
1.32M
      = (enum dwarf_form) abbrev_form;
1262
1.32M
    cur_abbrev->attrs[cur_abbrev->num_attrs].implicit_const
1263
1.32M
      = implicit_const;
1264
1.32M
    ++cur_abbrev->num_attrs;
1265
1.32M
  }
1266
1267
313k
      hash_number = abbrev_number % ABBREV_HASH_SIZE;
1268
313k
      cur_abbrev->next = abbrevs[hash_number];
1269
313k
      abbrevs[hash_number] = cur_abbrev;
1270
1271
      /* Get next abbreviation.
1272
   Under Irix6 the abbreviations for a compilation unit are not
1273
   always properly terminated with an abbrev number of 0.
1274
   Exit loop if we encounter an abbreviation which we have
1275
   already read (which means we are about to read the abbreviations
1276
   for the next compile unit) or if the end of the abbreviation
1277
   table is reached.  */
1278
313k
      if ((size_t) (abbrev_ptr - file->dwarf_abbrev_buffer)
1279
313k
    >= file->dwarf_abbrev_size)
1280
122
  break;
1281
313k
      abbrev_number = _bfd_safe_read_leb128 (abfd, &abbrev_ptr,
1282
313k
               false, abbrev_end);
1283
313k
      if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
1284
159
  break;
1285
313k
    }
1286
1287
15.4k
  *slot = bfd_malloc (sizeof ent);
1288
15.4k
  if (!*slot)
1289
0
    goto fail;
1290
15.4k
  ent.abbrevs = abbrevs;
1291
15.4k
  memcpy (*slot, &ent, sizeof ent);
1292
15.4k
  return abbrevs;
1293
1294
0
 fail:
1295
0
  if (abbrevs != NULL)
1296
0
    {
1297
0
      size_t i;
1298
1299
0
      for (i = 0; i < ABBREV_HASH_SIZE; i++)
1300
0
  {
1301
0
    struct abbrev_info *abbrev = abbrevs[i];
1302
1303
0
    while (abbrev)
1304
0
      {
1305
0
        free (abbrev->attrs);
1306
0
        abbrev = abbrev->next;
1307
0
      }
1308
0
  }
1309
0
      free (abbrevs);
1310
0
    }
1311
0
  return NULL;
1312
15.4k
}
1313
1314
/* Returns true if the form is one which has a string value.  */
1315
1316
static bool
1317
is_str_form (const struct attribute *attr)
1318
449k
{
1319
449k
  switch (attr->form)
1320
449k
    {
1321
79.3k
    case DW_FORM_string:
1322
448k
    case DW_FORM_strp:
1323
448k
    case DW_FORM_strx:
1324
449k
    case DW_FORM_strx1:
1325
449k
    case DW_FORM_strx2:
1326
449k
    case DW_FORM_strx3:
1327
449k
    case DW_FORM_strx4:
1328
449k
    case DW_FORM_line_strp:
1329
449k
    case DW_FORM_GNU_strp_alt:
1330
449k
      return true;
1331
1332
236
    default:
1333
236
      return false;
1334
449k
    }
1335
449k
}
1336
1337
/* Returns true if the form is one which has an integer value.  */
1338
1339
static bool
1340
is_int_form (const struct attribute *attr)
1341
1.15M
{
1342
1.15M
  switch (attr->form)
1343
1.15M
    {
1344
162k
    case DW_FORM_addr:
1345
384k
    case DW_FORM_data2:
1346
422k
    case DW_FORM_data4:
1347
422k
    case DW_FORM_data8:
1348
1.05M
    case DW_FORM_data1:
1349
1.06M
    case DW_FORM_flag:
1350
1.06M
    case DW_FORM_sdata:
1351
1.06M
    case DW_FORM_udata:
1352
1.06M
    case DW_FORM_ref_addr:
1353
1.06M
    case DW_FORM_ref1:
1354
1.06M
    case DW_FORM_ref2:
1355
1.13M
    case DW_FORM_ref4:
1356
1.13M
    case DW_FORM_ref8:
1357
1.13M
    case DW_FORM_ref_udata:
1358
1.15M
    case DW_FORM_sec_offset:
1359
1.15M
    case DW_FORM_flag_present:
1360
1.15M
    case DW_FORM_ref_sig8:
1361
1.15M
    case DW_FORM_addrx:
1362
1.15M
    case DW_FORM_implicit_const:
1363
1.15M
    case DW_FORM_addrx1:
1364
1.15M
    case DW_FORM_addrx2:
1365
1.15M
    case DW_FORM_addrx3:
1366
1.15M
    case DW_FORM_addrx4:
1367
1.15M
    case DW_FORM_GNU_ref_alt:
1368
1.15M
      return true;
1369
1370
205
    default:
1371
205
      return false;
1372
1.15M
    }
1373
1.15M
}
1374
1375
/* Returns true if the form is strx[1-4].  */
1376
1377
static inline bool
1378
is_strx_form (enum dwarf_form form)
1379
108k
{
1380
108k
  return (form == DW_FORM_strx
1381
108k
    || form == DW_FORM_strx1
1382
108k
    || form == DW_FORM_strx2
1383
108k
    || form == DW_FORM_strx3
1384
108k
    || form == DW_FORM_strx4);
1385
108k
}
1386
1387
/* Return true if the form is addrx[1-4].  */
1388
1389
static inline bool
1390
is_addrx_form (enum dwarf_form form)
1391
108k
{
1392
108k
  return (form == DW_FORM_addrx
1393
108k
    || form == DW_FORM_addrx1
1394
108k
    || form == DW_FORM_addrx2
1395
108k
    || form == DW_FORM_addrx3
1396
108k
    || form == DW_FORM_addrx4);
1397
108k
}
1398
1399
/* Returns the address in .debug_addr section using DW_AT_addr_base.
1400
   Used to implement DW_FORM_addrx*.  */
1401
static uint64_t
1402
read_indexed_address (uint64_t idx, struct comp_unit *unit)
1403
180
{
1404
180
  struct dwarf2_debug *stash = unit->stash;
1405
180
  struct dwarf2_debug_file *file = unit->file;
1406
180
  bfd_byte *info_ptr;
1407
180
  size_t offset;
1408
1409
180
  if (stash == NULL)
1410
0
    return 0;
1411
1412
180
  if (!read_section (unit->abfd, &stash->debug_sections[debug_addr],
1413
180
         file->syms, 0,
1414
180
         &file->dwarf_addr_buffer, &file->dwarf_addr_size))
1415
91
    return 0;
1416
1417
89
  if (_bfd_mul_overflow (idx, unit->addr_size, &offset))
1418
0
    return 0;
1419
1420
89
  offset += unit->dwarf_addr_offset;
1421
89
  if (offset < unit->dwarf_addr_offset
1422
89
      || offset > file->dwarf_addr_size
1423
89
      || file->dwarf_addr_size - offset < unit->addr_size)
1424
4
    return 0;
1425
1426
85
  info_ptr = file->dwarf_addr_buffer + offset;
1427
1428
85
  if (unit->addr_size == 4)
1429
0
    return bfd_get_32 (unit->abfd, info_ptr);
1430
85
  else if (unit->addr_size == 8)
1431
85
    return bfd_get_64 (unit->abfd, info_ptr);
1432
0
  else
1433
0
    return 0;
1434
85
}
1435
1436
/* Returns the string using DW_AT_str_offsets_base.
1437
   Used to implement DW_FORM_strx*.  */
1438
static const char *
1439
read_indexed_string (uint64_t idx, struct comp_unit *unit)
1440
3.51k
{
1441
3.51k
  struct dwarf2_debug *stash = unit->stash;
1442
3.51k
  struct dwarf2_debug_file *file = unit->file;
1443
3.51k
  bfd_byte *info_ptr;
1444
3.51k
  uint64_t str_offset;
1445
3.51k
  size_t offset;
1446
1447
3.51k
  if (stash == NULL)
1448
0
    return NULL;
1449
1450
3.51k
  if (!read_section (unit->abfd, &stash->debug_sections[debug_str],
1451
3.51k
         file->syms, 0,
1452
3.51k
         &file->dwarf_str_buffer, &file->dwarf_str_size))
1453
653
    return NULL;
1454
1455
2.86k
  if (!read_section (unit->abfd, &stash->debug_sections[debug_str_offsets],
1456
2.86k
         file->syms, 0,
1457
2.86k
         &file->dwarf_str_offsets_buffer,
1458
2.86k
         &file->dwarf_str_offsets_size))
1459
67
    return NULL;
1460
1461
2.79k
  if (_bfd_mul_overflow (idx, unit->offset_size, &offset))
1462
0
    return NULL;
1463
1464
2.79k
  offset += unit->dwarf_str_offset;
1465
2.79k
  if (offset < unit->dwarf_str_offset
1466
2.79k
      || offset > file->dwarf_str_offsets_size
1467
2.79k
      || file->dwarf_str_offsets_size - offset < unit->offset_size)
1468
6
    return NULL;
1469
1470
2.79k
  info_ptr = file->dwarf_str_offsets_buffer + offset;
1471
1472
2.79k
  if (unit->offset_size == 4)
1473
2.79k
    str_offset = bfd_get_32 (unit->abfd, info_ptr);
1474
0
  else if (unit->offset_size == 8)
1475
0
    str_offset = bfd_get_64 (unit->abfd, info_ptr);
1476
0
  else
1477
0
    return NULL;
1478
1479
2.79k
  if (str_offset >= file->dwarf_str_size)
1480
11
    return NULL;
1481
2.78k
  return (const char *) file->dwarf_str_buffer + str_offset;
1482
2.79k
}
1483
1484
/* Read and fill in the value of attribute ATTR as described by FORM.
1485
   Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1486
   Returns an updated INFO_PTR taking into account the amount of data read.  */
1487
1488
static bfd_byte *
1489
read_attribute_value (struct attribute *  attr,
1490
          unsigned      form,
1491
          bfd_vma     implicit_const,
1492
          struct comp_unit *  unit,
1493
          bfd_byte *    info_ptr,
1494
          bfd_byte *    info_ptr_end)
1495
8.56M
{
1496
8.56M
  bfd *abfd = unit->abfd;
1497
8.56M
  size_t amt;
1498
1499
8.56M
  if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
1500
60
    {
1501
60
      _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1502
60
      bfd_set_error (bfd_error_bad_value);
1503
60
      return NULL;
1504
60
    }
1505
1506
8.56M
  attr->form = (enum dwarf_form) form;
1507
1508
8.56M
  switch (form)
1509
8.56M
    {
1510
81.3k
    case DW_FORM_flag_present:
1511
81.3k
      attr->u.val = 1;
1512
81.3k
      break;
1513
255
    case DW_FORM_ref_addr:
1514
      /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1515
   DWARF3.  */
1516
255
      if (unit->version >= 3)
1517
221
  {
1518
221
    if (unit->offset_size == 4)
1519
221
      attr->u.val = read_4_bytes (unit->abfd, &info_ptr, info_ptr_end);
1520
0
    else
1521
0
      attr->u.val = read_8_bytes (unit->abfd, &info_ptr, info_ptr_end);
1522
221
    break;
1523
221
  }
1524
      /* FALLTHROUGH */
1525
535k
    case DW_FORM_addr:
1526
535k
      attr->u.val = read_address (unit, &info_ptr, info_ptr_end);
1527
535k
      break;
1528
0
    case DW_FORM_GNU_ref_alt:
1529
51.5k
    case DW_FORM_sec_offset:
1530
51.5k
      if (unit->offset_size == 4)
1531
51.5k
  attr->u.val = read_4_bytes (unit->abfd, &info_ptr, info_ptr_end);
1532
0
      else
1533
0
  attr->u.val = read_8_bytes (unit->abfd, &info_ptr, info_ptr_end);
1534
51.5k
      break;
1535
78
    case DW_FORM_block2:
1536
78
      amt = read_2_bytes (abfd, &info_ptr, info_ptr_end);
1537
78
      attr->u.blk = read_blk (abfd, &info_ptr, info_ptr_end, amt);
1538
78
      if (attr->u.blk == NULL)
1539
0
  return NULL;
1540
78
      break;
1541
78
    case DW_FORM_block4:
1542
29
      amt = read_4_bytes (abfd, &info_ptr, info_ptr_end);
1543
29
      attr->u.blk = read_blk (abfd, &info_ptr, info_ptr_end, amt);
1544
29
      if (attr->u.blk == NULL)
1545
0
  return NULL;
1546
29
      break;
1547
556
    case DW_FORM_ref1:
1548
214k
    case DW_FORM_flag:
1549
2.85M
    case DW_FORM_data1:
1550
2.85M
      attr->u.val = read_1_byte (abfd, &info_ptr, info_ptr_end);
1551
2.85M
      break;
1552
54
    case DW_FORM_addrx1:
1553
54
      attr->u.val = read_1_byte (abfd, &info_ptr, info_ptr_end);
1554
      /* dwarf_addr_offset value 0 indicates the attribute DW_AT_addr_base
1555
   is not yet read.  */
1556
54
      if (unit->dwarf_addr_offset != 0)
1557
0
  attr->u.val = read_indexed_address (attr->u.val, unit);
1558
54
      break;
1559
612k
    case DW_FORM_data2:
1560
612k
    case DW_FORM_ref2:
1561
612k
      attr->u.val = read_2_bytes (abfd, &info_ptr, info_ptr_end);
1562
612k
      break;
1563
51
    case DW_FORM_addrx2:
1564
51
      attr->u.val = read_2_bytes (abfd, &info_ptr, info_ptr_end);
1565
51
      if (unit->dwarf_addr_offset != 0)
1566
0
  attr->u.val = read_indexed_address (attr->u.val, unit);
1567
51
      break;
1568
41
    case DW_FORM_addrx3:
1569
41
      attr->u.val = read_3_bytes (abfd, &info_ptr, info_ptr_end);
1570
41
      if (unit->dwarf_addr_offset != 0)
1571
2
  attr->u.val = read_indexed_address(attr->u.val, unit);
1572
41
      break;
1573
1.98M
    case DW_FORM_ref4:
1574
2.27M
    case DW_FORM_data4:
1575
2.27M
      attr->u.val = read_4_bytes (abfd, &info_ptr, info_ptr_end);
1576
2.27M
      break;
1577
19
    case DW_FORM_addrx4:
1578
19
      attr->u.val = read_4_bytes (abfd, &info_ptr, info_ptr_end);
1579
19
      if (unit->dwarf_addr_offset != 0)
1580
2
  attr->u.val = read_indexed_address (attr->u.val, unit);
1581
19
      break;
1582
496
    case DW_FORM_data8:
1583
517
    case DW_FORM_ref8:
1584
729
    case DW_FORM_ref_sig8:
1585
729
      attr->u.val = read_8_bytes (abfd, &info_ptr, info_ptr_end);
1586
729
      break;
1587
296k
    case DW_FORM_string:
1588
296k
      attr->u.str = read_string (&info_ptr, info_ptr_end);
1589
296k
      break;
1590
1.16M
    case DW_FORM_strp:
1591
1.16M
      attr->u.str = read_indirect_string (unit, &info_ptr, info_ptr_end);
1592
1.16M
      break;
1593
4.90k
    case DW_FORM_line_strp:
1594
4.90k
      attr->u.str = read_indirect_line_string (unit, &info_ptr, info_ptr_end);
1595
4.90k
      break;
1596
0
    case DW_FORM_GNU_strp_alt:
1597
0
      attr->u.str = read_alt_indirect_string (unit, &info_ptr, info_ptr_end);
1598
0
      break;
1599
3.49k
    case DW_FORM_strx1:
1600
3.49k
      attr->u.val = read_1_byte (abfd, &info_ptr, info_ptr_end);
1601
      /* dwarf_str_offset value 0 indicates the attribute DW_AT_str_offsets_base
1602
   is not yet read.  */
1603
3.49k
      if (unit->dwarf_str_offset != 0)
1604
3.30k
  attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
1605
193
      else
1606
193
  attr->u.str = NULL;
1607
3.49k
      break;
1608
22
    case DW_FORM_strx2:
1609
22
      attr->u.val = read_2_bytes (abfd, &info_ptr, info_ptr_end);
1610
22
      if (unit->dwarf_str_offset != 0)
1611
2
  attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
1612
20
      else
1613
20
  attr->u.str = NULL;
1614
22
      break;
1615
51
    case DW_FORM_strx3:
1616
51
      attr->u.val = read_3_bytes (abfd, &info_ptr, info_ptr_end);
1617
51
      if (unit->dwarf_str_offset != 0)
1618
0
  attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
1619
51
      else
1620
51
  attr->u.str = NULL;
1621
51
      break;
1622
123
    case DW_FORM_strx4:
1623
123
      attr->u.val = read_4_bytes (abfd, &info_ptr, info_ptr_end);
1624
123
      if (unit->dwarf_str_offset != 0)
1625
18
  attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
1626
105
      else
1627
105
  attr->u.str = NULL;
1628
123
      break;
1629
33
    case DW_FORM_strx:
1630
33
      attr->u.val = _bfd_safe_read_leb128 (abfd, &info_ptr,
1631
33
             false, info_ptr_end);
1632
33
      if (unit->dwarf_str_offset != 0)
1633
1
  attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
1634
32
      else
1635
32
  attr->u.str = NULL;
1636
33
      break;
1637
8.80k
    case DW_FORM_exprloc:
1638
8.82k
    case DW_FORM_block:
1639
8.82k
      amt = _bfd_safe_read_leb128 (abfd, &info_ptr,
1640
8.82k
           false, info_ptr_end);
1641
8.82k
      attr->u.blk = read_blk (abfd, &info_ptr, info_ptr_end, amt);
1642
8.82k
      if (attr->u.blk == NULL)
1643
0
  return NULL;
1644
8.82k
      break;
1645
608k
    case DW_FORM_block1:
1646
608k
      amt = read_1_byte (abfd, &info_ptr, info_ptr_end);
1647
608k
      attr->u.blk = read_blk (abfd, &info_ptr, info_ptr_end, amt);
1648
608k
      if (attr->u.blk == NULL)
1649
0
  return NULL;
1650
608k
      break;
1651
608k
    case DW_FORM_sdata:
1652
63.4k
      attr->u.sval = _bfd_safe_read_leb128 (abfd, &info_ptr,
1653
63.4k
              true, info_ptr_end);
1654
63.4k
      break;
1655
1656
26
    case DW_FORM_rnglistx:
1657
95
    case DW_FORM_loclistx:
1658
      /* FIXME: Add support for these forms!  */
1659
      /* Fall through.  */
1660
169
    case DW_FORM_ref_udata:
1661
4.13k
    case DW_FORM_udata:
1662
4.13k
      attr->u.val = _bfd_safe_read_leb128 (abfd, &info_ptr,
1663
4.13k
             false, info_ptr_end);
1664
4.13k
      break;
1665
262
    case DW_FORM_addrx:
1666
262
      attr->u.val = _bfd_safe_read_leb128 (abfd, &info_ptr,
1667
262
             false, info_ptr_end);
1668
262
      if (unit->dwarf_addr_offset != 0)
1669
93
  attr->u.val = read_indexed_address (attr->u.val, unit);
1670
262
      break;
1671
13
    case DW_FORM_indirect:
1672
13
      form = _bfd_safe_read_leb128 (abfd, &info_ptr,
1673
13
            false, info_ptr_end);
1674
13
      if (form == DW_FORM_implicit_const)
1675
0
  implicit_const = _bfd_safe_read_leb128 (abfd, &info_ptr,
1676
0
            true, info_ptr_end);
1677
13
      info_ptr = read_attribute_value (attr, form, implicit_const, unit,
1678
13
               info_ptr, info_ptr_end);
1679
13
      break;
1680
5.21k
    case DW_FORM_implicit_const:
1681
5.21k
      attr->form = DW_FORM_sdata;
1682
5.21k
      attr->u.sval = implicit_const;
1683
5.21k
      break;
1684
318
    case DW_FORM_data16:
1685
      /* This is really a "constant", but there is no way to store that
1686
         so pretend it is a 16 byte block instead.  */
1687
318
      attr->u.blk = read_blk (abfd, &info_ptr, info_ptr_end, 16);
1688
318
      if (attr->u.blk == NULL)
1689
0
  return NULL;
1690
318
      break;
1691
1692
318
    default:
1693
170
      _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1694
170
        form);
1695
170
      bfd_set_error (bfd_error_bad_value);
1696
170
      return NULL;
1697
8.56M
    }
1698
8.56M
  return info_ptr;
1699
8.56M
}
1700
1701
/* Read an attribute described by an abbreviated attribute.  */
1702
1703
static bfd_byte *
1704
read_attribute (struct attribute *    attr,
1705
    struct attr_abbrev *  abbrev,
1706
    struct comp_unit *    unit,
1707
    bfd_byte *        info_ptr,
1708
    bfd_byte *        info_ptr_end)
1709
8.56M
{
1710
8.56M
  attr->name = abbrev->name;
1711
8.56M
  info_ptr = read_attribute_value (attr, abbrev->form, abbrev->implicit_const,
1712
8.56M
           unit, info_ptr, info_ptr_end);
1713
8.56M
  return info_ptr;
1714
8.56M
}
1715
1716
/* Return mangling style given LANG.  */
1717
1718
static int
1719
mangle_style (int lang)
1720
133k
{
1721
133k
  switch (lang)
1722
133k
    {
1723
3
    case DW_LANG_Ada83:
1724
52
    case DW_LANG_Ada95:
1725
52
    case DW_LANG_Ada2005:
1726
52
    case DW_LANG_Ada2012:
1727
52
      return DMGL_GNAT;
1728
1729
61
    case DW_LANG_C_plus_plus:
1730
62
    case DW_LANG_C_plus_plus_03:
1731
200
    case DW_LANG_C_plus_plus_11:
1732
298
    case DW_LANG_C_plus_plus_14:
1733
320
    case DW_LANG_C_plus_plus_17:
1734
320
    case DW_LANG_C_plus_plus_20:
1735
320
    case DW_LANG_C_plus_plus_23:
1736
320
      return DMGL_GNU_V3;
1737
1738
105
    case DW_LANG_Java:
1739
105
      return DMGL_JAVA;
1740
1741
34
    case DW_LANG_D:
1742
34
      return DMGL_DLANG;
1743
1744
20
    case DW_LANG_Rust:
1745
20
    case DW_LANG_Rust_old:
1746
20
      return DMGL_RUST;
1747
1748
1.49k
    default:
1749
1.49k
      return DMGL_AUTO;
1750
1751
79.5k
    case DW_LANG_C89:
1752
79.6k
    case DW_LANG_C:
1753
79.6k
    case DW_LANG_Cobol74:
1754
79.6k
    case DW_LANG_Cobol85:
1755
79.6k
    case DW_LANG_Fortran77:
1756
79.6k
    case DW_LANG_Fortran18:
1757
79.6k
    case DW_LANG_Fortran23:
1758
79.6k
    case DW_LANG_Pascal83:
1759
79.6k
    case DW_LANG_PLI:
1760
131k
    case DW_LANG_C99:
1761
131k
    case DW_LANG_UPC:
1762
131k
    case DW_LANG_C11:
1763
131k
    case DW_LANG_C17:
1764
131k
    case DW_LANG_C23:
1765
131k
    case DW_LANG_Mips_Assembler:
1766
131k
    case DW_LANG_Assembly:
1767
131k
    case DW_LANG_Upc:
1768
131k
    case DW_LANG_HP_Basic91:
1769
131k
    case DW_LANG_HP_IMacro:
1770
131k
    case DW_LANG_HP_Assembler:
1771
131k
      return 0;
1772
133k
    }
1773
133k
}
1774
1775
/* Source line information table routines.  */
1776
1777
201k
#define FILE_ALLOC_CHUNK 5
1778
45.9k
#define DIR_ALLOC_CHUNK 5
1779
1780
struct line_info
1781
{
1782
  struct line_info *  prev_line;
1783
  bfd_vma   address;
1784
  char *    filename;
1785
  unsigned int    line;
1786
  unsigned int    column;
1787
  unsigned int    discriminator;
1788
  unsigned char   op_index;
1789
  unsigned char   end_sequence;   /* End of (sequential) code sequence.  */
1790
};
1791
1792
struct fileinfo
1793
{
1794
  char *    name;
1795
  unsigned int    dir;
1796
  unsigned int    time;
1797
  unsigned int    size;
1798
};
1799
1800
struct line_sequence
1801
{
1802
  bfd_vma   low_pc;
1803
  struct line_sequence* prev_sequence;
1804
  struct line_info* last_line;  /* Largest VMA.  */
1805
  struct line_info**  line_info_lookup;
1806
  bfd_size_type   num_lines;
1807
};
1808
1809
struct line_info_table
1810
{
1811
  bfd *     abfd;
1812
  unsigned int    num_files;
1813
  unsigned int    num_dirs;
1814
  unsigned int    num_sequences;
1815
  bool                  use_dir_and_file_0;
1816
  char *    comp_dir;
1817
  char **   dirs;
1818
  struct fileinfo*  files;
1819
  struct line_sequence* sequences;
1820
  struct line_info* lcl_head;   /* Local head; used in 'add_line_info'.  */
1821
};
1822
1823
/* Remember some information about each function.  If the function is
1824
   inlined (DW_TAG_inlined_subroutine) it may have two additional
1825
   attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1826
   source code location where this function was inlined.  */
1827
1828
struct funcinfo
1829
{
1830
  /* Pointer to previous function in list of all functions.  */
1831
  struct funcinfo *prev_func;
1832
  /* Pointer to function one scope higher.  */
1833
  struct funcinfo *caller_func;
1834
  /* Source location file name where caller_func inlines this func.  */
1835
  char *caller_file;
1836
  /* Source location file name.  */
1837
  char *file;
1838
  /* Source location line number where caller_func inlines this func.  */
1839
  int caller_line;
1840
  /* Source location line number.  */
1841
  int line;
1842
  int tag;
1843
  bool is_linkage;
1844
  const char *name;
1845
  struct arange arange;
1846
  /* The offset of the funcinfo from the start of the unit.  */
1847
  uint64_t unit_offset;
1848
};
1849
1850
struct lookup_funcinfo
1851
{
1852
  /* Function information corresponding to this lookup table entry.  */
1853
  struct funcinfo *funcinfo;
1854
1855
  /* The lowest address for this specific function.  */
1856
  bfd_vma low_addr;
1857
1858
  /* The highest address of this function before the lookup table is sorted.
1859
     The highest address of all prior functions after the lookup table is
1860
     sorted, which is used for binary search.  */
1861
  bfd_vma high_addr;
1862
  /* Index of this function, used to ensure qsort is stable.  */
1863
  unsigned int idx;
1864
};
1865
1866
struct varinfo
1867
{
1868
  /* Pointer to previous variable in list of all variables.  */
1869
  struct varinfo *prev_var;
1870
  /* The offset of the varinfo from the start of the unit.  */
1871
  uint64_t unit_offset;
1872
  /* Source location file name.  */
1873
  char *file;
1874
  /* Source location line number.  */
1875
  int line;
1876
  /* The type of this variable.  */
1877
  int tag;
1878
  /* The name of the variable, if it has one.  */
1879
  const char *name;
1880
  /* The address of the variable.  */
1881
  bfd_vma addr;
1882
  /* Is this a stack variable?  */
1883
  bool stack;
1884
};
1885
1886
/* Return TRUE if NEW_LINE should sort after LINE.  */
1887
1888
static inline bool
1889
new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1890
4.62M
{
1891
4.62M
  return (new_line->address > line->address
1892
4.62M
    || (new_line->address == line->address
1893
2.03M
        && new_line->op_index > line->op_index));
1894
4.62M
}
1895
1896
1897
/* Adds a new entry to the line_info list in the line_info_table, ensuring
1898
   that the list is sorted.  Note that the line_info list is sorted from
1899
   highest to lowest VMA (with possible duplicates); that is,
1900
   line_info->prev_line always accesses an equal or smaller VMA.  */
1901
1902
static bool
1903
add_line_info (struct line_info_table *table,
1904
         bfd_vma address,
1905
         unsigned char op_index,
1906
         char *filename,
1907
         unsigned int line,
1908
         unsigned int column,
1909
         unsigned int discriminator,
1910
         int end_sequence)
1911
2.82M
{
1912
2.82M
  size_t amt = sizeof (struct line_info);
1913
2.82M
  struct line_sequence* seq = table->sequences;
1914
2.82M
  struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1915
1916
2.82M
  if (info == NULL)
1917
0
    return false;
1918
1919
  /* Set member data of 'info'.  */
1920
2.82M
  info->prev_line = NULL;
1921
2.82M
  info->address = address;
1922
2.82M
  info->op_index = op_index;
1923
2.82M
  info->line = line;
1924
2.82M
  info->column = column;
1925
2.82M
  info->discriminator = discriminator;
1926
2.82M
  info->end_sequence = end_sequence;
1927
1928
2.82M
  if (filename && filename[0])
1929
2.81M
    {
1930
2.81M
      info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1931
2.81M
      if (info->filename == NULL)
1932
0
  return false;
1933
2.81M
      strcpy (info->filename, filename);
1934
2.81M
    }
1935
7.22k
  else
1936
7.22k
    info->filename = NULL;
1937
1938
  /* Find the correct location for 'info'.  Normally we will receive
1939
     new line_info data 1) in order and 2) with increasing VMAs.
1940
     However some compilers break the rules (cf. decode_line_info) and
1941
     so we include some heuristics for quickly finding the correct
1942
     location for 'info'. In particular, these heuristics optimize for
1943
     the common case in which the VMA sequence that we receive is a
1944
     list of locally sorted VMAs such as
1945
       p...z a...j  (where a < j < p < z)
1946
1947
     Note: table->lcl_head is used to head an *actual* or *possible*
1948
     sub-sequence within the list (such as a...j) that is not directly
1949
     headed by table->last_line
1950
1951
     Note: we may receive duplicate entries from 'decode_line_info'.  */
1952
1953
2.82M
  if (seq
1954
2.82M
      && seq->last_line->address == address
1955
2.82M
      && seq->last_line->op_index == op_index
1956
2.82M
      && seq->last_line->end_sequence == end_sequence)
1957
186k
    {
1958
      /* We only keep the last entry with the same address and end
1959
   sequence.  See PR ld/4986.  */
1960
186k
      if (table->lcl_head == seq->last_line)
1961
4.99k
  table->lcl_head = info;
1962
186k
      info->prev_line = seq->last_line->prev_line;
1963
186k
      seq->last_line = info;
1964
186k
    }
1965
2.64M
  else if (!seq || seq->last_line->end_sequence)
1966
22.1k
    {
1967
      /* Start a new line sequence.  */
1968
22.1k
      amt = sizeof (struct line_sequence);
1969
22.1k
      seq = (struct line_sequence *) bfd_malloc (amt);
1970
22.1k
      if (seq == NULL)
1971
0
  return false;
1972
22.1k
      seq->low_pc = address;
1973
22.1k
      seq->prev_sequence = table->sequences;
1974
22.1k
      seq->last_line = info;
1975
22.1k
      table->lcl_head = info;
1976
22.1k
      table->sequences = seq;
1977
22.1k
      table->num_sequences++;
1978
22.1k
    }
1979
2.61M
  else if (info->end_sequence
1980
2.61M
     || new_line_sorts_after (info, seq->last_line))
1981
2.53M
    {
1982
      /* Normal case: add 'info' to the beginning of the current sequence.  */
1983
2.53M
      info->prev_line = seq->last_line;
1984
2.53M
      seq->last_line = info;
1985
1986
      /* lcl_head: initialize to head a *possible* sequence at the end.  */
1987
2.53M
      if (!table->lcl_head)
1988
0
  table->lcl_head = info;
1989
2.53M
    }
1990
87.4k
  else if (!new_line_sorts_after (info, table->lcl_head)
1991
87.4k
     && (!table->lcl_head->prev_line
1992
69.1k
         || new_line_sorts_after (info, table->lcl_head->prev_line)))
1993
55.3k
    {
1994
      /* Abnormal but easy: lcl_head is the head of 'info'.  */
1995
55.3k
      info->prev_line = table->lcl_head->prev_line;
1996
55.3k
      table->lcl_head->prev_line = info;
1997
55.3k
    }
1998
32.0k
  else
1999
32.0k
    {
2000
      /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
2001
   are valid heads for 'info'.  Reset 'lcl_head'.  */
2002
32.0k
      struct line_info* li2 = seq->last_line; /* Always non-NULL.  */
2003
32.0k
      struct line_info* li1 = li2->prev_line;
2004
2005
938k
      while (li1)
2006
937k
  {
2007
937k
    if (!new_line_sorts_after (info, li2)
2008
937k
        && new_line_sorts_after (info, li1))
2009
31.0k
      break;
2010
2011
906k
    li2 = li1; /* always non-NULL */
2012
906k
    li1 = li1->prev_line;
2013
906k
  }
2014
32.0k
      table->lcl_head = li2;
2015
32.0k
      info->prev_line = table->lcl_head->prev_line;
2016
32.0k
      table->lcl_head->prev_line = info;
2017
32.0k
      if (address < seq->low_pc)
2018
161
  seq->low_pc = address;
2019
32.0k
    }
2020
2.82M
  return true;
2021
2.82M
}
2022
2023
/* Extract a fully qualified filename from a line info table.
2024
   The returned string has been malloc'ed and it is the caller's
2025
   responsibility to free it.  */
2026
2027
static char *
2028
concat_filename (struct line_info_table *table, unsigned int file)
2029
584k
{
2030
584k
  char *filename;
2031
2032
  /* Pre DWARF-5 entry 0 in the directory and filename tables was not used.
2033
     So in order to save space in the tables used here the info for, eg
2034
     directory 1 is stored in slot 0 of the directory table, directory 2
2035
     in slot 1 and so on.
2036
2037
     Starting with DWARF-5 the 0'th entry is used so there is a one to one
2038
     mapping between DWARF slots and internal table entries.  */
2039
584k
  if (! table->use_dir_and_file_0)
2040
578k
    {
2041
      /* Pre DWARF-5, FILE == 0 means unknown.  */
2042
578k
      if (file == 0)
2043
101
  return strdup ("<unknown>");
2044
578k
      -- file;
2045
578k
    }
2046
2047
584k
  if (table == NULL || file >= table->num_files)
2048
875
    {
2049
875
      _bfd_error_handler
2050
875
  (_("DWARF error: mangled line number section (bad file number)"));
2051
875
      return strdup ("<unknown>");
2052
875
    }
2053
2054
583k
  filename = table->files[file].name;
2055
2056
583k
  if (filename == NULL)
2057
817
    return strdup ("<unknown>");
2058
2059
583k
  if (!IS_ABSOLUTE_PATH (filename))
2060
582k
    {
2061
582k
      char *dir_name = NULL;
2062
582k
      char *subdir_name = NULL;
2063
582k
      char *name;
2064
582k
      size_t len;
2065
582k
      unsigned int dir = table->files[file].dir;
2066
2067
582k
      if (!table->use_dir_and_file_0)
2068
577k
  --dir;
2069
      /* Wrapping from 0 to -1u above gives the intended result with
2070
   the test below of leaving subdir_name NULL for pre-DWARF5 dir
2071
   of 0.  */
2072
      /* PR 17512: file: 0317e960, file: 7f3d2e4b.  */
2073
582k
      if (dir < table->num_dirs)
2074
199k
  subdir_name = table->dirs[dir];
2075
2076
582k
      if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
2077
500k
  dir_name = table->comp_dir;
2078
2079
582k
      if (!dir_name)
2080
122k
  {
2081
122k
    dir_name = subdir_name;
2082
122k
    subdir_name = NULL;
2083
122k
  }
2084
2085
582k
      if (!dir_name)
2086
32.4k
  return strdup (filename);
2087
2088
550k
      len = strlen (dir_name) + strlen (filename) + 2;
2089
2090
550k
      if (subdir_name)
2091
109k
  {
2092
109k
    len += strlen (subdir_name) + 1;
2093
109k
    name = (char *) bfd_malloc (len);
2094
109k
    if (name)
2095
109k
      sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
2096
109k
  }
2097
440k
      else
2098
440k
  {
2099
440k
    name = (char *) bfd_malloc (len);
2100
440k
    if (name)
2101
440k
      sprintf (name, "%s/%s", dir_name, filename);
2102
440k
  }
2103
2104
550k
      return name;
2105
582k
    }
2106
2107
72
  return strdup (filename);
2108
583k
}
2109
2110
/* Number of bits in a bfd_vma.  */
2111
46.0M
#define VMA_BITS (8 * sizeof (bfd_vma))
2112
2113
/* Check whether [low1, high1) can be combined with [low2, high2),
2114
   i.e., they touch or overlap.  */
2115
2116
static bool
2117
ranges_overlap (bfd_vma low1,
2118
    bfd_vma high1,
2119
    bfd_vma low2,
2120
    bfd_vma high2)
2121
36.8M
{
2122
36.8M
  if (low1 == low2 || high1 == high2)
2123
7.41M
    return true;
2124
2125
  /* Sort so that low1 is below low2. */
2126
29.4M
  if (low1 > low2)
2127
29.0M
    {
2128
29.0M
      bfd_vma tmp;
2129
2130
29.0M
      tmp = low1;
2131
29.0M
      low1 = low2;
2132
29.0M
      low2 = tmp;
2133
2134
29.0M
      tmp = high1;
2135
29.0M
      high1 = high2;
2136
29.0M
      high2 = tmp;
2137
29.0M
    }
2138
2139
  /* We touch iff low2 == high1.
2140
     We overlap iff low2 is within [low1, high1). */
2141
29.4M
  return low2 <= high1;
2142
36.8M
}
2143
2144
/* Insert an address range in the trie mapping addresses to compilation units.
2145
   Will return the new trie node (usually the same as is being sent in, but
2146
   in case of a leaf-to-interior conversion, or expansion of a leaf, it may be
2147
   different), or NULL on failure.  */
2148
2149
static struct trie_node *
2150
insert_arange_in_trie (bfd *abfd,
2151
           struct trie_node *trie,
2152
           bfd_vma trie_pc,
2153
           unsigned int trie_pc_bits,
2154
           struct comp_unit *unit,
2155
           bfd_vma low_pc,
2156
           bfd_vma high_pc)
2157
40.8M
{
2158
40.8M
  bfd_vma clamped_low_pc, clamped_high_pc;
2159
40.8M
  int ch, from_ch, to_ch;
2160
40.8M
  bool is_full_leaf = false;
2161
40.8M
  bool splitting_leaf_will_help = false;
2162
2163
  /* See if we can extend any of the existing ranges.  This merging
2164
     isn't perfect (if merging opens up the possibility of merging two existing
2165
     ranges, we won't find them), but it takes the majority of the cases.  */
2166
40.8M
  if (trie->num_room_in_leaf > 0)
2167
36.9M
    {
2168
36.9M
      struct trie_leaf *leaf = (struct trie_leaf *) trie;
2169
36.9M
      unsigned int i;
2170
2171
175M
      for (i = 0; i < leaf->num_stored_in_leaf; ++i)
2172
174M
  {
2173
174M
    if (leaf->ranges[i].unit == unit
2174
174M
        && ranges_overlap (low_pc, high_pc,
2175
36.8M
         leaf->ranges[i].low_pc,
2176
36.8M
         leaf->ranges[i].high_pc))
2177
36.0M
      {
2178
36.0M
        if (low_pc < leaf->ranges[i].low_pc)
2179
312k
    leaf->ranges[i].low_pc = low_pc;
2180
36.0M
        if (high_pc > leaf->ranges[i].high_pc)
2181
1.10M
    leaf->ranges[i].high_pc = high_pc;
2182
36.0M
        return trie;
2183
36.0M
      }
2184
174M
  }
2185
2186
914k
      is_full_leaf = leaf->num_stored_in_leaf == trie->num_room_in_leaf;
2187
2188
914k
      if (is_full_leaf && trie_pc_bits < VMA_BITS)
2189
14.8k
  {
2190
    /* See if we have at least one leaf that does _not_ cover the
2191
       entire bucket, so that splitting will actually reduce the number
2192
       of elements in at least one of the child nodes.  (For simplicity,
2193
       we don't test the range we're inserting, but it will be counted
2194
       on the next insertion where we're full, if any.)   */
2195
14.8k
    bfd_vma bucket_high_pc =
2196
14.8k
      trie_pc + ((bfd_vma) -1 >> trie_pc_bits);  /* Inclusive.  */
2197
196k
    for (i = 0; i < leaf->num_stored_in_leaf; ++i)
2198
184k
      {
2199
184k
        if (leaf->ranges[i].low_pc > trie_pc
2200
184k
      || leaf->ranges[i].high_pc <= bucket_high_pc)
2201
3.55k
    {
2202
3.55k
      splitting_leaf_will_help = true;
2203
3.55k
      break;
2204
3.55k
    }
2205
184k
      }
2206
14.8k
  }
2207
914k
    }
2208
2209
  /* If we're a leaf with no more room and we're _not_ at the bottom,
2210
     convert to an interior node.  */
2211
4.75M
  if (is_full_leaf && splitting_leaf_will_help)
2212
3.55k
    {
2213
3.55k
      const struct trie_leaf *leaf = (struct trie_leaf *) trie;
2214
3.55k
      unsigned int i;
2215
2216
3.55k
      trie = bfd_zalloc (abfd, sizeof (struct trie_interior));
2217
3.55k
      if (!trie)
2218
0
  return NULL;
2219
3.55k
      is_full_leaf = false;
2220
2221
      /* TODO: If we wanted to save a little more memory at the cost of
2222
   complexity, we could have reused the old leaf node as one of the
2223
   children of the new interior node, instead of throwing it away.  */
2224
60.4k
      for (i = 0; i < leaf->num_stored_in_leaf; ++i)
2225
56.8k
        {
2226
56.8k
    if (!insert_arange_in_trie (abfd, trie, trie_pc, trie_pc_bits,
2227
56.8k
              leaf->ranges[i].unit, leaf->ranges[i].low_pc,
2228
56.8k
              leaf->ranges[i].high_pc))
2229
0
      return NULL;
2230
56.8k
  }
2231
3.55k
    }
2232
2233
  /* If we're a leaf with no more room and we _are_ at the bottom
2234
     (or splitting it won't help), we have no choice but to just
2235
     make it larger.  */
2236
4.75M
  if (is_full_leaf)
2237
15.6k
    {
2238
15.6k
      const struct trie_leaf *leaf = (struct trie_leaf *) trie;
2239
15.6k
      unsigned int new_room_in_leaf = trie->num_room_in_leaf * 2;
2240
15.6k
      struct trie_leaf *new_leaf;
2241
15.6k
      size_t amt = sizeof (*leaf) + new_room_in_leaf * sizeof (leaf->ranges[0]);
2242
15.6k
      new_leaf = bfd_zalloc (abfd, amt);
2243
15.6k
      new_leaf->head.num_room_in_leaf = new_room_in_leaf;
2244
15.6k
      new_leaf->num_stored_in_leaf = leaf->num_stored_in_leaf;
2245
2246
15.6k
      memcpy (new_leaf->ranges,
2247
15.6k
        leaf->ranges,
2248
15.6k
        leaf->num_stored_in_leaf * sizeof (leaf->ranges[0]));
2249
15.6k
      trie = &new_leaf->head;
2250
15.6k
      is_full_leaf = false;
2251
2252
      /* Now the insert below will go through.  */
2253
15.6k
    }
2254
2255
  /* If we're a leaf (now with room), we can just insert at the end.  */
2256
4.75M
  if (trie->num_room_in_leaf > 0)
2257
911k
    {
2258
911k
      struct trie_leaf *leaf = (struct trie_leaf *) trie;
2259
2260
911k
      unsigned int i = leaf->num_stored_in_leaf++;
2261
911k
      leaf->ranges[i].unit = unit;
2262
911k
      leaf->ranges[i].low_pc = low_pc;
2263
911k
      leaf->ranges[i].high_pc = high_pc;
2264
911k
      return trie;
2265
911k
    }
2266
2267
  /* Now we are definitely an interior node, so recurse into all
2268
     the relevant buckets.  */
2269
2270
  /* Clamp the range to the current trie bucket.  */
2271
3.84M
  clamped_low_pc = low_pc;
2272
3.84M
  clamped_high_pc = high_pc;
2273
3.84M
  if (trie_pc_bits > 0)
2274
2.86M
    {
2275
2.86M
      bfd_vma bucket_high_pc =
2276
2.86M
  trie_pc + ((bfd_vma) -1 >> trie_pc_bits);  /* Inclusive.  */
2277
2.86M
      if (clamped_low_pc < trie_pc)
2278
10.5k
  clamped_low_pc = trie_pc;
2279
2.86M
      if (clamped_high_pc > bucket_high_pc)
2280
116k
  clamped_high_pc = bucket_high_pc;
2281
2.86M
    }
2282
2283
  /* Insert the ranges in all buckets that it spans.  */
2284
3.84M
  from_ch = (clamped_low_pc >> (VMA_BITS - trie_pc_bits - 8)) & 0xff;
2285
3.84M
  to_ch = ((clamped_high_pc - 1) >> (VMA_BITS - trie_pc_bits - 8)) & 0xff;
2286
42.1M
  for (ch = from_ch; ch <= to_ch; ++ch)
2287
38.2M
    {
2288
38.2M
      struct trie_interior *interior = (struct trie_interior *) trie;
2289
38.2M
      struct trie_node *child = interior->children[ch];
2290
2291
38.2M
      if (child == NULL)
2292
314k
        {
2293
314k
    child = alloc_trie_leaf (abfd);
2294
314k
    if (!child)
2295
0
      return NULL;
2296
314k
  }
2297
38.2M
      bfd_vma bucket = (bfd_vma) ch << (VMA_BITS - trie_pc_bits - 8);
2298
38.2M
      child = insert_arange_in_trie (abfd,
2299
38.2M
             child,
2300
38.2M
             trie_pc + bucket,
2301
38.2M
             trie_pc_bits + 8,
2302
38.2M
             unit,
2303
38.2M
             low_pc,
2304
38.2M
             high_pc);
2305
38.2M
      if (!child)
2306
0
  return NULL;
2307
2308
38.2M
      interior->children[ch] = child;
2309
38.2M
    }
2310
2311
3.84M
    return trie;
2312
3.84M
}
2313
2314
static bool
2315
arange_add (struct comp_unit *unit, struct arange *first_arange,
2316
      struct trie_node **trie_root, bfd_vma low_pc, bfd_vma high_pc)
2317
2.53M
{
2318
2.53M
  struct arange *arange;
2319
2320
  /* Ignore empty ranges.  */
2321
2.53M
  if (low_pc == high_pc)
2322
23.1k
    return true;
2323
2324
2.51M
  if (trie_root != NULL)
2325
2.51M
    {
2326
2.51M
      *trie_root = insert_arange_in_trie (unit->file->bfd_ptr,
2327
2.51M
            *trie_root,
2328
2.51M
            0,
2329
2.51M
            0,
2330
2.51M
            unit,
2331
2.51M
            low_pc,
2332
2.51M
            high_pc);
2333
2.51M
      if (*trie_root == NULL)
2334
0
  return false;
2335
2.51M
    }
2336
2337
  /* If the first arange is empty, use it.  */
2338
2.51M
  if (first_arange->high == 0)
2339
118k
    {
2340
118k
      first_arange->low = low_pc;
2341
118k
      first_arange->high = high_pc;
2342
118k
      return true;
2343
118k
    }
2344
2345
  /* Next see if we can cheaply extend an existing range.  */
2346
2.39M
  arange = first_arange;
2347
2.39M
  do
2348
1.13G
    {
2349
1.13G
      if (low_pc == arange->high)
2350
201k
  {
2351
201k
    arange->high = high_pc;
2352
201k
    return true;
2353
201k
  }
2354
1.13G
      if (high_pc == arange->low)
2355
215k
  {
2356
215k
    arange->low = low_pc;
2357
215k
    return true;
2358
215k
  }
2359
1.13G
      arange = arange->next;
2360
1.13G
    }
2361
1.13G
  while (arange);
2362
2363
  /* Need to allocate a new arange and insert it into the arange list.
2364
     Order isn't significant, so just insert after the first arange.  */
2365
1.97M
  arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
2366
1.97M
  if (arange == NULL)
2367
0
    return false;
2368
1.97M
  arange->low = low_pc;
2369
1.97M
  arange->high = high_pc;
2370
1.97M
  arange->next = first_arange->next;
2371
1.97M
  first_arange->next = arange;
2372
1.97M
  return true;
2373
1.97M
}
2374
2375
/* Compare function for line sequences.  */
2376
2377
static int
2378
compare_sequences (const void* a, const void* b)
2379
29.3k
{
2380
29.3k
  const struct line_sequence* seq1 = a;
2381
29.3k
  const struct line_sequence* seq2 = b;
2382
2383
  /* Sort by low_pc as the primary key.  */
2384
29.3k
  if (seq1->low_pc < seq2->low_pc)
2385
958
    return -1;
2386
28.3k
  if (seq1->low_pc > seq2->low_pc)
2387
24.4k
    return 1;
2388
2389
  /* If low_pc values are equal, sort in reverse order of
2390
     high_pc, so that the largest region comes first.  */
2391
3.92k
  if (seq1->last_line->address < seq2->last_line->address)
2392
1.91k
    return 1;
2393
2.01k
  if (seq1->last_line->address > seq2->last_line->address)
2394
1.79k
    return -1;
2395
2396
219
  if (seq1->last_line->op_index < seq2->last_line->op_index)
2397
28
    return 1;
2398
191
  if (seq1->last_line->op_index > seq2->last_line->op_index)
2399
29
    return -1;
2400
2401
  /* num_lines is initially an index, to make the sort stable.  */
2402
162
  if (seq1->num_lines < seq2->num_lines)
2403
162
    return -1;
2404
0
  if (seq1->num_lines > seq2->num_lines)
2405
0
    return 1;
2406
0
  return 0;
2407
0
}
2408
2409
/* Construct the line information table for quick lookup.  */
2410
2411
static bool
2412
build_line_info_table (struct line_info_table *  table,
2413
           struct line_sequence *    seq)
2414
29.0k
{
2415
29.0k
  size_t amt;
2416
29.0k
  struct line_info **line_info_lookup;
2417
29.0k
  struct line_info *each_line;
2418
29.0k
  unsigned int num_lines;
2419
29.0k
  unsigned int line_index;
2420
2421
29.0k
  if (seq->line_info_lookup != NULL)
2422
22.8k
    return true;
2423
2424
  /* Count the number of line information entries.  We could do this while
2425
     scanning the debug information, but some entries may be added via
2426
     lcl_head without having a sequence handy to increment the number of
2427
     lines.  */
2428
6.20k
  num_lines = 0;
2429
891k
  for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
2430
885k
    num_lines++;
2431
2432
6.20k
  seq->num_lines = num_lines;
2433
6.20k
  if (num_lines == 0)
2434
0
    return true;
2435
2436
  /* Allocate space for the line information lookup table.  */
2437
6.20k
  amt = sizeof (struct line_info*) * num_lines;
2438
6.20k
  line_info_lookup = (struct line_info**) bfd_alloc (table->abfd, amt);
2439
6.20k
  seq->line_info_lookup = line_info_lookup;
2440
6.20k
  if (line_info_lookup == NULL)
2441
0
    return false;
2442
2443
  /* Create the line information lookup table.  */
2444
6.20k
  line_index = num_lines;
2445
891k
  for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
2446
885k
    line_info_lookup[--line_index] = each_line;
2447
2448
6.20k
  BFD_ASSERT (line_index == 0);
2449
6.20k
  return true;
2450
6.20k
}
2451
2452
/* Sort the line sequences for quick lookup.  */
2453
2454
static bool
2455
sort_line_sequences (struct line_info_table* table)
2456
11.5k
{
2457
11.5k
  size_t amt;
2458
11.5k
  struct line_sequence *sequences;
2459
11.5k
  struct line_sequence *seq;
2460
11.5k
  unsigned int n = 0;
2461
11.5k
  unsigned int num_sequences = table->num_sequences;
2462
11.5k
  bfd_vma last_high_pc;
2463
2464
11.5k
  if (num_sequences == 0)
2465
323
    return true;
2466
2467
  /* Allocate space for an array of sequences.  */
2468
11.2k
  amt = sizeof (struct line_sequence) * num_sequences;
2469
11.2k
  sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
2470
11.2k
  if (sequences == NULL)
2471
0
    return false;
2472
2473
  /* Copy the linked list into the array, freeing the original nodes.  */
2474
11.2k
  seq = table->sequences;
2475
32.3k
  for (n = 0; n < num_sequences; n++)
2476
21.1k
    {
2477
21.1k
      struct line_sequence* last_seq = seq;
2478
2479
21.1k
      BFD_ASSERT (seq);
2480
21.1k
      sequences[n].low_pc = seq->low_pc;
2481
21.1k
      sequences[n].prev_sequence = NULL;
2482
21.1k
      sequences[n].last_line = seq->last_line;
2483
21.1k
      sequences[n].line_info_lookup = NULL;
2484
21.1k
      sequences[n].num_lines = n;
2485
21.1k
      seq = seq->prev_sequence;
2486
21.1k
      free (last_seq);
2487
21.1k
    }
2488
11.2k
  BFD_ASSERT (seq == NULL);
2489
2490
11.2k
  qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
2491
2492
  /* Make the list binary-searchable by trimming overlapping entries
2493
     and removing nested entries.  */
2494
11.2k
  num_sequences = 1;
2495
11.2k
  last_high_pc = sequences[0].last_line->address;
2496
21.1k
  for (n = 1; n < table->num_sequences; n++)
2497
9.90k
    {
2498
9.90k
      if (sequences[n].low_pc < last_high_pc)
2499
1.35k
  {
2500
1.35k
    if (sequences[n].last_line->address <= last_high_pc)
2501
      /* Skip nested entries.  */
2502
1.23k
      continue;
2503
2504
    /* Trim overlapping entries.  */
2505
112
    sequences[n].low_pc = last_high_pc;
2506
112
  }
2507
8.66k
      last_high_pc = sequences[n].last_line->address;
2508
8.66k
      if (n > num_sequences)
2509
911
  {
2510
    /* Close up the gap.  */
2511
911
    sequences[num_sequences].low_pc = sequences[n].low_pc;
2512
911
    sequences[num_sequences].last_line = sequences[n].last_line;
2513
911
  }
2514
8.66k
      num_sequences++;
2515
8.66k
    }
2516
2517
11.2k
  table->sequences = sequences;
2518
11.2k
  table->num_sequences = num_sequences;
2519
11.2k
  return true;
2520
11.2k
}
2521
2522
/* Add directory to TABLE.  CUR_DIR memory ownership is taken by TABLE.  */
2523
2524
static bool
2525
line_info_add_include_dir (struct line_info_table *table, char *cur_dir)
2526
34.6k
{
2527
34.6k
  if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
2528
11.2k
    {
2529
11.2k
      char **tmp;
2530
11.2k
      size_t amt;
2531
2532
11.2k
      amt = table->num_dirs + DIR_ALLOC_CHUNK;
2533
11.2k
      amt *= sizeof (char *);
2534
2535
11.2k
      tmp = (char **) bfd_realloc (table->dirs, amt);
2536
11.2k
      if (tmp == NULL)
2537
0
  return false;
2538
11.2k
      table->dirs = tmp;
2539
11.2k
    }
2540
2541
34.6k
  table->dirs[table->num_dirs++] = cur_dir;
2542
34.6k
  return true;
2543
34.6k
}
2544
2545
static bool
2546
line_info_add_include_dir_stub (struct line_info_table *table, char *cur_dir,
2547
        unsigned int dir ATTRIBUTE_UNUSED,
2548
        unsigned int xtime ATTRIBUTE_UNUSED,
2549
        unsigned int size ATTRIBUTE_UNUSED)
2550
1.23k
{
2551
1.23k
  return line_info_add_include_dir (table, cur_dir);
2552
1.23k
}
2553
2554
/* Add file to TABLE.  CUR_FILE memory ownership is taken by TABLE.  */
2555
2556
static bool
2557
line_info_add_file_name (struct line_info_table *table, char *cur_file,
2558
       unsigned int dir, unsigned int xtime,
2559
       unsigned int size)
2560
163k
{
2561
163k
  if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
2562
37.9k
    {
2563
37.9k
      struct fileinfo *tmp;
2564
37.9k
      size_t amt;
2565
2566
37.9k
      amt = table->num_files + FILE_ALLOC_CHUNK;
2567
37.9k
      amt *= sizeof (struct fileinfo);
2568
2569
37.9k
      tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
2570
37.9k
      if (tmp == NULL)
2571
0
  return false;
2572
37.9k
      table->files = tmp;
2573
37.9k
    }
2574
2575
163k
  table->files[table->num_files].name = cur_file;
2576
163k
  table->files[table->num_files].dir = dir;
2577
163k
  table->files[table->num_files].time = xtime;
2578
163k
  table->files[table->num_files].size = size;
2579
163k
  table->num_files++;
2580
163k
  return true;
2581
163k
}
2582
2583
/* Read directory or file name entry format, starting with byte of
2584
   format count entries, ULEB128 pairs of entry formats, ULEB128 of
2585
   entries count and the entries themselves in the described entry
2586
   format.  */
2587
2588
static bool
2589
read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
2590
      bfd_byte *buf_end, struct line_info_table *table,
2591
      bool (*callback) (struct line_info_table *table,
2592
            char *cur_file,
2593
            unsigned int dir,
2594
            unsigned int time,
2595
            unsigned int size))
2596
749
{
2597
749
  bfd *abfd = unit->abfd;
2598
749
  bfd_byte format_count, formati;
2599
749
  bfd_vma data_count, datai;
2600
749
  bfd_byte *buf = *bufp;
2601
749
  bfd_byte *format_header_data;
2602
2603
749
  format_count = read_1_byte (abfd, &buf, buf_end);
2604
749
  format_header_data = buf;
2605
12.3k
  for (formati = 0; formati < format_count; formati++)
2606
11.6k
    {
2607
11.6k
      _bfd_safe_read_leb128 (abfd, &buf, false, buf_end);
2608
11.6k
      _bfd_safe_read_leb128 (abfd, &buf, false, buf_end);
2609
11.6k
    }
2610
2611
749
  data_count = _bfd_safe_read_leb128 (abfd, &buf, false, buf_end);
2612
749
  if (format_count == 0 && data_count != 0)
2613
1
    {
2614
1
      _bfd_error_handler (_("DWARF error: zero format count"));
2615
1
      bfd_set_error (bfd_error_bad_value);
2616
1
      return false;
2617
1
    }
2618
2619
  /* PR 22210.  Paranoia check.  Don't bother running the loop
2620
     if we know that we are going to run out of buffer.  */
2621
748
  if (data_count > (bfd_vma) (buf_end - buf))
2622
0
    {
2623
0
      _bfd_error_handler
2624
0
  (_("DWARF error: data count (%" PRIx64 ") larger than buffer size"),
2625
0
   (uint64_t) data_count);
2626
0
      bfd_set_error (bfd_error_bad_value);
2627
0
      return false;
2628
0
    }
2629
2630
5.40k
  for (datai = 0; datai < data_count; datai++)
2631
4.80k
    {
2632
4.80k
      bfd_byte *format = format_header_data;
2633
4.80k
      struct fileinfo fe;
2634
2635
4.80k
      memset (&fe, 0, sizeof fe);
2636
13.1k
      for (formati = 0; formati < format_count; formati++)
2637
8.53k
  {
2638
8.53k
    bfd_vma content_type, form;
2639
8.53k
    char *string_trash;
2640
8.53k
    char **stringp = &string_trash;
2641
8.53k
    unsigned int uint_trash, *uintp = &uint_trash;
2642
8.53k
    struct attribute attr;
2643
2644
8.53k
    content_type = _bfd_safe_read_leb128 (abfd, &format, false, buf_end);
2645
8.53k
    switch (content_type)
2646
8.53k
      {
2647
4.66k
      case DW_LNCT_path:
2648
4.66k
        stringp = &fe.name;
2649
4.66k
        break;
2650
3.42k
      case DW_LNCT_directory_index:
2651
3.42k
        uintp = &fe.dir;
2652
3.42k
        break;
2653
4
      case DW_LNCT_timestamp:
2654
4
        uintp = &fe.time;
2655
4
        break;
2656
7
      case DW_LNCT_size:
2657
7
        uintp = &fe.size;
2658
7
        break;
2659
304
      case DW_LNCT_MD5:
2660
304
        break;
2661
134
      default:
2662
134
        _bfd_error_handler
2663
134
    (_("DWARF error: unknown format content type %" PRIu64),
2664
134
     (uint64_t) content_type);
2665
134
        bfd_set_error (bfd_error_bad_value);
2666
134
        return false;
2667
8.53k
      }
2668
2669
8.40k
    form = _bfd_safe_read_leb128 (abfd, &format, false, buf_end);
2670
8.40k
    buf = read_attribute_value (&attr, form, 0, unit, buf, buf_end);
2671
8.40k
    if (buf == NULL)
2672
7
      return false;
2673
8.39k
    switch (form)
2674
8.39k
      {
2675
0
      case DW_FORM_string:
2676
4.58k
      case DW_FORM_line_strp:
2677
4.58k
      case DW_FORM_strx:
2678
4.58k
      case DW_FORM_strx1:
2679
4.58k
      case DW_FORM_strx2:
2680
4.58k
      case DW_FORM_strx3:
2681
4.58k
      case DW_FORM_strx4:
2682
4.58k
        *stringp = attr.u.str;
2683
4.58k
        break;
2684
2685
0
      case DW_FORM_data1:
2686
4
      case DW_FORM_data2:
2687
4
      case DW_FORM_data4:
2688
75
      case DW_FORM_data8:
2689
3.49k
      case DW_FORM_udata:
2690
3.49k
        *uintp = attr.u.val;
2691
3.49k
        break;
2692
2693
286
      case DW_FORM_data16:
2694
        /* MD5 data is in the attr.blk, but we are ignoring those.  */
2695
286
        break;
2696
8.39k
      }
2697
8.39k
  }
2698
2699
4.65k
      if (!callback (table, fe.name, fe.dir, fe.time, fe.size))
2700
0
  return false;
2701
4.65k
    }
2702
2703
607
  *bufp = buf;
2704
607
  return true;
2705
748
}
2706
2707
/* Decode the line number information for UNIT.  */
2708
2709
static struct line_info_table*
2710
decode_line_info (struct comp_unit *unit)
2711
15.4k
{
2712
15.4k
  bfd *abfd = unit->abfd;
2713
15.4k
  struct dwarf2_debug *stash = unit->stash;
2714
15.4k
  struct dwarf2_debug_file *file = unit->file;
2715
15.4k
  struct line_info_table* table;
2716
15.4k
  bfd_byte *line_ptr;
2717
15.4k
  bfd_byte *line_end;
2718
15.4k
  struct line_head lh;
2719
15.4k
  unsigned int i, offset_size;
2720
15.4k
  char *cur_file, *cur_dir;
2721
15.4k
  unsigned char op_code, extended_op, adj_opcode;
2722
15.4k
  unsigned int exop_len;
2723
15.4k
  size_t amt;
2724
2725
15.4k
  if (unit->line_offset == 0 && file->line_table)
2726
10
    return file->line_table;
2727
2728
15.4k
  if (! read_section (abfd, &stash->debug_sections[debug_line],
2729
15.4k
          file->syms, unit->line_offset,
2730
15.4k
          &file->dwarf_line_buffer, &file->dwarf_line_size))
2731
193
    return NULL;
2732
2733
15.2k
  if (file->dwarf_line_size < 16)
2734
1
    {
2735
1
      _bfd_error_handler
2736
1
  (_("DWARF error: line info section is too small (%" PRId64 ")"),
2737
1
   (int64_t) file->dwarf_line_size);
2738
1
      bfd_set_error (bfd_error_bad_value);
2739
1
      return NULL;
2740
1
    }
2741
15.2k
  line_ptr = file->dwarf_line_buffer + unit->line_offset;
2742
15.2k
  line_end = file->dwarf_line_buffer + file->dwarf_line_size;
2743
2744
  /* Read in the prologue.  */
2745
15.2k
  lh.total_length = read_4_bytes (abfd, &line_ptr, line_end);
2746
15.2k
  offset_size = 4;
2747
15.2k
  if (lh.total_length == 0xffffffff)
2748
88
    {
2749
88
      lh.total_length = read_8_bytes (abfd, &line_ptr, line_end);
2750
88
      offset_size = 8;
2751
88
    }
2752
15.1k
  else if (lh.total_length == 0 && unit->addr_size == 8)
2753
18
    {
2754
      /* Handle (non-standard) 64-bit DWARF2 formats.  */
2755
18
      lh.total_length = read_4_bytes (abfd, &line_ptr, line_end);
2756
18
      offset_size = 8;
2757
18
    }
2758
2759
15.2k
  if (lh.total_length > (size_t) (line_end - line_ptr))
2760
2.53k
    {
2761
2.53k
      _bfd_error_handler
2762
  /* xgettext: c-format */
2763
2.53k
  (_("DWARF error: line info data is bigger (%#" PRIx64 ")"
2764
2.53k
     " than the space remaining in the section (%#lx)"),
2765
2.53k
   (uint64_t) lh.total_length, (unsigned long) (line_end - line_ptr));
2766
2.53k
      bfd_set_error (bfd_error_bad_value);
2767
2.53k
      return NULL;
2768
2.53k
    }
2769
2770
12.7k
  line_end = line_ptr + lh.total_length;
2771
2772
12.7k
  lh.version = read_2_bytes (abfd, &line_ptr, line_end);
2773
12.7k
  if (lh.version < 2 || lh.version > 5)
2774
503
    {
2775
503
      _bfd_error_handler
2776
503
  (_("DWARF error: unhandled .debug_line version %d"), lh.version);
2777
503
      bfd_set_error (bfd_error_bad_value);
2778
503
      return NULL;
2779
503
    }
2780
2781
12.2k
  if (line_ptr + offset_size + (lh.version >= 5 ? 8 : (lh.version >= 4 ? 6 : 5))
2782
12.2k
      >= line_end)
2783
2
    {
2784
2
      _bfd_error_handler
2785
2
  (_("DWARF error: ran out of room reading prologue"));
2786
2
      bfd_set_error (bfd_error_bad_value);
2787
2
      return NULL;
2788
2
    }
2789
2790
12.2k
  if (lh.version >= 5)
2791
395
    {
2792
395
      unsigned int segment_selector_size;
2793
2794
      /* Skip address size.  */
2795
395
      read_1_byte (abfd, &line_ptr, line_end);
2796
2797
395
      segment_selector_size = read_1_byte (abfd, &line_ptr, line_end);
2798
395
      if (segment_selector_size != 0)
2799
2
  {
2800
2
    _bfd_error_handler
2801
2
      (_("DWARF error: line info unsupported segment selector size %u"),
2802
2
       segment_selector_size);
2803
2
    bfd_set_error (bfd_error_bad_value);
2804
2
    return NULL;
2805
2
  }
2806
395
    }
2807
2808
12.2k
  if (offset_size == 4)
2809
12.2k
    lh.prologue_length = read_4_bytes (abfd, &line_ptr, line_end);
2810
3
  else
2811
3
    lh.prologue_length = read_8_bytes (abfd, &line_ptr, line_end);
2812
2813
12.2k
  lh.minimum_instruction_length = read_1_byte (abfd, &line_ptr, line_end);
2814
2815
12.2k
  if (lh.version >= 4)
2816
1.56k
    lh.maximum_ops_per_insn = read_1_byte (abfd, &line_ptr, line_end);
2817
10.6k
  else
2818
10.6k
    lh.maximum_ops_per_insn = 1;
2819
2820
12.2k
  if (lh.maximum_ops_per_insn == 0)
2821
3
    {
2822
3
      _bfd_error_handler
2823
3
  (_("DWARF error: invalid maximum operations per instruction"));
2824
3
      bfd_set_error (bfd_error_bad_value);
2825
3
      return NULL;
2826
3
    }
2827
2828
12.2k
  lh.default_is_stmt = read_1_byte (abfd, &line_ptr, line_end);
2829
12.2k
  lh.line_base = read_1_signed_byte (abfd, &line_ptr, line_end);
2830
12.2k
  lh.line_range = read_1_byte (abfd, &line_ptr, line_end);
2831
12.2k
  lh.opcode_base = read_1_byte (abfd, &line_ptr, line_end);
2832
2833
12.2k
  if (line_ptr + (lh.opcode_base - 1) >= line_end)
2834
6
    {
2835
6
      _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2836
6
      bfd_set_error (bfd_error_bad_value);
2837
6
      return NULL;
2838
6
    }
2839
2840
12.1k
  amt = lh.opcode_base * sizeof (unsigned char);
2841
12.1k
  lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
2842
2843
12.1k
  lh.standard_opcode_lengths[0] = 1;
2844
2845
140k
  for (i = 1; i < lh.opcode_base; ++i)
2846
128k
    lh.standard_opcode_lengths[i] = read_1_byte (abfd, &line_ptr, line_end);
2847
2848
12.1k
  amt = sizeof (struct line_info_table);
2849
12.1k
  table = (struct line_info_table *) bfd_alloc (abfd, amt);
2850
12.1k
  if (table == NULL)
2851
0
    return NULL;
2852
12.1k
  table->abfd = abfd;
2853
12.1k
  table->comp_dir = unit->comp_dir;
2854
2855
12.1k
  table->num_files = 0;
2856
12.1k
  table->files = NULL;
2857
2858
12.1k
  table->num_dirs = 0;
2859
12.1k
  table->dirs = NULL;
2860
2861
12.1k
  table->num_sequences = 0;
2862
12.1k
  table->sequences = NULL;
2863
2864
12.1k
  table->lcl_head = NULL;
2865
2866
12.1k
  if (lh.version >= 5)
2867
392
    {
2868
      /* Read directory table.  */
2869
392
      if (!read_formatted_entries (unit, &line_ptr, line_end, table,
2870
392
           line_info_add_include_dir_stub))
2871
35
  goto fail;
2872
2873
      /* Read file name table.  */
2874
357
      if (!read_formatted_entries (unit, &line_ptr, line_end, table,
2875
357
           line_info_add_file_name))
2876
107
  goto fail;
2877
250
      table->use_dir_and_file_0 = true;
2878
250
    }
2879
11.8k
  else
2880
11.8k
    {
2881
      /* Read directory table.  */
2882
45.2k
      while ((cur_dir = read_string (&line_ptr, line_end)) != NULL)
2883
33.4k
  {
2884
33.4k
    if (!line_info_add_include_dir (table, cur_dir))
2885
0
      goto fail;
2886
33.4k
  }
2887
2888
      /* Read file name table.  */
2889
172k
      while ((cur_file = read_string (&line_ptr, line_end)) != NULL)
2890
160k
  {
2891
160k
    unsigned int dir, xtime, size;
2892
2893
160k
    dir = _bfd_safe_read_leb128 (abfd, &line_ptr, false, line_end);
2894
160k
    xtime = _bfd_safe_read_leb128 (abfd, &line_ptr, false, line_end);
2895
160k
    size = _bfd_safe_read_leb128 (abfd, &line_ptr, false, line_end);
2896
2897
160k
    if (!line_info_add_file_name (table, cur_file, dir, xtime, size))
2898
0
      goto fail;
2899
160k
  }
2900
11.8k
      table->use_dir_and_file_0 = false;
2901
11.8k
    }
2902
2903
  /* Read the statement sequences until there's nothing left.  */
2904
33.7k
  while (line_ptr < line_end)
2905
22.1k
    {
2906
      /* State machine registers.  */
2907
22.1k
      bfd_vma address = 0;
2908
22.1k
      unsigned char op_index = 0;
2909
22.1k
      char * filename = NULL;
2910
22.1k
      unsigned int line = 1;
2911
22.1k
      unsigned int column = 0;
2912
22.1k
      unsigned int discriminator = 0;
2913
22.1k
      int is_stmt = lh.default_is_stmt;
2914
22.1k
      int end_sequence = 0;
2915
22.1k
      unsigned int dir, xtime, size;
2916
      /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2917
   compilers generate address sequences that are wildly out of
2918
   order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2919
   for ia64-Linux).  Thus, to determine the low and high
2920
   address, we must compare on every DW_LNS_copy, etc.  */
2921
22.1k
      bfd_vma low_pc  = (bfd_vma) -1;
2922
22.1k
      bfd_vma high_pc = 0;
2923
2924
22.1k
      if (table->num_files)
2925
22.1k
  {
2926
    /* PR 30783: Always start with a file index of 1, even
2927
       for DWARF-5.  */
2928
22.1k
    filename = concat_filename (table, 1);
2929
22.1k
  }
2930
2931
      /* Decode the table.  */
2932
7.13M
      while (!end_sequence && line_ptr < line_end)
2933
7.10M
  {
2934
7.10M
    op_code = read_1_byte (abfd, &line_ptr, line_end);
2935
2936
7.10M
    if (op_code >= lh.opcode_base)
2937
2.53M
      {
2938
        /* Special operand.  */
2939
2.53M
        adj_opcode = op_code - lh.opcode_base;
2940
2.53M
        if (lh.line_range == 0)
2941
14
    goto line_fail;
2942
2.53M
        if (lh.maximum_ops_per_insn == 1)
2943
2.51M
    address += (adj_opcode / lh.line_range
2944
2.51M
          * lh.minimum_instruction_length);
2945
19.5k
        else
2946
19.5k
    {
2947
19.5k
      address += ((op_index + adj_opcode / lh.line_range)
2948
19.5k
            / lh.maximum_ops_per_insn
2949
19.5k
            * lh.minimum_instruction_length);
2950
19.5k
      op_index = ((op_index + adj_opcode / lh.line_range)
2951
19.5k
            % lh.maximum_ops_per_insn);
2952
19.5k
    }
2953
2.53M
        line += lh.line_base + (adj_opcode % lh.line_range);
2954
        /* Append row to matrix using current values.  */
2955
2.53M
        if (!add_line_info (table, address, op_index, filename,
2956
2.53M
          line, column, discriminator, 0))
2957
0
    goto line_fail;
2958
2.53M
        discriminator = 0;
2959
2.53M
        if (address < low_pc)
2960
6.13k
    low_pc = address;
2961
2.53M
        if (address > high_pc)
2962
2.31M
    high_pc = address;
2963
2.53M
      }
2964
4.57M
    else switch (op_code)
2965
4.57M
      {
2966
1.16M
      case DW_LNS_extended_op:
2967
1.16M
        exop_len = _bfd_safe_read_leb128 (abfd, &line_ptr,
2968
1.16M
            false, line_end);
2969
1.16M
        extended_op = read_1_byte (abfd, &line_ptr, line_end);
2970
2971
1.16M
        switch (extended_op)
2972
1.16M
    {
2973
21.5k
    case DW_LNE_end_sequence:
2974
21.5k
      end_sequence = 1;
2975
21.5k
      if (!add_line_info (table, address, op_index, filename, line,
2976
21.5k
              column, discriminator, end_sequence))
2977
0
        goto line_fail;
2978
21.5k
      discriminator = 0;
2979
21.5k
      if (address < low_pc)
2980
803
        low_pc = address;
2981
21.5k
      if (address > high_pc)
2982
21.1k
        high_pc = address;
2983
21.5k
      if (!arange_add (unit, &unit->arange, &unit->file->trie_root,
2984
21.5k
           low_pc, high_pc))
2985
0
        goto line_fail;
2986
21.5k
      break;
2987
1.13M
    case DW_LNE_set_address:
2988
1.13M
      address = read_address (unit, &line_ptr, line_end);
2989
1.13M
      op_index = 0;
2990
1.13M
      break;
2991
131
    case DW_LNE_define_file:
2992
131
      cur_file = read_string (&line_ptr, line_end);
2993
131
      dir = _bfd_safe_read_leb128 (abfd, &line_ptr,
2994
131
                 false, line_end);
2995
131
      xtime = _bfd_safe_read_leb128 (abfd, &line_ptr,
2996
131
             false, line_end);
2997
131
      size = _bfd_safe_read_leb128 (abfd, &line_ptr,
2998
131
            false, line_end);
2999
131
      if (!line_info_add_file_name (table, cur_file, dir,
3000
131
            xtime, size))
3001
0
        goto line_fail;
3002
131
      break;
3003
4.42k
    case DW_LNE_set_discriminator:
3004
4.42k
      discriminator = _bfd_safe_read_leb128 (abfd, &line_ptr,
3005
4.42k
               false, line_end);
3006
4.42k
      break;
3007
20
    case DW_LNE_HP_source_file_correlation:
3008
20
      line_ptr += exop_len - 1;
3009
20
      break;
3010
498
    default:
3011
498
      _bfd_error_handler
3012
498
        (_("DWARF error: mangled line number section"));
3013
498
      bfd_set_error (bfd_error_bad_value);
3014
514
    line_fail:
3015
514
      free (filename);
3016
514
      goto fail;
3017
1.16M
    }
3018
1.16M
        break;
3019
1.16M
      case DW_LNS_copy:
3020
269k
        if (!add_line_info (table, address, op_index,
3021
269k
          filename, line, column, discriminator, 0))
3022
0
    goto line_fail;
3023
269k
        discriminator = 0;
3024
269k
        if (address < low_pc)
3025
15.5k
    low_pc = address;
3026
269k
        if (address > high_pc)
3027
208k
    high_pc = address;
3028
269k
        break;
3029
99.2k
      case DW_LNS_advance_pc:
3030
99.2k
        if (lh.maximum_ops_per_insn == 1)
3031
97.9k
    address += (lh.minimum_instruction_length
3032
97.9k
          * _bfd_safe_read_leb128 (abfd, &line_ptr,
3033
97.9k
                 false, line_end));
3034
1.31k
        else
3035
1.31k
    {
3036
1.31k
      bfd_vma adjust = _bfd_safe_read_leb128 (abfd, &line_ptr,
3037
1.31k
                false, line_end);
3038
1.31k
      address = ((op_index + adjust) / lh.maximum_ops_per_insn
3039
1.31k
           * lh.minimum_instruction_length);
3040
1.31k
      op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
3041
1.31k
    }
3042
99.2k
        break;
3043
954k
      case DW_LNS_advance_line:
3044
954k
        line += _bfd_safe_read_leb128 (abfd, &line_ptr,
3045
954k
               true, line_end);
3046
954k
        break;
3047
142k
      case DW_LNS_set_file:
3048
142k
        {
3049
142k
    unsigned int filenum;
3050
3051
    /* The file and directory tables are 0
3052
       based, the references are 1 based.  */
3053
142k
    filenum = _bfd_safe_read_leb128 (abfd, &line_ptr,
3054
142k
             false, line_end);
3055
142k
    free (filename);
3056
142k
    filename = concat_filename (table, filenum);
3057
142k
    break;
3058
269k
        }
3059
931k
      case DW_LNS_set_column:
3060
931k
        column = _bfd_safe_read_leb128 (abfd, &line_ptr,
3061
931k
                false, line_end);
3062
931k
        break;
3063
584k
      case DW_LNS_negate_stmt:
3064
584k
        is_stmt = (!is_stmt);
3065
584k
        break;
3066
424
      case DW_LNS_set_basic_block:
3067
424
        break;
3068
412k
      case DW_LNS_const_add_pc:
3069
412k
        if (lh.line_range == 0)
3070
2
    goto line_fail;
3071
412k
        if (lh.maximum_ops_per_insn == 1)
3072
407k
    address += (lh.minimum_instruction_length
3073
407k
          * ((255 - lh.opcode_base) / lh.line_range));
3074
4.69k
        else
3075
4.69k
    {
3076
4.69k
      bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
3077
4.69k
      address += (lh.minimum_instruction_length
3078
4.69k
            * ((op_index + adjust)
3079
4.69k
         / lh.maximum_ops_per_insn));
3080
4.69k
      op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
3081
4.69k
    }
3082
412k
        break;
3083
1.25k
      case DW_LNS_fixed_advance_pc:
3084
1.25k
        address += read_2_bytes (abfd, &line_ptr, line_end);
3085
1.25k
        op_index = 0;
3086
1.25k
        break;
3087
12.2k
      default:
3088
        /* Unknown standard opcode, ignore it.  */
3089
59.1k
        for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
3090
46.9k
    (void) _bfd_safe_read_leb128 (abfd, &line_ptr,
3091
46.9k
                false, line_end);
3092
12.2k
        break;
3093
4.57M
      }
3094
7.10M
  }
3095
3096
21.6k
      free (filename);
3097
21.6k
    }
3098
3099
11.5k
  if (unit->line_offset == 0)
3100
1.26k
    file->line_table = table;
3101
11.5k
  if (sort_line_sequences (table))
3102
11.5k
    return table;
3103
3104
656
 fail:
3105
1.65k
  while (table->sequences != NULL)
3106
994
    {
3107
994
      struct line_sequence* seq = table->sequences;
3108
994
      table->sequences = table->sequences->prev_sequence;
3109
994
      free (seq);
3110
994
    }
3111
656
  free (table->files);
3112
656
  free (table->dirs);
3113
656
  return NULL;
3114
11.5k
}
3115
3116
/* If ADDR is within TABLE set the output parameters and return TRUE,
3117
   otherwise set *FILENAME_PTR to NULL and return FALSE.
3118
   The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
3119
   are pointers to the objects to be filled in.  */
3120
3121
static bool
3122
lookup_address_in_line_info_table (struct line_info_table *table,
3123
           bfd_vma addr,
3124
           const char **filename_ptr,
3125
           unsigned int *linenumber_ptr,
3126
           unsigned int *discriminator_ptr)
3127
42.3k
{
3128
42.3k
  struct line_sequence *seq = NULL;
3129
42.3k
  struct line_info *info;
3130
42.3k
  int low, high, mid;
3131
3132
  /* Binary search the array of sequences.  */
3133
42.3k
  low = 0;
3134
42.3k
  high = table->num_sequences;
3135
98.6k
  while (low < high)
3136
85.3k
    {
3137
85.3k
      mid = (low + high) / 2;
3138
85.3k
      seq = &table->sequences[mid];
3139
85.3k
      if (addr < seq->low_pc)
3140
29.5k
  high = mid;
3141
55.7k
      else if (addr >= seq->last_line->address)
3142
26.7k
  low = mid + 1;
3143
29.0k
      else
3144
29.0k
  break;
3145
85.3k
    }
3146
3147
  /* Check for a valid sequence.  */
3148
42.3k
  if (!seq || addr < seq->low_pc || addr >= seq->last_line->address)
3149
13.2k
    goto fail;
3150
3151
29.0k
  if (!build_line_info_table (table, seq))
3152
0
    goto fail;
3153
3154
  /* Binary search the array of line information.  */
3155
29.0k
  low = 0;
3156
29.0k
  high = seq->num_lines;
3157
29.0k
  info = NULL;
3158
202k
  while (low < high)
3159
202k
    {
3160
202k
      mid = (low + high) / 2;
3161
202k
      info = seq->line_info_lookup[mid];
3162
202k
      if (addr < info->address)
3163
116k
  high = mid;
3164
85.8k
      else if (addr >= seq->line_info_lookup[mid + 1]->address)
3165
56.8k
  low = mid + 1;
3166
29.0k
      else
3167
29.0k
  break;
3168
202k
    }
3169
3170
  /* Check for a valid line information entry.  */
3171
29.0k
  if (info
3172
29.0k
      && addr >= info->address
3173
29.0k
      && addr < seq->line_info_lookup[mid + 1]->address
3174
29.0k
      && !(info->end_sequence || info == seq->last_line))
3175
29.0k
    {
3176
29.0k
      *filename_ptr = info->filename;
3177
29.0k
      *linenumber_ptr = info->line;
3178
29.0k
      if (discriminator_ptr)
3179
255
  *discriminator_ptr = info->discriminator;
3180
29.0k
      return true;
3181
29.0k
    }
3182
3183
13.2k
 fail:
3184
13.2k
  *filename_ptr = NULL;
3185
13.2k
  return false;
3186
29.0k
}
3187
3188
/* Read in the .debug_ranges section for future reference.  */
3189
3190
static bool
3191
read_debug_ranges (struct comp_unit * unit)
3192
1.11k
{
3193
1.11k
  struct dwarf2_debug *stash = unit->stash;
3194
1.11k
  struct dwarf2_debug_file *file = unit->file;
3195
3196
1.11k
  return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
3197
1.11k
           file->syms, 0,
3198
1.11k
           &file->dwarf_ranges_buffer, &file->dwarf_ranges_size);
3199
1.11k
}
3200
3201
/* Read in the .debug_rnglists section for future reference.  */
3202
3203
static bool
3204
read_debug_rnglists (struct comp_unit * unit)
3205
0
{
3206
0
  struct dwarf2_debug *stash = unit->stash;
3207
0
  struct dwarf2_debug_file *file = unit->file;
3208
3209
0
  return read_section (unit->abfd, &stash->debug_sections[debug_rnglists],
3210
0
           file->syms, 0,
3211
0
           &file->dwarf_rnglists_buffer, &file->dwarf_rnglists_size);
3212
0
}
3213
3214
/* Function table functions.  */
3215
3216
static int
3217
compare_lookup_funcinfos (const void * a, const void * b)
3218
388k
{
3219
388k
  const struct lookup_funcinfo * lookup1 = a;
3220
388k
  const struct lookup_funcinfo * lookup2 = b;
3221
3222
388k
  if (lookup1->low_addr < lookup2->low_addr)
3223
212k
    return -1;
3224
175k
  if (lookup1->low_addr > lookup2->low_addr)
3225
69.0k
    return 1;
3226
106k
  if (lookup1->high_addr < lookup2->high_addr)
3227
3.36k
    return -1;
3228
103k
  if (lookup1->high_addr > lookup2->high_addr)
3229
24.0k
    return 1;
3230
3231
79.4k
  if (lookup1->idx < lookup2->idx)
3232
79.4k
    return -1;
3233
0
  if (lookup1->idx > lookup2->idx)
3234
0
    return 1;
3235
0
  return 0;
3236
0
}
3237
3238
static bool
3239
build_lookup_funcinfo_table (struct comp_unit * unit)
3240
39.8k
{
3241
39.8k
  struct lookup_funcinfo *lookup_funcinfo_table = unit->lookup_funcinfo_table;
3242
39.8k
  unsigned int number_of_functions = unit->number_of_functions;
3243
39.8k
  struct funcinfo *each;
3244
39.8k
  struct lookup_funcinfo *entry;
3245
39.8k
  size_t func_index;
3246
39.8k
  struct arange *range;
3247
39.8k
  bfd_vma low_addr, high_addr;
3248
3249
39.8k
  if (lookup_funcinfo_table || number_of_functions == 0)
3250
36.9k
    return true;
3251
3252
  /* Create the function info lookup table.  */
3253
2.80k
  lookup_funcinfo_table = (struct lookup_funcinfo *)
3254
2.80k
    bfd_malloc (number_of_functions * sizeof (struct lookup_funcinfo));
3255
2.80k
  if (lookup_funcinfo_table == NULL)
3256
0
    return false;
3257
3258
  /* Populate the function info lookup table.  */
3259
2.80k
  func_index = number_of_functions;
3260
91.4k
  for (each = unit->function_table; each; each = each->prev_func)
3261
88.6k
    {
3262
88.6k
      entry = &lookup_funcinfo_table[--func_index];
3263
88.6k
      entry->funcinfo = each;
3264
88.6k
      entry->idx = func_index;
3265
3266
      /* Calculate the lowest and highest address for this function entry.  */
3267
88.6k
      low_addr  = entry->funcinfo->arange.low;
3268
88.6k
      high_addr = entry->funcinfo->arange.high;
3269
3270
1.77M
      for (range = entry->funcinfo->arange.next; range; range = range->next)
3271
1.69M
  {
3272
1.69M
    if (range->low < low_addr)
3273
12.8k
      low_addr = range->low;
3274
1.69M
    if (range->high > high_addr)
3275
40.1k
      high_addr = range->high;
3276
1.69M
  }
3277
3278
88.6k
      entry->low_addr = low_addr;
3279
88.6k
      entry->high_addr = high_addr;
3280
88.6k
    }
3281
3282
2.80k
  BFD_ASSERT (func_index == 0);
3283
3284
  /* Sort the function by address.  */
3285
2.80k
  qsort (lookup_funcinfo_table,
3286
2.80k
   number_of_functions,
3287
2.80k
   sizeof (struct lookup_funcinfo),
3288
2.80k
   compare_lookup_funcinfos);
3289
3290
  /* Calculate the high watermark for each function in the lookup table.  */
3291
2.80k
  high_addr = lookup_funcinfo_table[0].high_addr;
3292
88.6k
  for (func_index = 1; func_index < number_of_functions; func_index++)
3293
85.8k
    {
3294
85.8k
      entry = &lookup_funcinfo_table[func_index];
3295
85.8k
      if (entry->high_addr > high_addr)
3296
14.7k
  high_addr = entry->high_addr;
3297
71.0k
      else
3298
71.0k
  entry->high_addr = high_addr;
3299
85.8k
    }
3300
3301
2.80k
  unit->lookup_funcinfo_table = lookup_funcinfo_table;
3302
2.80k
  return true;
3303
2.80k
}
3304
3305
/* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
3306
   TRUE.  Note that we need to find the function that has the smallest range
3307
   that contains ADDR, to handle inlined functions without depending upon
3308
   them being ordered in TABLE by increasing range.  */
3309
3310
static bool
3311
lookup_address_in_function_table (struct comp_unit *unit,
3312
          bfd_vma addr,
3313
          struct funcinfo **function_ptr)
3314
42.3k
{
3315
42.3k
  unsigned int number_of_functions = unit->number_of_functions;
3316
42.3k
  struct lookup_funcinfo* lookup_funcinfo = NULL;
3317
42.3k
  struct funcinfo* funcinfo = NULL;
3318
42.3k
  struct funcinfo* best_fit = NULL;
3319
42.3k
  bfd_vma best_fit_len = (bfd_vma) -1;
3320
42.3k
  bfd_size_type low, high, mid, first;
3321
42.3k
  struct arange *arange;
3322
3323
42.3k
  if (number_of_functions == 0)
3324
2.51k
    return false;
3325
3326
39.8k
  if (!build_lookup_funcinfo_table (unit))
3327
0
    return false;
3328
3329
39.8k
  if (unit->lookup_funcinfo_table[number_of_functions - 1].high_addr < addr)
3330
7.20k
    return false;
3331
3332
  /* Find the first function in the lookup table which may contain the
3333
     specified address.  */
3334
32.5k
  low = 0;
3335
32.5k
  high = number_of_functions;
3336
32.5k
  first = high;
3337
225k
  while (low < high)
3338
193k
    {
3339
193k
      mid = (low + high) / 2;
3340
193k
      lookup_funcinfo = &unit->lookup_funcinfo_table[mid];
3341
193k
      if (addr < lookup_funcinfo->low_addr)
3342
41.5k
  high = mid;
3343
151k
      else if (addr >= lookup_funcinfo->high_addr)
3344
90.9k
  low = mid + 1;
3345
60.7k
      else
3346
60.7k
  high = first = mid;
3347
193k
    }
3348
3349
  /* Find the 'best' match for the address.  The prior algorithm defined the
3350
     best match as the function with the smallest address range containing
3351
     the specified address.  This definition should probably be changed to the
3352
     innermost inline routine containing the address, but right now we want
3353
     to get the same results we did before.  */
3354
957k
  while (first < number_of_functions)
3355
944k
    {
3356
944k
      if (addr < unit->lookup_funcinfo_table[first].low_addr)
3357
20.4k
  break;
3358
924k
      funcinfo = unit->lookup_funcinfo_table[first].funcinfo;
3359
3360
178M
      for (arange = &funcinfo->arange; arange; arange = arange->next)
3361
177M
  {
3362
177M
    if (addr < arange->low || addr >= arange->high)
3363
158M
      continue;
3364
3365
19.1M
    if (arange->high - arange->low < best_fit_len
3366
        /* The following comparison is designed to return the same
3367
     match as the previous algorithm for routines which have the
3368
     same best fit length.  */
3369
19.1M
        || (arange->high - arange->low == best_fit_len
3370
19.1M
      && funcinfo > best_fit))
3371
92.4k
      {
3372
92.4k
        best_fit = funcinfo;
3373
92.4k
        best_fit_len = arange->high - arange->low;
3374
92.4k
      }
3375
19.1M
  }
3376
3377
924k
      first++;
3378
924k
    }
3379
3380
32.5k
  if (!best_fit)
3381
4.26k
    return false;
3382
3383
28.3k
  *function_ptr = best_fit;
3384
28.3k
  return true;
3385
32.5k
}
3386
3387
/* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
3388
   and LINENUMBER_PTR, and return TRUE.  */
3389
3390
static bool
3391
lookup_symbol_in_function_table (struct comp_unit *unit,
3392
         asymbol *sym,
3393
         bfd_vma addr,
3394
         const char **filename_ptr,
3395
         unsigned int *linenumber_ptr)
3396
216k
{
3397
216k
  struct funcinfo* each;
3398
216k
  struct funcinfo* best_fit = NULL;
3399
216k
  bfd_vma best_fit_len = (bfd_vma) -1;
3400
216k
  struct arange *arange;
3401
216k
  const char *name = bfd_asymbol_name (sym);
3402
3403
5.37M
  for (each = unit->function_table; each; each = each->prev_func)
3404
145M
    for (arange = &each->arange; arange; arange = arange->next)
3405
140M
      if (addr >= arange->low
3406
140M
    && addr < arange->high
3407
140M
    && arange->high - arange->low < best_fit_len
3408
140M
    && each->file
3409
140M
    && each->name
3410
140M
    && strstr (name, each->name) != NULL)
3411
22.4k
  {
3412
22.4k
    best_fit = each;
3413
22.4k
    best_fit_len = arange->high - arange->low;
3414
22.4k
  }
3415
3416
216k
  if (best_fit)
3417
21.2k
    {
3418
21.2k
      *filename_ptr = best_fit->file;
3419
21.2k
      *linenumber_ptr = best_fit->line;
3420
21.2k
      return true;
3421
21.2k
    }
3422
3423
195k
  return false;
3424
216k
}
3425
3426
/* Variable table functions.  */
3427
3428
/* If SYM is within variable table of UNIT, set FILENAME_PTR and
3429
   LINENUMBER_PTR, and return TRUE.  */
3430
3431
static bool
3432
lookup_symbol_in_variable_table (struct comp_unit *unit,
3433
         asymbol *sym,
3434
         bfd_vma addr,
3435
         const char **filename_ptr,
3436
         unsigned int *linenumber_ptr)
3437
2.74M
{
3438
2.74M
  struct varinfo* each;
3439
2.74M
  const char *name = bfd_asymbol_name (sym);
3440
3441
84.5M
  for (each = unit->variable_table; each; each = each->prev_var)
3442
81.8M
    if (each->addr == addr
3443
81.8M
  && !each->stack
3444
81.8M
  && each->file != NULL
3445
81.8M
  && each->name != NULL
3446
81.8M
  && strstr (name, each->name) != NULL)
3447
8.55k
      break;
3448
3449
2.74M
  if (each)
3450
8.55k
    {
3451
8.55k
      *filename_ptr = each->file;
3452
8.55k
      *linenumber_ptr = each->line;
3453
8.55k
      return true;
3454
8.55k
    }
3455
3456
2.73M
  return false;
3457
2.74M
}
3458
3459
static struct comp_unit *stash_comp_unit (struct dwarf2_debug *,
3460
            struct dwarf2_debug_file *);
3461
static bool comp_unit_maybe_decode_line_info (struct comp_unit *);
3462
3463
static bool
3464
find_abstract_instance (struct comp_unit *unit,
3465
      struct attribute *attr_ptr,
3466
      unsigned int recur_count,
3467
      const char **pname,
3468
      bool *is_linkage,
3469
      char **filename_ptr,
3470
      int *linenumber_ptr)
3471
65.3k
{
3472
65.3k
  bfd *abfd = unit->abfd;
3473
65.3k
  bfd_byte *info_ptr = NULL;
3474
65.3k
  bfd_byte *info_ptr_end;
3475
65.3k
  unsigned int abbrev_number, i;
3476
65.3k
  struct abbrev_info *abbrev;
3477
65.3k
  uint64_t die_ref = attr_ptr->u.val;
3478
65.3k
  struct attribute attr;
3479
3480
65.3k
  if (recur_count == 100)
3481
0
    {
3482
0
      _bfd_error_handler
3483
0
  (_("DWARF error: abstract instance recursion detected"));
3484
0
      bfd_set_error (bfd_error_bad_value);
3485
0
      return false;
3486
0
    }
3487
3488
  /* DW_FORM_ref_addr can reference an entry in a different CU. It
3489
     is an offset from the .debug_info section, not the current CU.  */
3490
65.3k
  if (attr_ptr->form == DW_FORM_ref_addr)
3491
28
    {
3492
      /* We only support DW_FORM_ref_addr within the same file, so
3493
   any relocations should be resolved already.  Check this by
3494
   testing for a zero die_ref;  There can't be a valid reference
3495
   to the header of a .debug_info section.
3496
   DW_FORM_ref_addr is an offset relative to .debug_info.
3497
   Normally when using the GNU linker this is accomplished by
3498
   emitting a symbolic reference to a label, because .debug_info
3499
   sections are linked at zero.  When there are multiple section
3500
   groups containing .debug_info, as there might be in a
3501
   relocatable object file, it would be reasonable to assume that
3502
   a symbolic reference to a label in any .debug_info section
3503
   might be used.  Since we lay out multiple .debug_info
3504
   sections at non-zero VMAs (see place_sections), and read
3505
   them contiguously into dwarf_info_buffer, that means the
3506
   reference is relative to dwarf_info_buffer.  */
3507
28
      size_t total;
3508
3509
28
      info_ptr = unit->file->dwarf_info_buffer;
3510
28
      info_ptr_end = info_ptr + unit->file->dwarf_info_size;
3511
28
      total = info_ptr_end - info_ptr;
3512
28
      if (!die_ref)
3513
1
  return true;
3514
27
      else if (die_ref >= total)
3515
0
  {
3516
0
    _bfd_error_handler
3517
0
      (_("DWARF error: invalid abstract instance DIE ref"));
3518
0
    bfd_set_error (bfd_error_bad_value);
3519
0
    return false;
3520
0
  }
3521
27
      info_ptr += die_ref;
3522
27
    }
3523
65.3k
  else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
3524
0
    {
3525
0
      bool first_time = unit->stash->alt.dwarf_info_buffer == NULL;
3526
3527
0
      info_ptr = read_alt_indirect_ref (unit, die_ref);
3528
0
      if (first_time)
3529
0
  unit->stash->alt.info_ptr = unit->stash->alt.dwarf_info_buffer;
3530
0
      if (info_ptr == NULL)
3531
0
  {
3532
0
    _bfd_error_handler
3533
0
      (_("DWARF error: unable to read alt ref %" PRIu64),
3534
0
       (uint64_t) die_ref);
3535
0
    bfd_set_error (bfd_error_bad_value);
3536
0
    return false;
3537
0
  }
3538
0
      info_ptr_end = (unit->stash->alt.dwarf_info_buffer
3539
0
          + unit->stash->alt.dwarf_info_size);
3540
0
      if (unit->stash->alt.all_comp_units)
3541
0
  unit = unit->stash->alt.all_comp_units;
3542
0
    }
3543
3544
65.3k
  if (attr_ptr->form == DW_FORM_ref_addr
3545
65.3k
      || attr_ptr->form == DW_FORM_GNU_ref_alt)
3546
27
    {
3547
      /* Now find the CU containing this pointer.  */
3548
27
      if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
3549
27
  info_ptr_end = unit->end_ptr;
3550
0
      else
3551
0
  {
3552
    /* Check other CUs to see if they contain the abbrev.  */
3553
0
    struct comp_unit *u = NULL;
3554
0
    struct addr_range range = { info_ptr, info_ptr };
3555
0
    splay_tree_node v = splay_tree_lookup (unit->file->comp_unit_tree,
3556
0
             (splay_tree_key)&range);
3557
0
    if (v != NULL)
3558
0
      u = (struct comp_unit *)v->value;
3559
3560
0
    if (attr_ptr->form == DW_FORM_ref_addr)
3561
0
      while (u == NULL)
3562
0
        {
3563
0
    u = stash_comp_unit (unit->stash, &unit->stash->f);
3564
0
    if (u == NULL)
3565
0
      break;
3566
0
    if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
3567
0
      break;
3568
0
    u = NULL;
3569
0
        }
3570
3571
0
    if (attr_ptr->form == DW_FORM_GNU_ref_alt)
3572
0
      while (u == NULL)
3573
0
        {
3574
0
    u = stash_comp_unit (unit->stash, &unit->stash->alt);
3575
0
    if (u == NULL)
3576
0
      break;
3577
0
    if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
3578
0
      break;
3579
0
    u = NULL;
3580
0
        }
3581
3582
0
    if (u == NULL)
3583
0
      {
3584
0
        _bfd_error_handler
3585
0
    (_("DWARF error: unable to locate abstract instance DIE ref %"
3586
0
       PRIu64), (uint64_t) die_ref);
3587
0
        bfd_set_error (bfd_error_bad_value);
3588
0
        return false;
3589
0
      }
3590
0
    unit = u;
3591
0
    info_ptr_end = unit->end_ptr;
3592
0
  }
3593
27
    }
3594
65.3k
  else
3595
65.3k
    {
3596
      /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
3597
   DW_FORM_ref_udata.  These are all references relative to the
3598
   start of the current CU.  */
3599
65.3k
      size_t total;
3600
3601
65.3k
      info_ptr = unit->info_ptr_unit;
3602
65.3k
      info_ptr_end = unit->end_ptr;
3603
65.3k
      total = info_ptr_end - info_ptr;
3604
65.3k
      if (!die_ref || die_ref >= total)
3605
39
  {
3606
39
    _bfd_error_handler
3607
39
      (_("DWARF error: invalid abstract instance DIE ref"));
3608
39
    bfd_set_error (bfd_error_bad_value);
3609
39
    return false;
3610
39
  }
3611
65.3k
      info_ptr += die_ref;
3612
65.3k
    }
3613
3614
65.3k
  abbrev_number = _bfd_safe_read_leb128 (abfd, &info_ptr,
3615
65.3k
           false, info_ptr_end);
3616
65.3k
  if (abbrev_number)
3617
65.2k
    {
3618
65.2k
      abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
3619
65.2k
      if (! abbrev)
3620
22
  {
3621
22
    _bfd_error_handler
3622
22
      (_("DWARF error: could not find abbrev number %u"), abbrev_number);
3623
22
    bfd_set_error (bfd_error_bad_value);
3624
22
    return false;
3625
22
  }
3626
65.1k
      else
3627
65.1k
  {
3628
359k
    for (i = 0; i < abbrev->num_attrs; ++i)
3629
294k
      {
3630
294k
        info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
3631
294k
           info_ptr, info_ptr_end);
3632
294k
        if (info_ptr == NULL)
3633
4
    break;
3634
294k
        switch (attr.name)
3635
294k
    {
3636
65.1k
    case DW_AT_name:
3637
      /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3638
         over DW_AT_name.  */
3639
65.1k
      if (*pname == NULL && is_str_form (&attr))
3640
65.0k
        {
3641
65.0k
          *pname = attr.u.str;
3642
65.0k
          if (mangle_style (unit->lang) == 0)
3643
64.2k
      *is_linkage = true;
3644
65.0k
        }
3645
65.1k
      break;
3646
0
    case DW_AT_specification:
3647
0
      if (is_int_form (&attr)
3648
0
          && !find_abstract_instance (unit, &attr, recur_count + 1,
3649
0
              pname, is_linkage,
3650
0
              filename_ptr, linenumber_ptr))
3651
0
        return false;
3652
0
      break;
3653
0
    case DW_AT_linkage_name:
3654
0
    case DW_AT_MIPS_linkage_name:
3655
      /* PR 16949:  Corrupt debug info can place
3656
         non-string forms into these attributes.  */
3657
0
      if (is_str_form (&attr))
3658
0
        {
3659
0
          *pname = attr.u.str;
3660
0
          *is_linkage = true;
3661
0
        }
3662
0
      break;
3663
33.3k
    case DW_AT_decl_file:
3664
33.3k
      if (!comp_unit_maybe_decode_line_info (unit))
3665
0
        return false;
3666
33.3k
      if (is_int_form (&attr))
3667
33.3k
        {
3668
33.3k
          free (*filename_ptr);
3669
33.3k
          *filename_ptr = concat_filename (unit->line_table,
3670
33.3k
                   attr.u.val);
3671
33.3k
        }
3672
33.3k
      break;
3673
33.3k
    case DW_AT_decl_line:
3674
33.3k
      if (is_int_form (&attr))
3675
33.3k
        *linenumber_ptr = attr.u.val;
3676
33.3k
      break;
3677
162k
    default:
3678
162k
      break;
3679
294k
    }
3680
294k
      }
3681
65.1k
  }
3682
65.2k
    }
3683
65.3k
  return true;
3684
65.3k
}
3685
3686
static bool
3687
read_ranges (struct comp_unit *unit, struct arange *arange,
3688
       struct trie_node **trie_root, uint64_t offset)
3689
32.8k
{
3690
32.8k
  bfd_byte *ranges_ptr;
3691
32.8k
  bfd_byte *ranges_end;
3692
32.8k
  bfd_vma base_address = unit->base_address;
3693
3694
32.8k
  if (! unit->file->dwarf_ranges_buffer)
3695
1.11k
    {
3696
1.11k
      if (! read_debug_ranges (unit))
3697
41
  return false;
3698
1.11k
    }
3699
3700
32.8k
  if (offset > unit->file->dwarf_ranges_size)
3701
22
    return false;
3702
32.8k
  ranges_ptr = unit->file->dwarf_ranges_buffer + offset;
3703
32.8k
  ranges_end = unit->file->dwarf_ranges_buffer + unit->file->dwarf_ranges_size;
3704
3705
32.8k
  for (;;)
3706
2.46M
    {
3707
2.46M
      bfd_vma low_pc;
3708
2.46M
      bfd_vma high_pc;
3709
3710
      /* PR 17512: file: 62cada7d.  */
3711
2.46M
      if (2u * unit->addr_size > (size_t) (ranges_end - ranges_ptr))
3712
103
  return false;
3713
3714
2.45M
      low_pc = read_address (unit, &ranges_ptr, ranges_end);
3715
2.45M
      high_pc = read_address (unit, &ranges_ptr, ranges_end);
3716
3717
2.45M
      if (low_pc == 0 && high_pc == 0)
3718
32.7k
  break;
3719
2.42M
      if (low_pc == (bfd_vma) -1 && high_pc != (bfd_vma) -1)
3720
71
  base_address = high_pc;
3721
2.42M
      else
3722
2.42M
  {
3723
2.42M
    if (!arange_add (unit, arange, trie_root,
3724
2.42M
         base_address + low_pc, base_address + high_pc))
3725
0
      return false;
3726
2.42M
  }
3727
2.42M
    }
3728
32.7k
  return true;
3729
32.8k
}
3730
3731
static bool
3732
read_rnglists (struct comp_unit *unit, struct arange *arange,
3733
         struct trie_node **trie_root, uint64_t offset)
3734
0
{
3735
0
  bfd_byte *rngs_ptr;
3736
0
  bfd_byte *rngs_end;
3737
0
  bfd_vma base_address = unit->base_address;
3738
0
  bfd_vma low_pc;
3739
0
  bfd_vma high_pc;
3740
0
  bfd *abfd = unit->abfd;
3741
3742
0
  if (! unit->file->dwarf_rnglists_buffer)
3743
0
    {
3744
0
      if (! read_debug_rnglists (unit))
3745
0
  return false;
3746
0
    }
3747
3748
0
  rngs_ptr = unit->file->dwarf_rnglists_buffer + offset;
3749
0
  if (rngs_ptr < unit->file->dwarf_rnglists_buffer)
3750
0
    return false;
3751
0
  rngs_end = unit->file->dwarf_rnglists_buffer;
3752
0
  rngs_end +=  unit->file->dwarf_rnglists_size;
3753
3754
0
  for (;;)
3755
0
    {
3756
0
      enum dwarf_range_list_entry rlet;
3757
3758
0
      if (rngs_ptr >= rngs_end)
3759
0
  return false;
3760
3761
0
      rlet = read_1_byte (abfd, &rngs_ptr, rngs_end);
3762
3763
0
      switch (rlet)
3764
0
  {
3765
0
  case DW_RLE_end_of_list:
3766
0
    return true;
3767
3768
0
  case DW_RLE_base_address:
3769
0
    if (unit->addr_size > (size_t) (rngs_end - rngs_ptr))
3770
0
      return false;
3771
0
    base_address = read_address (unit, &rngs_ptr, rngs_end);
3772
0
    continue;
3773
3774
0
  case DW_RLE_start_length:
3775
0
    if (unit->addr_size > (size_t) (rngs_end - rngs_ptr))
3776
0
      return false;
3777
0
    low_pc = read_address (unit, &rngs_ptr, rngs_end);
3778
0
    high_pc = low_pc;
3779
0
    high_pc += _bfd_safe_read_leb128 (abfd, &rngs_ptr,
3780
0
              false, rngs_end);
3781
0
    break;
3782
3783
0
  case DW_RLE_offset_pair:
3784
0
    low_pc = base_address;
3785
0
    low_pc += _bfd_safe_read_leb128 (abfd, &rngs_ptr,
3786
0
             false, rngs_end);
3787
0
    high_pc = base_address;
3788
0
    high_pc += _bfd_safe_read_leb128 (abfd, &rngs_ptr,
3789
0
              false, rngs_end);
3790
0
    break;
3791
3792
0
  case DW_RLE_start_end:
3793
0
    if (2u * unit->addr_size > (size_t) (rngs_end - rngs_ptr))
3794
0
      return false;
3795
0
    low_pc = read_address (unit, &rngs_ptr, rngs_end);
3796
0
    high_pc = read_address (unit, &rngs_ptr, rngs_end);
3797
0
    break;
3798
3799
  /* TODO x-variants need .debug_addr support used for split-dwarf.  */
3800
0
  case DW_RLE_base_addressx:
3801
0
  case DW_RLE_startx_endx:
3802
0
  case DW_RLE_startx_length:
3803
0
  default:
3804
0
    return false;
3805
0
  }
3806
3807
0
      if (!arange_add (unit, arange, trie_root, low_pc, high_pc))
3808
0
  return false;
3809
0
    }
3810
0
}
3811
3812
static bool
3813
read_rangelist (struct comp_unit *unit, struct arange *arange,
3814
    struct trie_node **trie_root, uint64_t offset)
3815
32.8k
{
3816
32.8k
  if (unit->version <= 4)
3817
32.8k
    return read_ranges (unit, arange, trie_root, offset);
3818
0
  else
3819
0
    return read_rnglists (unit, arange, trie_root, offset);
3820
32.8k
}
3821
3822
static struct funcinfo *
3823
lookup_func_by_offset (uint64_t offset, struct funcinfo * table)
3824
9.82k
{
3825
9.82k
  for (; table != NULL; table = table->prev_func)
3826
9.82k
    if (table->unit_offset == offset)
3827
9.82k
      return table;
3828
0
  return NULL;
3829
9.82k
}
3830
3831
static struct varinfo *
3832
lookup_var_by_offset (uint64_t offset, struct varinfo * table)
3833
9.87k
{
3834
9.87k
  while (table)
3835
9.87k
    {
3836
9.87k
      if (table->unit_offset == offset)
3837
9.87k
  return table;
3838
0
      table = table->prev_var;
3839
0
    }
3840
3841
0
  return NULL;
3842
9.87k
}
3843
3844
3845
/* DWARF2 Compilation unit functions.  */
3846
3847
static struct funcinfo *
3848
reverse_funcinfo_list (struct funcinfo *head)
3849
29.5k
{
3850
29.5k
  struct funcinfo *rhead;
3851
29.5k
  struct funcinfo *temp;
3852
3853
449k
  for (rhead = NULL; head; head = temp)
3854
420k
    {
3855
420k
      temp = head->prev_func;
3856
420k
      head->prev_func = rhead;
3857
420k
      rhead = head;
3858
420k
    }
3859
29.5k
  return rhead;
3860
29.5k
}
3861
3862
static struct varinfo *
3863
reverse_varinfo_list (struct varinfo *head)
3864
29.5k
{
3865
29.5k
  struct varinfo *rhead;
3866
29.5k
  struct varinfo *temp;
3867
3868
1.03M
  for (rhead = NULL; head; head = temp)
3869
1.00M
    {
3870
1.00M
      temp = head->prev_var;
3871
1.00M
      head->prev_var = rhead;
3872
1.00M
      rhead = head;
3873
1.00M
    }
3874
29.5k
  return rhead;
3875
29.5k
}
3876
3877
/* Scan over each die in a comp. unit looking for functions to add
3878
   to the function table and variables to the variable table.  */
3879
3880
static bool
3881
scan_unit_for_symbols (struct comp_unit *unit)
3882
11.4k
{
3883
11.4k
  bfd *abfd = unit->abfd;
3884
11.4k
  bfd_byte *info_ptr = unit->first_child_die_ptr;
3885
11.4k
  bfd_byte *info_ptr_end = unit->end_ptr;
3886
11.4k
  int nesting_level = 0;
3887
11.4k
  struct nest_funcinfo
3888
11.4k
  {
3889
11.4k
    struct funcinfo *func;
3890
11.4k
  } *nested_funcs;
3891
11.4k
  int nested_funcs_size;
3892
11.4k
  struct funcinfo *last_func;
3893
11.4k
  struct varinfo *last_var;
3894
  
3895
  /* Maintain a stack of in-scope functions and inlined functions, which we
3896
     can use to set the caller_func field.  */
3897
11.4k
  nested_funcs_size = 32;
3898
11.4k
  nested_funcs = (struct nest_funcinfo *)
3899
11.4k
    bfd_malloc (nested_funcs_size * sizeof (*nested_funcs));
3900
11.4k
  if (nested_funcs == NULL)
3901
0
    return false;
3902
11.4k
  nested_funcs[nesting_level].func = 0;
3903
3904
  /* PR 27484: We must scan the DIEs twice.  The first time we look for
3905
     function and variable tags and accumulate them into their respective
3906
     tables.  The second time through we process the attributes of the
3907
     functions/variables and augment the table entries.  */
3908
1.41M
  while (nesting_level >= 0)
3909
1.39M
    {
3910
1.39M
      unsigned int abbrev_number, i;
3911
1.39M
      struct abbrev_info *abbrev;
3912
1.39M
      struct funcinfo *func;
3913
1.39M
      struct varinfo *var;
3914
1.39M
      uint64_t current_offset;
3915
3916
      /* PR 17512: file: 9f405d9d.  */
3917
1.39M
      if (info_ptr >= info_ptr_end)
3918
62
  goto fail;
3919
3920
1.39M
      current_offset = info_ptr - unit->info_ptr_unit;
3921
1.39M
      abbrev_number = _bfd_safe_read_leb128 (abfd, &info_ptr,
3922
1.39M
               false, info_ptr_end);
3923
1.39M
      if (abbrev_number == 0)
3924
236k
  {
3925
236k
    nesting_level--;
3926
236k
    continue;
3927
236k
  }
3928
3929
1.16M
      abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
3930
1.16M
      if (! abbrev)
3931
277
  {
3932
277
    static unsigned int previous_failed_abbrev = -1U;
3933
3934
    /* Avoid multiple reports of the same missing abbrev.  */
3935
277
    if (abbrev_number != previous_failed_abbrev)
3936
271
      {
3937
271
        _bfd_error_handler
3938
271
    (_("DWARF error: could not find abbrev number %u"),
3939
271
     abbrev_number);
3940
271
        previous_failed_abbrev = abbrev_number;
3941
271
      }
3942
277
    bfd_set_error (bfd_error_bad_value);
3943
277
    goto fail;
3944
277
  }
3945
3946
1.16M
      if (abbrev->tag == DW_TAG_subprogram
3947
1.16M
    || abbrev->tag == DW_TAG_entry_point
3948
1.16M
    || abbrev->tag == DW_TAG_inlined_subroutine)
3949
150k
  {
3950
150k
    size_t amt = sizeof (struct funcinfo);
3951
3952
150k
    var = NULL;
3953
150k
    func = (struct funcinfo *) bfd_zalloc (abfd, amt);
3954
150k
    if (func == NULL)
3955
0
      goto fail;
3956
150k
    func->tag = abbrev->tag;
3957
150k
    func->prev_func = unit->function_table;
3958
150k
    func->unit_offset = current_offset;
3959
150k
    unit->function_table = func;
3960
150k
    unit->number_of_functions++;
3961
150k
    BFD_ASSERT (!unit->cached);
3962
3963
150k
    if (func->tag == DW_TAG_inlined_subroutine)
3964
100k
      for (i = nesting_level; i-- != 0; )
3965
99.9k
        if (nested_funcs[i].func)
3966
73.3k
    {
3967
73.3k
      func->caller_func = nested_funcs[i].func;
3968
73.3k
      break;
3969
73.3k
    }
3970
150k
    nested_funcs[nesting_level].func = func;
3971
150k
  }
3972
1.01M
      else
3973
1.01M
  {
3974
1.01M
    func = NULL;
3975
1.01M
    if (abbrev->tag == DW_TAG_variable
3976
1.01M
        || abbrev->tag == DW_TAG_member)
3977
360k
      {
3978
360k
        size_t amt = sizeof (struct varinfo);
3979
3980
360k
        var = (struct varinfo *) bfd_zalloc (abfd, amt);
3981
360k
        if (var == NULL)
3982
0
    goto fail;
3983
360k
        var->tag = abbrev->tag;
3984
360k
        var->stack = true;
3985
360k
        var->prev_var = unit->variable_table;
3986
360k
        unit->variable_table = var;
3987
360k
        var->unit_offset = current_offset;
3988
        /* PR 18205: Missing debug information can cause this
3989
     var to be attached to an already cached unit.  */
3990
360k
      }
3991
651k
    else
3992
651k
      var = NULL;
3993
3994
    /* No inline function in scope at this nesting level.  */
3995
1.01M
    nested_funcs[nesting_level].func = 0;
3996
1.01M
  }
3997
3998
5.40M
      for (i = 0; i < abbrev->num_attrs; ++i)
3999
4.24M
  {
4000
4.24M
    struct attribute attr;
4001
4002
4.24M
    info_ptr = read_attribute (&attr, &abbrev->attrs[i],
4003
4.24M
             unit, info_ptr, info_ptr_end);
4004
4.24M
    if (info_ptr == NULL)
4005
155
      goto fail;
4006
4.24M
  }
4007
4008
1.16M
      if (abbrev->has_children)
4009
226k
  {
4010
226k
    nesting_level++;
4011
4012
226k
    if (nesting_level >= nested_funcs_size)
4013
12
      {
4014
12
        struct nest_funcinfo *tmp;
4015
4016
12
        nested_funcs_size *= 2;
4017
12
        tmp = (struct nest_funcinfo *)
4018
12
    bfd_realloc (nested_funcs,
4019
12
           nested_funcs_size * sizeof (*nested_funcs));
4020
12
        if (tmp == NULL)
4021
0
    goto fail;
4022
12
        nested_funcs = tmp;
4023
12
      }
4024
226k
    nested_funcs[nesting_level].func = 0;
4025
226k
  }
4026
1.16M
    }
4027
4028
10.9k
  unit->function_table = reverse_funcinfo_list (unit->function_table);
4029
10.9k
  unit->variable_table = reverse_varinfo_list (unit->variable_table);
4030
4031
  /* This is the second pass over the abbrevs.  */      
4032
10.9k
  info_ptr = unit->first_child_die_ptr;
4033
10.9k
  nesting_level = 0;
4034
  
4035
10.9k
  last_func = NULL;
4036
10.9k
  last_var = NULL;
4037
4038
1.29M
  while (nesting_level >= 0)
4039
1.28M
    {
4040
1.28M
      unsigned int abbrev_number, i;
4041
1.28M
      struct abbrev_info *abbrev;
4042
1.28M
      struct attribute attr;
4043
1.28M
      struct funcinfo *func;
4044
1.28M
      struct varinfo *var;
4045
1.28M
      bfd_vma low_pc = 0;
4046
1.28M
      bfd_vma high_pc = 0;
4047
1.28M
      bool high_pc_relative = false;
4048
1.28M
      uint64_t current_offset;
4049
4050
      /* PR 17512: file: 9f405d9d.  */
4051
1.28M
      if (info_ptr >= info_ptr_end)
4052
0
  goto fail;
4053
4054
1.28M
      current_offset = info_ptr - unit->info_ptr_unit;
4055
1.28M
      abbrev_number = _bfd_safe_read_leb128 (abfd, &info_ptr,
4056
1.28M
               false, info_ptr_end);
4057
1.28M
      if (! abbrev_number)
4058
215k
  {
4059
215k
    nesting_level--;
4060
215k
    continue;
4061
215k
  }
4062
4063
1.06M
      abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
4064
      /* This should have been handled above.  */
4065
1.06M
      BFD_ASSERT (abbrev != NULL);
4066
4067
1.06M
      func = NULL;
4068
1.06M
      var = NULL;
4069
1.06M
      if (abbrev->tag == DW_TAG_subprogram
4070
1.06M
    || abbrev->tag == DW_TAG_entry_point
4071
1.06M
    || abbrev->tag == DW_TAG_inlined_subroutine)
4072
135k
  {
4073
135k
    if (last_func
4074
135k
        && last_func->prev_func
4075
135k
        && last_func->prev_func->unit_offset == current_offset)
4076
125k
      func = last_func->prev_func;
4077
9.82k
    else
4078
9.82k
      func = lookup_func_by_offset (current_offset, unit->function_table);
4079
4080
135k
    if (func == NULL)
4081
0
      goto fail;
4082
4083
135k
    last_func = func;
4084
135k
  }
4085
934k
      else if (abbrev->tag == DW_TAG_variable
4086
934k
         || abbrev->tag == DW_TAG_member)
4087
333k
  {
4088
333k
    if (last_var
4089
333k
        && last_var->prev_var
4090
333k
        && last_var->prev_var->unit_offset == current_offset)
4091
323k
      var = last_var->prev_var;
4092
9.87k
    else
4093
9.87k
      var = lookup_var_by_offset (current_offset, unit->variable_table);
4094
4095
333k
    if (var == NULL)
4096
0
      goto fail;
4097
4098
333k
    last_var = var;
4099
333k
  }
4100
4101
4.98M
      for (i = 0; i < abbrev->num_attrs; ++i)
4102
3.91M
  {
4103
3.91M
    info_ptr = read_attribute (&attr, &abbrev->attrs[i],
4104
3.91M
             unit, info_ptr, info_ptr_end);
4105
3.91M
    if (info_ptr == NULL)
4106
0
      goto fail;
4107
4108
3.91M
    if (func)
4109
805k
      {
4110
805k
        switch (attr.name)
4111
805k
    {
4112
46.2k
    case DW_AT_call_file:
4113
46.2k
      if (is_int_form (&attr))
4114
46.2k
        {
4115
46.2k
          free (func->caller_file);
4116
46.2k
          func->caller_file = concat_filename (unit->line_table,
4117
46.2k
                 attr.u.val);
4118
46.2k
        }
4119
46.2k
      break;
4120
4121
46.1k
    case DW_AT_call_line:
4122
46.1k
      if (is_int_form (&attr))
4123
46.1k
        func->caller_line = attr.u.val;
4124
46.1k
      break;
4125
4126
65.3k
    case DW_AT_abstract_origin:
4127
65.3k
    case DW_AT_specification:
4128
65.3k
      if (is_int_form (&attr)
4129
65.3k
          && !find_abstract_instance (unit, &attr, 0,
4130
65.3k
              &func->name,
4131
65.3k
              &func->is_linkage,
4132
65.3k
              &func->file,
4133
65.3k
              &func->line))
4134
58
        goto fail;
4135
65.3k
      break;
4136
4137
68.9k
    case DW_AT_name:
4138
      /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
4139
         over DW_AT_name.  */
4140
68.9k
      if (func->name == NULL && is_str_form (&attr))
4141
68.8k
        {
4142
68.8k
          func->name = attr.u.str;
4143
68.8k
          if (mangle_style (unit->lang) == 0)
4144
67.6k
      func->is_linkage = true;
4145
68.8k
        }
4146
68.9k
      break;
4147
4148
84
    case DW_AT_linkage_name:
4149
87
    case DW_AT_MIPS_linkage_name:
4150
      /* PR 16949:  Corrupt debug info can place
4151
         non-string forms into these attributes.  */
4152
87
      if (is_str_form (&attr))
4153
65
        {
4154
65
          func->name = attr.u.str;
4155
65
          func->is_linkage = true;
4156
65
        }
4157
87
      break;
4158
4159
74.0k
    case DW_AT_low_pc:
4160
74.0k
      if (is_int_form (&attr))
4161
74.0k
        low_pc = attr.u.val;
4162
74.0k
      break;
4163
4164
74.1k
    case DW_AT_high_pc:
4165
74.1k
      if (is_int_form (&attr))
4166
74.1k
        {
4167
74.1k
          high_pc = attr.u.val;
4168
74.1k
          high_pc_relative = attr.form != DW_FORM_addr;
4169
74.1k
        }
4170
74.1k
      break;
4171
4172
31.9k
    case DW_AT_ranges:
4173
31.9k
      if (is_int_form (&attr)
4174
31.9k
          && !read_rangelist (unit, &func->arange,
4175
31.9k
            &unit->file->trie_root, attr.u.val))
4176
96
        goto fail;
4177
31.8k
      break;
4178
4179
57.0k
    case DW_AT_decl_file:
4180
57.0k
      if (is_int_form (&attr))
4181
57.0k
        {
4182
57.0k
          free (func->file);
4183
57.0k
          func->file = concat_filename (unit->line_table,
4184
57.0k
                attr.u.val);
4185
57.0k
        }
4186
57.0k
      break;
4187
4188
57.0k
    case DW_AT_decl_line:
4189
57.0k
      if (is_int_form (&attr))
4190
56.9k
        func->line = attr.u.val;
4191
57.0k
      break;
4192
4193
284k
    default:
4194
284k
      break;
4195
805k
    }
4196
805k
      }
4197
3.10M
    else if (var)
4198
1.48M
      {
4199
1.48M
        switch (attr.name)
4200
1.48M
    {
4201
41
    case DW_AT_specification:
4202
41
      if (is_int_form (&attr) && attr.u.val)
4203
30
        {
4204
30
          bool is_linkage;
4205
30
          if (!find_abstract_instance (unit, &attr, 0,
4206
30
               &var->name,
4207
30
               &is_linkage,
4208
30
               &var->file,
4209
30
               &var->line))
4210
3
      {
4211
3
        _bfd_error_handler (_("DWARF error: could not find "
4212
3
            "variable specification "
4213
3
            "at offset 0x%lx"),
4214
3
                (unsigned long) attr.u.val);
4215
3
        break;
4216
3
      }
4217
30
        }
4218
38
      break;
4219
4220
285k
    case DW_AT_name:
4221
285k
      if (is_str_form (&attr))
4222
285k
        var->name = attr.u.str;
4223
285k
      break;
4224
4225
283k
    case DW_AT_decl_file:
4226
283k
      if (is_int_form (&attr))
4227
283k
        {
4228
283k
          free (var->file);
4229
283k
          var->file = concat_filename (unit->line_table,
4230
283k
               attr.u.val);
4231
283k
        }
4232
283k
      break;
4233
4234
283k
    case DW_AT_decl_line:
4235
283k
      if (is_int_form (&attr))
4236
283k
        var->line = attr.u.val;
4237
283k
      break;
4238
4239
9.32k
    case DW_AT_external:
4240
9.32k
      if (is_int_form (&attr) && attr.u.val != 0)
4241
9.31k
        var->stack = false;
4242
9.32k
      break;
4243
4244
155k
    case DW_AT_location:
4245
155k
      switch (attr.form)
4246
155k
        {
4247
0
        case DW_FORM_block:
4248
117k
        case DW_FORM_block1:
4249
117k
        case DW_FORM_block2:
4250
117k
        case DW_FORM_block4:
4251
118k
        case DW_FORM_exprloc:
4252
118k
          if (attr.u.blk->data != NULL
4253
118k
        && *attr.u.blk->data == DW_OP_addr)
4254
17.5k
      {
4255
17.5k
        var->stack = false;
4256
4257
        /* Verify that DW_OP_addr is the only opcode in the
4258
           location, in which case the block size will be 1
4259
           plus the address size.  */
4260
        /* ??? For TLS variables, gcc can emit
4261
           DW_OP_addr <addr> DW_OP_GNU_push_tls_address
4262
           which we don't handle here yet.  */
4263
17.5k
        if (attr.u.blk->size == unit->addr_size + 1U)
4264
17.5k
          var->addr = bfd_get (unit->addr_size * 8,
4265
17.5k
             unit->abfd,
4266
17.5k
             attr.u.blk->data + 1);
4267
17.5k
      }
4268
118k
          break;
4269
4270
118k
        default:
4271
37.9k
          break;
4272
155k
        }
4273
155k
      break;
4274
4275
464k
    default:
4276
464k
      break;
4277
1.48M
    }
4278
1.48M
      }
4279
3.91M
  }
4280
4281
1.06M
      if (abbrev->has_children)
4282
204k
  nesting_level++;
4283
4284
1.06M
      if (high_pc_relative)
4285
14.7k
  high_pc += low_pc;
4286
4287
1.06M
      if (func && high_pc != 0)
4288
74.0k
  {
4289
74.0k
    if (!arange_add (unit, &func->arange, &unit->file->trie_root,
4290
74.0k
         low_pc, high_pc))
4291
0
      goto fail;
4292
74.0k
  }
4293
1.06M
    }
4294
4295
10.8k
  unit->function_table = reverse_funcinfo_list (unit->function_table);
4296
10.8k
  unit->variable_table = reverse_varinfo_list (unit->variable_table);
4297
4298
10.8k
  free (nested_funcs);
4299
10.8k
  return true;
4300
4301
648
 fail:
4302
648
  free (nested_funcs);
4303
648
  return false;
4304
10.9k
}
4305
4306
/* Read the attributes of the form strx and addrx.  */
4307
4308
static void
4309
reread_attribute (struct comp_unit *unit,
4310
      struct attribute *attr,
4311
      bfd_vma *low_pc,
4312
      bfd_vma *high_pc,
4313
      bool *high_pc_relative,
4314
      bool compunit)
4315
278
{
4316
278
  if (is_strx_form (attr->form))
4317
195
    attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
4318
278
  if (is_addrx_form (attr->form))
4319
83
    attr->u.val = read_indexed_address (attr->u.val, unit);
4320
4321
278
  switch (attr->name)
4322
278
    {
4323
12
    case DW_AT_stmt_list:
4324
12
      unit->stmtlist = 1;
4325
12
      unit->line_offset = attr->u.val;
4326
12
      break;
4327
4328
77
    case DW_AT_name:
4329
77
      if (is_str_form (attr))
4330
56
  unit->name = attr->u.str;
4331
77
      break;
4332
4333
42
    case DW_AT_low_pc:
4334
42
      *low_pc = attr->u.val;
4335
42
      if (compunit)
4336
39
  unit->base_address = *low_pc;
4337
42
      break;
4338
4339
10
    case DW_AT_high_pc:
4340
10
      *high_pc = attr->u.val;
4341
10
      *high_pc_relative = attr->form != DW_FORM_addr;
4342
10
      break;
4343
4344
6
    case DW_AT_ranges:
4345
6
      if (!read_rangelist (unit, &unit->arange,
4346
6
         &unit->file->trie_root, attr->u.val))
4347
1
  return;
4348
5
      break;
4349
4350
14
    case DW_AT_comp_dir:
4351
14
      {
4352
14
  char *comp_dir = attr->u.str;
4353
4354
14
  if (!is_str_form (attr))
4355
8
    {
4356
8
      _bfd_error_handler
4357
8
        (_("DWARF error: DW_AT_comp_dir attribute encountered "
4358
8
     "with a non-string form"));
4359
8
      comp_dir = NULL;
4360
8
    }
4361
4362
14
  if (comp_dir)
4363
0
    {
4364
0
      char *cp = strchr (comp_dir, ':');
4365
4366
0
      if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
4367
0
        comp_dir = cp + 1;
4368
0
    }
4369
14
  unit->comp_dir = comp_dir;
4370
14
  break;
4371
6
      }
4372
4373
4
    case DW_AT_language:
4374
4
      unit->lang = attr->u.val;
4375
117
    default:
4376
117
      break;
4377
278
    }
4378
278
}
4379
4380
/* Parse a DWARF2 compilation unit starting at INFO_PTR.  UNIT_LENGTH
4381
   includes the compilation unit header that proceeds the DIE's, but
4382
   does not include the length field that precedes each compilation
4383
   unit header.  END_PTR points one past the end of this comp unit.
4384
   OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
4385
4386
   This routine does not read the whole compilation unit; only enough
4387
   to get to the line number information for the compilation unit.  */
4388
4389
static struct comp_unit *
4390
parse_comp_unit (struct dwarf2_debug *stash,
4391
     struct dwarf2_debug_file *file,
4392
     bfd_byte *info_ptr,
4393
     bfd_vma unit_length,
4394
     bfd_byte *info_ptr_unit,
4395
     unsigned int offset_size)
4396
15.8k
{
4397
15.8k
  struct comp_unit* unit;
4398
15.8k
  unsigned int version;
4399
15.8k
  uint64_t abbrev_offset = 0;
4400
  /* Initialize it just to avoid a GCC false warning.  */
4401
15.8k
  unsigned int addr_size = -1;
4402
15.8k
  struct abbrev_info** abbrevs;
4403
15.8k
  unsigned int abbrev_number, i;
4404
15.8k
  struct abbrev_info *abbrev;
4405
15.8k
  struct attribute attr;
4406
15.8k
  bfd_byte *end_ptr = info_ptr + unit_length;
4407
15.8k
  size_t amt;
4408
15.8k
  bfd_vma low_pc = 0;
4409
15.8k
  bfd_vma high_pc = 0;
4410
15.8k
  bfd *abfd = file->bfd_ptr;
4411
15.8k
  bool high_pc_relative = false;
4412
15.8k
  enum dwarf_unit_type unit_type;
4413
15.8k
  struct attribute *str_addrp = NULL;
4414
15.8k
  size_t str_count = 0;
4415
15.8k
  size_t str_alloc = 0;
4416
15.8k
  bool compunit_flag = false;
4417
4418
15.8k
  version = read_2_bytes (abfd, &info_ptr, end_ptr);
4419
15.8k
  if (version < 2 || version > 5)
4420
58
    {
4421
      /* PR 19872: A version number of 0 probably means that there is padding
4422
   at the end of the .debug_info section.  Gold puts it there when
4423
   performing an incremental link, for example.  So do not generate
4424
   an error, just return a NULL.  */
4425
58
      if (version)
4426
32
  {
4427
32
    _bfd_error_handler
4428
32
      (_("DWARF error: found dwarf version '%u', this reader"
4429
32
         " only handles version 2, 3, 4 and 5 information"), version);
4430
32
    bfd_set_error (bfd_error_bad_value);
4431
32
  }
4432
58
      return NULL;
4433
58
    }
4434
4435
15.7k
  if (version < 5)
4436
15.3k
    unit_type = DW_UT_compile;
4437
433
  else
4438
433
    {
4439
433
      unit_type = read_1_byte (abfd, &info_ptr, end_ptr);
4440
433
      addr_size = read_1_byte (abfd, &info_ptr, end_ptr);
4441
433
    }
4442
4443
15.7k
  BFD_ASSERT (offset_size == 4 || offset_size == 8);
4444
15.7k
  if (offset_size == 4)
4445
15.7k
    abbrev_offset = read_4_bytes (abfd, &info_ptr, end_ptr);
4446
4
  else
4447
4
    abbrev_offset = read_8_bytes (abfd, &info_ptr, end_ptr);
4448
4449
15.7k
  if (version < 5)
4450
15.3k
    addr_size = read_1_byte (abfd, &info_ptr, end_ptr);
4451
4452
15.7k
  switch (unit_type)
4453
15.7k
    {
4454
239
    case DW_UT_type:
4455
      /* Skip type signature.  */
4456
239
      info_ptr += 8;
4457
4458
      /* Skip type offset.  */
4459
239
      info_ptr += offset_size;
4460
239
      break;
4461
4462
0
    case DW_UT_skeleton:
4463
      /* Skip DWO_id field.  */
4464
0
      info_ptr += 8;
4465
0
      break;
4466
4467
15.5k
    default:
4468
15.5k
      break;
4469
15.7k
    }
4470
4471
15.7k
  if (addr_size > sizeof (bfd_vma))
4472
8
    {
4473
8
      _bfd_error_handler
4474
  /* xgettext: c-format */
4475
8
  (_("DWARF error: found address size '%u', this reader"
4476
8
     " can not handle sizes greater than '%u'"),
4477
8
   addr_size,
4478
8
   (unsigned int) sizeof (bfd_vma));
4479
8
      bfd_set_error (bfd_error_bad_value);
4480
8
      return NULL;
4481
8
    }
4482
4483
15.7k
  if (addr_size != 2 && addr_size != 4 && addr_size != 8)
4484
12
    {
4485
12
      _bfd_error_handler
4486
12
  ("DWARF error: found address size '%u', this reader"
4487
12
   " can only handle address sizes '2', '4' and '8'", addr_size);
4488
12
      bfd_set_error (bfd_error_bad_value);
4489
12
      return NULL;
4490
12
    }
4491
4492
  /* Read the abbrevs for this compilation unit into a table.  */
4493
15.7k
  abbrevs = read_abbrevs (abfd, abbrev_offset, stash, file);
4494
15.7k
  if (! abbrevs)
4495
54
    return NULL;
4496
4497
15.6k
  abbrev_number = _bfd_safe_read_leb128 (abfd, &info_ptr,
4498
15.6k
           false, end_ptr);
4499
15.6k
  if (! abbrev_number)
4500
2
    {
4501
      /* PR 19872: An abbrev number of 0 probably means that there is padding
4502
   at the end of the .debug_abbrev section.  Gold puts it there when
4503
   performing an incremental link, for example.  So do not generate
4504
   an error, just return a NULL.  */
4505
2
      return NULL;
4506
2
    }
4507
4508
15.6k
  abbrev = lookup_abbrev (abbrev_number, abbrevs);
4509
15.6k
  if (! abbrev)
4510
45
    {
4511
45
      _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
4512
45
        abbrev_number);
4513
45
      bfd_set_error (bfd_error_bad_value);
4514
45
      return NULL;
4515
45
    }
4516
4517
15.6k
  amt = sizeof (struct comp_unit);
4518
15.6k
  unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
4519
15.6k
  if (unit == NULL)
4520
0
    return NULL;
4521
15.6k
  unit->abfd = abfd;
4522
15.6k
  unit->version = version;
4523
15.6k
  unit->addr_size = addr_size;
4524
15.6k
  unit->offset_size = offset_size;
4525
15.6k
  unit->abbrevs = abbrevs;
4526
15.6k
  unit->end_ptr = end_ptr;
4527
15.6k
  unit->stash = stash;
4528
15.6k
  unit->file = file;
4529
15.6k
  unit->info_ptr_unit = info_ptr_unit;
4530
4531
15.6k
  if (abbrev->tag == DW_TAG_compile_unit)
4532
15.3k
    compunit_flag = true;
4533
4534
123k
  for (i = 0; i < abbrev->num_attrs; ++i)
4535
108k
    {
4536
108k
      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
4537
108k
      if (info_ptr == NULL)
4538
64
  goto err_exit;
4539
4540
      /* Identify attributes of the form strx* and addrx* which come before
4541
   DW_AT_str_offsets_base and DW_AT_addr_base respectively in the CU.
4542
   Store the attributes in an array and process them later.  */
4543
108k
      if ((unit->dwarf_str_offset == 0 && is_strx_form (attr.form))
4544
108k
    || (unit->dwarf_addr_offset == 0 && is_addrx_form (attr.form)))
4545
307
  {
4546
307
    if (str_count <= str_alloc)
4547
307
      {
4548
307
        str_alloc = 2 * str_alloc + 200;
4549
307
        str_addrp = bfd_realloc (str_addrp,
4550
307
               str_alloc * sizeof (*str_addrp));
4551
307
        if (str_addrp == NULL)
4552
0
    goto err_exit;
4553
307
      }
4554
307
    str_addrp[str_count] = attr;
4555
307
    str_count++;
4556
307
    continue;
4557
307
  }
4558
4559
      /* Store the data if it is of an attribute we want to keep in a
4560
   partial symbol table.  */
4561
107k
      switch (attr.name)
4562
107k
  {
4563
15.5k
  case DW_AT_stmt_list:
4564
15.5k
    if (is_int_form (&attr))
4565
15.5k
      {
4566
15.5k
        unit->stmtlist = 1;
4567
15.5k
        unit->line_offset = attr.u.val;
4568
15.5k
      }
4569
15.5k
    break;
4570
4571
15.2k
  case DW_AT_name:
4572
15.2k
    if (is_str_form (&attr))
4573
15.1k
      unit->name = attr.u.str;
4574
15.2k
    break;
4575
4576
15.2k
  case DW_AT_low_pc:
4577
15.2k
    if (is_int_form (&attr))
4578
15.2k
      {
4579
15.2k
        low_pc = attr.u.val;
4580
        /* If the compilation unit DIE has a DW_AT_low_pc attribute,
4581
     this is the base address to use when reading location
4582
     lists or range lists.  */
4583
15.2k
        if (compunit_flag)
4584
15.2k
    unit->base_address = low_pc;
4585
15.2k
      }
4586
15.2k
    break;
4587
4588
14.4k
  case DW_AT_high_pc:
4589
14.4k
    if (is_int_form (&attr))
4590
14.4k
      {
4591
14.4k
        high_pc = attr.u.val;
4592
14.4k
        high_pc_relative = attr.form != DW_FORM_addr;
4593
14.4k
      }
4594
14.4k
    break;
4595
4596
900
  case DW_AT_ranges:
4597
900
    if (is_int_form (&attr)
4598
900
        && !read_rangelist (unit, &unit->arange,
4599
898
          &unit->file->trie_root, attr.u.val))
4600
69
      goto err_exit;
4601
831
    break;
4602
4603
15.2k
  case DW_AT_comp_dir:
4604
15.2k
    {
4605
15.2k
      char *comp_dir = attr.u.str;
4606
4607
      /* PR 17512: file: 1fe726be.  */
4608
15.2k
      if (!is_str_form (&attr))
4609
9
        {
4610
9
    _bfd_error_handler
4611
9
      (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
4612
9
    comp_dir = NULL;
4613
9
        }
4614
4615
15.2k
      if (comp_dir)
4616
13.2k
        {
4617
    /* Irix 6.2 native cc prepends <machine>.: to the compilation
4618
       directory, get rid of it.  */
4619
13.2k
    char *cp = strchr (comp_dir, ':');
4620
4621
13.2k
    if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
4622
0
      comp_dir = cp + 1;
4623
13.2k
        }
4624
15.2k
      unit->comp_dir = comp_dir;
4625
15.2k
      break;
4626
900
    }
4627
4628
15.5k
  case DW_AT_language:
4629
15.5k
    if (is_int_form (&attr))
4630
15.5k
      unit->lang = attr.u.val;
4631
15.5k
    break;
4632
4633
48
  case DW_AT_addr_base:
4634
48
    unit->dwarf_addr_offset = attr.u.val;
4635
48
    break;
4636
4637
39
  case DW_AT_str_offsets_base:
4638
39
    unit->dwarf_str_offset = attr.u.val;
4639
39
    break;
4640
4641
15.5k
  default:
4642
15.5k
    break;
4643
107k
  }
4644
107k
    }
4645
4646
15.7k
  for (i = 0; i < str_count; ++i)
4647
278
    reread_attribute (unit, &str_addrp[i], &low_pc, &high_pc,
4648
278
          &high_pc_relative, compunit_flag);
4649
4650
15.5k
  if (high_pc_relative)
4651
614
    high_pc += low_pc;
4652
15.5k
  if (high_pc != 0)
4653
14.2k
    {
4654
14.2k
      if (!arange_add (unit, &unit->arange, &unit->file->trie_root,
4655
14.2k
           low_pc, high_pc))
4656
0
  goto err_exit;
4657
14.2k
    }
4658
4659
15.5k
  unit->first_child_die_ptr = info_ptr;
4660
4661
15.5k
  free (str_addrp);
4662
15.5k
  return unit;
4663
4664
133
 err_exit:
4665
133
  unit->error = 1;
4666
133
  free (str_addrp);
4667
133
  return NULL;
4668
15.5k
}
4669
4670
/* Return TRUE if UNIT may contain the address given by ADDR.  When
4671
   there are functions written entirely with inline asm statements, the
4672
   range info in the compilation unit header may not be correct.  We
4673
   need to consult the line info table to see if a compilation unit
4674
   really contains the given address.  */
4675
4676
static bool
4677
comp_unit_may_contain_address (struct comp_unit *unit, bfd_vma addr)
4678
2.84M
{
4679
2.84M
  struct arange *arange;
4680
4681
2.84M
  if (unit->error)
4682
918k
    return false;
4683
4684
1.92M
  if (unit->arange.high == 0 /* No ranges have been computed yet.  */
4685
1.92M
      || unit->line_table == NULL) /* The line info table has not been loaded.  */
4686
173k
    return true;
4687
4688
5.25M
  for (arange = &unit->arange; arange != NULL; arange = arange->next)
4689
3.55M
    if (addr >= arange->low && addr < arange->high)
4690
45.9k
      return true;
4691
4692
1.70M
  return false;
4693
1.74M
}
4694
4695
/* If UNIT contains ADDR, set the output parameters to the values for
4696
   the line containing ADDR and return TRUE.  Otherwise return FALSE.
4697
   The output parameters, FILENAME_PTR, FUNCTION_PTR, and
4698
   LINENUMBER_PTR, are pointers to the objects to be filled in.  */
4699
4700
static bool
4701
comp_unit_find_nearest_line (struct comp_unit *unit,
4702
           bfd_vma addr,
4703
           const char **filename_ptr,
4704
           struct funcinfo **function_ptr,
4705
           unsigned int *linenumber_ptr,
4706
           unsigned int *discriminator_ptr)
4707
77.6k
{
4708
77.6k
  bool line_p, func_p;
4709
4710
77.6k
  if (!comp_unit_maybe_decode_line_info (unit))
4711
35.2k
    return false;
4712
4713
42.3k
  *function_ptr = NULL;
4714
42.3k
  func_p = lookup_address_in_function_table (unit, addr, function_ptr);
4715
4716
42.3k
  if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
4717
9.26k
    unit->stash->inliner_chain = *function_ptr;
4718
4719
42.3k
  line_p = lookup_address_in_line_info_table (unit->line_table, addr,
4720
42.3k
                filename_ptr,
4721
42.3k
                linenumber_ptr,
4722
42.3k
                discriminator_ptr);
4723
42.3k
  return line_p || func_p;
4724
77.6k
}
4725
4726
/* Check to see if line info is already decoded in a comp_unit.
4727
   If not, decode it.  Returns TRUE if no errors were encountered;
4728
   FALSE otherwise.  */
4729
4730
static bool
4731
comp_unit_maybe_decode_line_info (struct comp_unit *unit)
4732
4.38M
{
4733
4.38M
  if (unit->error)
4734
1.34M
    return false;
4735
4736
3.04M
  if (! unit->line_table)
4737
15.5k
    {
4738
15.5k
      if (! unit->stmtlist)
4739
64
  {
4740
64
    unit->error = 1;
4741
64
    return false;
4742
64
  }
4743
4744
15.4k
      unit->line_table = decode_line_info (unit);
4745
4746
15.4k
      if (! unit->line_table)
4747
3.90k
  {
4748
3.90k
    unit->error = 1;
4749
3.90k
    return false;
4750
3.90k
  }
4751
4752
11.5k
      if (unit->first_child_die_ptr < unit->end_ptr
4753
11.5k
    && ! scan_unit_for_symbols (unit))
4754
648
  {
4755
648
    unit->error = 1;
4756
648
    return false;
4757
648
  }
4758
11.5k
    }
4759
4760
3.04M
  return true;
4761
3.04M
}
4762
4763
/* If UNIT contains SYM at ADDR, set the output parameters to the
4764
   values for the line containing SYM.  The output parameters,
4765
   FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
4766
   filled in.
4767
4768
   Return TRUE if UNIT contains SYM, and no errors were encountered;
4769
   FALSE otherwise.  */
4770
4771
static bool
4772
comp_unit_find_line (struct comp_unit *unit,
4773
         asymbol *sym,
4774
         bfd_vma addr,
4775
         const char **filename_ptr,
4776
         unsigned int *linenumber_ptr)
4777
4.26M
{
4778
4.26M
  if (!comp_unit_maybe_decode_line_info (unit))
4779
1.30M
    return false;
4780
4781
2.95M
  if (sym->flags & BSF_FUNCTION)
4782
216k
    return lookup_symbol_in_function_table (unit, sym, addr,
4783
216k
              filename_ptr,
4784
216k
              linenumber_ptr);
4785
4786
2.74M
  return lookup_symbol_in_variable_table (unit, sym, addr,
4787
2.74M
            filename_ptr,
4788
2.74M
            linenumber_ptr);
4789
2.95M
}
4790
4791
/* Extract all interesting funcinfos and varinfos of a compilation
4792
   unit into hash tables for faster lookup.  Returns TRUE if no
4793
   errors were enountered; FALSE otherwise.  */
4794
4795
static bool
4796
comp_unit_hash_info (struct dwarf2_debug *stash,
4797
         struct comp_unit *unit,
4798
         struct info_hash_table *funcinfo_hash_table,
4799
         struct info_hash_table *varinfo_hash_table)
4800
4.18k
{
4801
4.18k
  struct funcinfo* each_func;
4802
4.18k
  struct varinfo* each_var;
4803
4.18k
  bool okay = true;
4804
4805
4.18k
  BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
4806
4807
4.18k
  if (!comp_unit_maybe_decode_line_info (unit))
4808
297
    return false;
4809
4810
3.88k
  BFD_ASSERT (!unit->cached);
4811
4812
  /* To preserve the original search order, we went to visit the function
4813
     infos in the reversed order of the list.  However, making the list
4814
     bi-directional use quite a bit of extra memory.  So we reverse
4815
     the list first, traverse the list in the now reversed order and
4816
     finally reverse the list again to get back the original order.  */
4817
3.88k
  unit->function_table = reverse_funcinfo_list (unit->function_table);
4818
3.88k
  for (each_func = unit->function_table;
4819
78.6k
       each_func && okay;
4820
74.7k
       each_func = each_func->prev_func)
4821
74.7k
    {
4822
      /* Skip nameless functions.  */
4823
74.7k
      if (each_func->name)
4824
  /* There is no need to copy name string into hash table as
4825
     name string is either in the dwarf string buffer or
4826
     info in the stash.  */
4827
68.9k
  okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
4828
68.9k
               (void*) each_func, false);
4829
74.7k
    }
4830
3.88k
  unit->function_table = reverse_funcinfo_list (unit->function_table);
4831
3.88k
  if (!okay)
4832
0
    return false;
4833
4834
  /* We do the same for variable infos.  */
4835
3.88k
  unit->variable_table = reverse_varinfo_list (unit->variable_table);
4836
3.88k
  for (each_var = unit->variable_table;
4837
171k
       each_var && okay;
4838
168k
       each_var = each_var->prev_var)
4839
168k
    {
4840
      /* Skip stack vars and vars with no files or names.  */
4841
168k
      if (! each_var->stack
4842
168k
    && each_var->file != NULL
4843
168k
    && each_var->name != NULL)
4844
  /* There is no need to copy name string into hash table as
4845
     name string is either in the dwarf string buffer or
4846
     info in the stash.  */
4847
13.6k
  okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
4848
13.6k
               (void*) each_var, false);
4849
168k
    }
4850
4851
3.88k
  unit->variable_table = reverse_varinfo_list (unit->variable_table);
4852
3.88k
  unit->cached = true;
4853
3.88k
  return okay;
4854
3.88k
}
4855
4856
/* Locate a section in a BFD containing debugging info.  The search starts
4857
   from the section after AFTER_SEC, or from the first section in the BFD if
4858
   AFTER_SEC is NULL.  The search works by examining the names of the
4859
   sections.  There are three permissiable names.  The first two are given
4860
   by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
4861
   and .zdebug_info).  The third is a prefix .gnu.linkonce.wi.
4862
   This is a variation on the .debug_info section which has a checksum
4863
   describing the contents appended onto the name.  This allows the linker to
4864
   identify and discard duplicate debugging sections for different
4865
   compilation units.  */
4866
564k
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
4867
4868
static asection *
4869
find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
4870
     asection *after_sec)
4871
8.99k
{
4872
8.99k
  asection *msec;
4873
8.99k
  const char *look;
4874
4875
8.99k
  if (after_sec == NULL)
4876
5.95k
    {
4877
5.95k
      look = debug_sections[debug_info].uncompressed_name;
4878
5.95k
      msec = bfd_get_section_by_name (abfd, look);
4879
      /* Testing SEC_HAS_CONTENTS is an anti-fuzzer measure.  Of
4880
   course debug sections always have contents.  */
4881
5.95k
      if (msec != NULL && (msec->flags & SEC_HAS_CONTENTS) != 0)
4882
2.70k
  return msec;
4883
4884
3.24k
      look = debug_sections[debug_info].compressed_name;
4885
3.24k
      msec = bfd_get_section_by_name (abfd, look);
4886
3.24k
      if (msec != NULL && (msec->flags & SEC_HAS_CONTENTS) != 0)
4887
1
        return msec;
4888
4889
402k
      for (msec = abfd->sections; msec != NULL; msec = msec->next)
4890
398k
  if ((msec->flags & SEC_HAS_CONTENTS) != 0
4891
398k
      && startswith (msec->name, GNU_LINKONCE_INFO))
4892
20
    return msec;
4893
4894
3.22k
      return NULL;
4895
3.24k
    }
4896
4897
23.3k
  for (msec = after_sec->next; msec != NULL; msec = msec->next)
4898
20.6k
    {
4899
20.6k
      if ((msec->flags & SEC_HAS_CONTENTS) == 0)
4900
63
  continue;
4901
4902
20.6k
      look = debug_sections[debug_info].uncompressed_name;
4903
20.6k
      if (strcmp (msec->name, look) == 0)
4904
329
  return msec;
4905
4906
20.2k
      look = debug_sections[debug_info].compressed_name;
4907
20.2k
      if (look != NULL && strcmp (msec->name, look) == 0)
4908
3
  return msec;
4909
4910
20.2k
      if (startswith (msec->name, GNU_LINKONCE_INFO))
4911
40
  return msec;
4912
20.2k
    }
4913
4914
2.67k
  return NULL;
4915
3.04k
}
4916
4917
/* Transfer VMAs from object file to separate debug file.  */
4918
4919
static void
4920
set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
4921
0
{
4922
0
  asection *s, *d;
4923
4924
0
  for (s = orig_bfd->sections, d = debug_bfd->sections;
4925
0
       s != NULL && d != NULL;
4926
0
       s = s->next, d = d->next)
4927
0
    {
4928
0
      if ((d->flags & SEC_DEBUGGING) != 0)
4929
0
  break;
4930
      /* ??? Assumes 1-1 correspondence between sections in the
4931
   two files.  */
4932
0
      if (strcmp (s->name, d->name) == 0)
4933
0
  {
4934
0
    d->output_section = s->output_section;
4935
0
    d->output_offset = s->output_offset;
4936
0
    d->vma = s->vma;
4937
0
  }
4938
0
    }
4939
0
}
4940
4941
/* If the dwarf2 info was found in a separate debug file, return the
4942
   debug file section corresponding to the section in the original file
4943
   and the debug file symbols.  */
4944
4945
static void
4946
_bfd_dwarf2_stash_syms (struct dwarf2_debug *stash, bfd *abfd,
4947
      asection **sec, asymbol ***syms)
4948
157k
{
4949
157k
  if (stash->f.bfd_ptr != abfd)
4950
0
    {
4951
0
      asection *s, *d;
4952
4953
0
      if (*sec == NULL)
4954
0
  {
4955
0
    *syms = stash->f.syms;
4956
0
    return;
4957
0
  }
4958
4959
0
      for (s = abfd->sections, d = stash->f.bfd_ptr->sections;
4960
0
     s != NULL && d != NULL;
4961
0
     s = s->next, d = d->next)
4962
0
  {
4963
0
    if ((d->flags & SEC_DEBUGGING) != 0)
4964
0
      break;
4965
0
    if (s == *sec
4966
0
        && strcmp (s->name, d->name) == 0)
4967
0
      {
4968
0
        *sec = d;
4969
0
        *syms = stash->f.syms;
4970
0
        break;
4971
0
      }
4972
0
  }
4973
0
    }
4974
157k
}
4975
4976
/* Unset vmas for adjusted sections in STASH.  */
4977
4978
static void
4979
unset_sections (struct dwarf2_debug *stash)
4980
349k
{
4981
349k
  int i;
4982
349k
  struct adjusted_section *p;
4983
4984
349k
  i = stash->adjusted_section_count;
4985
349k
  p = stash->adjusted_sections;
4986
11.4M
  for (; i > 0; i--, p++)
4987
11.1M
    p->section->vma = p->orig_vma;
4988
349k
}
4989
4990
/* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
4991
   relocatable object file.  VMAs are normally all zero in relocatable
4992
   object files, so if we want to distinguish locations in sections by
4993
   address we need to set VMAs so the sections do not overlap.  We
4994
   also set VMA on .debug_info so that when we have multiple
4995
   .debug_info sections (or the linkonce variant) they also do not
4996
   overlap.  The multiple .debug_info sections make up a single
4997
   logical section.  ??? We should probably do the same for other
4998
   debug sections.  */
4999
5000
static bool
5001
place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
5002
135k
{
5003
135k
  bfd *abfd;
5004
135k
  struct adjusted_section *p;
5005
135k
  int i;
5006
135k
  const char *debug_info_name;
5007
5008
135k
  if (stash->adjusted_section_count != 0)
5009
133k
    {
5010
133k
      i = stash->adjusted_section_count;
5011
133k
      p = stash->adjusted_sections;
5012
11.1M
      for (; i > 0; i--, p++)
5013
11.0M
  p->section->vma = p->adj_vma;
5014
133k
      return true;
5015
133k
    }
5016
5017
2.15k
  debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
5018
2.15k
  i = 0;
5019
2.15k
  abfd = orig_bfd;
5020
2.15k
  while (1)
5021
2.15k
    {
5022
2.15k
      asection *sect;
5023
5024
118k
      for (sect = abfd->sections; sect != NULL; sect = sect->next)
5025
116k
  {
5026
116k
    int is_debug_info;
5027
5028
116k
    if (sect->output_section != NULL
5029
116k
        && sect->output_section != sect
5030
116k
        && (sect->flags & SEC_DEBUGGING) == 0)
5031
0
      continue;
5032
5033
116k
    is_debug_info = (strcmp (sect->name, debug_info_name) == 0
5034
116k
         || startswith (sect->name, GNU_LINKONCE_INFO));
5035
5036
116k
    if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
5037
116k
        && !is_debug_info)
5038
36.8k
      continue;
5039
5040
79.3k
    i++;
5041
79.3k
  }
5042
2.15k
      if (abfd == stash->f.bfd_ptr)
5043
2.15k
  break;
5044
0
      abfd = stash->f.bfd_ptr;
5045
0
    }
5046
5047
2.15k
  if (i <= 1)
5048
0
    stash->adjusted_section_count = -1;
5049
2.15k
  else
5050
2.15k
    {
5051
2.15k
      bfd_vma last_vma = 0, last_dwarf = 0;
5052
2.15k
      size_t amt = i * sizeof (struct adjusted_section);
5053
5054
2.15k
      p = (struct adjusted_section *) bfd_malloc (amt);
5055
2.15k
      if (p == NULL)
5056
0
  return false;
5057
5058
2.15k
      stash->adjusted_sections = p;
5059
2.15k
      stash->adjusted_section_count = i;
5060
5061
2.15k
      abfd = orig_bfd;
5062
2.15k
      while (1)
5063
2.15k
  {
5064
2.15k
    asection *sect;
5065
5066
118k
    for (sect = abfd->sections; sect != NULL; sect = sect->next)
5067
116k
      {
5068
116k
        bfd_size_type sz;
5069
116k
        int is_debug_info;
5070
5071
116k
        if (sect->output_section != NULL
5072
116k
      && sect->output_section != sect
5073
116k
      && (sect->flags & SEC_DEBUGGING) == 0)
5074
0
    continue;
5075
5076
116k
        is_debug_info = (strcmp (sect->name, debug_info_name) == 0
5077
116k
             || startswith (sect->name, GNU_LINKONCE_INFO));
5078
5079
116k
        if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
5080
116k
      && !is_debug_info)
5081
36.8k
    continue;
5082
5083
79.3k
        sz = sect->rawsize ? sect->rawsize : sect->size;
5084
5085
79.3k
        p->section = sect;
5086
79.3k
        p->orig_vma = sect->vma;
5087
5088
79.3k
        bfd_vma *v = is_debug_info ? &last_dwarf : &last_vma;
5089
        /* Align the new address to the current section
5090
     alignment.  */
5091
79.3k
        bfd_vma mask = -(bfd_vma) 1 << sect->alignment_power;
5092
79.3k
        *v = (*v + ~mask) & mask;
5093
79.3k
        sect->vma = *v;
5094
79.3k
        *v += sz;
5095
5096
79.3k
        p->adj_vma = sect->vma;
5097
79.3k
        p++;
5098
79.3k
      }
5099
2.15k
    if (abfd == stash->f.bfd_ptr)
5100
2.15k
      break;
5101
0
    abfd = stash->f.bfd_ptr;
5102
0
  }
5103
2.15k
    }
5104
5105
2.15k
  if (orig_bfd != stash->f.bfd_ptr)
5106
0
    set_debug_vma (orig_bfd, stash->f.bfd_ptr);
5107
5108
2.15k
  return true;
5109
2.15k
}
5110
5111
/* Look up a funcinfo by name using the given info hash table.  If found,
5112
   also update the locations pointed to by filename_ptr and linenumber_ptr.
5113
5114
   This function returns TRUE if a funcinfo that matches the given symbol
5115
   and address is found with any error; otherwise it returns FALSE.  */
5116
5117
static bool
5118
info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
5119
         asymbol *sym,
5120
         bfd_vma addr,
5121
         const char **filename_ptr,
5122
         unsigned int *linenumber_ptr)
5123
6.73k
{
5124
6.73k
  struct funcinfo* each_func;
5125
6.73k
  struct funcinfo* best_fit = NULL;
5126
6.73k
  bfd_vma best_fit_len = (bfd_vma) -1;
5127
6.73k
  struct info_list_node *node;
5128
6.73k
  struct arange *arange;
5129
6.73k
  const char *name = bfd_asymbol_name (sym);
5130
5131
6.73k
  for (node = lookup_info_hash_table (hash_table, name);
5132
9.28k
       node;
5133
6.73k
       node = node->next)
5134
2.55k
    {
5135
2.55k
      each_func = (struct funcinfo *) node->info;
5136
2.55k
      for (arange = &each_func->arange;
5137
8.48k
     arange;
5138
5.93k
     arange = arange->next)
5139
5.93k
  {
5140
5.93k
    if (addr >= arange->low
5141
5.93k
        && addr < arange->high
5142
5.93k
        && arange->high - arange->low < best_fit_len)
5143
2.15k
      {
5144
2.15k
        best_fit = each_func;
5145
2.15k
        best_fit_len = arange->high - arange->low;
5146
2.15k
      }
5147
5.93k
  }
5148
2.55k
    }
5149
5150
6.73k
  if (best_fit)
5151
2.15k
    {
5152
2.15k
      *filename_ptr = best_fit->file;
5153
2.15k
      *linenumber_ptr = best_fit->line;
5154
2.15k
      return true;
5155
2.15k
    }
5156
5157
4.58k
  return false;
5158
6.73k
}
5159
5160
/* Look up a varinfo by name using the given info hash table.  If found,
5161
   also update the locations pointed to by filename_ptr and linenumber_ptr.
5162
5163
   This function returns TRUE if a varinfo that matches the given symbol
5164
   and address is found with any error; otherwise it returns FALSE.  */
5165
5166
static bool
5167
info_hash_lookup_varinfo (struct info_hash_table *hash_table,
5168
        asymbol *sym,
5169
        bfd_vma addr,
5170
        const char **filename_ptr,
5171
        unsigned int *linenumber_ptr)
5172
47.5k
{
5173
47.5k
  struct varinfo* each;
5174
47.5k
  struct info_list_node *node;
5175
47.5k
  const char *name = bfd_asymbol_name (sym);
5176
5177
47.5k
  for (node = lookup_info_hash_table (hash_table, name);
5178
48.5k
       node;
5179
47.5k
       node = node->next)
5180
3.02k
    {
5181
3.02k
      each = (struct varinfo *) node->info;
5182
3.02k
      if (each->addr == addr)
5183
2.01k
  {
5184
2.01k
    *filename_ptr = each->file;
5185
2.01k
    *linenumber_ptr = each->line;
5186
2.01k
    return true;
5187
2.01k
  }
5188
3.02k
    }
5189
5190
45.5k
  return false;
5191
47.5k
}
5192
5193
/* Update the funcinfo and varinfo info hash tables if they are
5194
   not up to date.  Returns TRUE if there is no error; otherwise
5195
   returns FALSE and disable the info hash tables.  */
5196
5197
static bool
5198
stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
5199
54.7k
{
5200
54.7k
  struct comp_unit *each;
5201
5202
  /* Exit if hash tables are up-to-date.  */
5203
54.7k
  if (stash->f.all_comp_units == stash->hash_units_head)
5204
54.3k
    return true;
5205
5206
487
  if (stash->hash_units_head)
5207
0
    each = stash->hash_units_head->prev_unit;
5208
487
  else
5209
487
    each = stash->f.last_comp_unit;
5210
5211
4.37k
  while (each)
5212
4.18k
    {
5213
4.18k
      if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
5214
4.18k
        stash->varinfo_hash_table))
5215
297
  {
5216
297
    stash->info_hash_status = STASH_INFO_HASH_DISABLED;
5217
297
    return false;
5218
297
  }
5219
3.88k
      each = each->prev_unit;
5220
3.88k
    }
5221
5222
190
  stash->hash_units_head = stash->f.all_comp_units;
5223
190
  return true;
5224
487
}
5225
5226
/* Check consistency of info hash tables.  This is for debugging only.  */
5227
5228
static void ATTRIBUTE_UNUSED
5229
stash_verify_info_hash_table (struct dwarf2_debug *stash)
5230
0
{
5231
0
  struct comp_unit *each_unit;
5232
0
  struct funcinfo *each_func;
5233
0
  struct varinfo *each_var;
5234
0
  struct info_list_node *node;
5235
0
  bool found;
5236
0
5237
0
  for (each_unit = stash->f.all_comp_units;
5238
0
       each_unit;
5239
0
       each_unit = each_unit->next_unit)
5240
0
    {
5241
0
      for (each_func = each_unit->function_table;
5242
0
     each_func;
5243
0
     each_func = each_func->prev_func)
5244
0
  {
5245
0
    if (!each_func->name)
5246
0
      continue;
5247
0
    node = lookup_info_hash_table (stash->funcinfo_hash_table,
5248
0
           each_func->name);
5249
0
    BFD_ASSERT (node);
5250
0
    found = false;
5251
0
    while (node && !found)
5252
0
      {
5253
0
        found = node->info == each_func;
5254
0
        node = node->next;
5255
0
      }
5256
0
    BFD_ASSERT (found);
5257
0
  }
5258
0
5259
0
      for (each_var = each_unit->variable_table;
5260
0
     each_var;
5261
0
     each_var = each_var->prev_var)
5262
0
  {
5263
0
    if (!each_var->name || !each_var->file || each_var->stack)
5264
0
      continue;
5265
0
    node = lookup_info_hash_table (stash->varinfo_hash_table,
5266
0
           each_var->name);
5267
0
    BFD_ASSERT (node);
5268
0
    found = false;
5269
0
    while (node && !found)
5270
0
      {
5271
0
        found = node->info == each_var;
5272
0
        node = node->next;
5273
0
      }
5274
0
    BFD_ASSERT (found);
5275
0
  }
5276
0
    }
5277
0
}
5278
5279
/* Check to see if we want to enable the info hash tables, which consume
5280
   quite a bit of memory.  Currently we only check the number times
5281
   bfd_dwarf2_find_line is called.  In the future, we may also want to
5282
   take the number of symbols into account.  */
5283
5284
static void
5285
stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
5286
66.8k
{
5287
66.8k
  BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
5288
5289
66.8k
  if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
5290
66.3k
    return;
5291
5292
  /* FIXME: Maybe we should check the reduce_memory_overheads
5293
     and optimize fields in the bfd_link_info structure ?  */
5294
5295
  /* Create hash tables.  */
5296
525
  stash->funcinfo_hash_table = create_info_hash_table (abfd);
5297
525
  stash->varinfo_hash_table = create_info_hash_table (abfd);
5298
525
  if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
5299
0
    {
5300
      /* Turn off info hashes if any allocation above fails.  */
5301
0
      stash->info_hash_status = STASH_INFO_HASH_DISABLED;
5302
0
      return;
5303
0
    }
5304
  /* We need a forced update so that the info hash tables will
5305
     be created even though there is no compilation unit.  That
5306
     happens if STASH_INFO_HASH_TRIGGER is 0.  */
5307
525
  if (stash_maybe_update_info_hash_tables (stash))
5308
228
    stash->info_hash_status = STASH_INFO_HASH_ON;
5309
525
}
5310
5311
/* Find the file and line associated with a symbol and address using the
5312
   info hash tables of a stash. If there is a match, the function returns
5313
   TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
5314
   otherwise it returns FALSE.  */
5315
5316
static bool
5317
stash_find_line_fast (struct dwarf2_debug *stash,
5318
          asymbol *sym,
5319
          bfd_vma addr,
5320
          const char **filename_ptr,
5321
          unsigned int *linenumber_ptr)
5322
54.2k
{
5323
54.2k
  BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
5324
5325
54.2k
  if (sym->flags & BSF_FUNCTION)
5326
6.73k
    return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
5327
6.73k
              filename_ptr, linenumber_ptr);
5328
47.5k
  return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
5329
47.5k
           filename_ptr, linenumber_ptr);
5330
54.2k
}
5331
5332
/* Save current section VMAs.  */
5333
5334
static bool
5335
save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
5336
5.85k
{
5337
5.85k
  asection *s;
5338
5.85k
  unsigned int i;
5339
5340
5.85k
  if (abfd->section_count == 0)
5341
0
    return true;
5342
5.85k
  stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
5343
5.85k
  if (stash->sec_vma == NULL)
5344
0
    return false;
5345
5.85k
  stash->sec_vma_count = abfd->section_count;
5346
5.85k
  for (i = 0, s = abfd->sections;
5347
536k
       s != NULL && i < abfd->section_count;
5348
530k
       i++, s = s->next)
5349
530k
    {
5350
530k
      if (s->output_section != NULL)
5351
0
  stash->sec_vma[i] = s->output_section->vma + s->output_offset;
5352
530k
      else
5353
530k
  stash->sec_vma[i] = s->vma;
5354
530k
    }
5355
5.85k
  return true;
5356
5.85k
}
5357
5358
/* Compare current section VMAs against those at the time the stash
5359
   was created.  If find_nearest_line is used in linker warnings or
5360
   errors early in the link process, the debug info stash will be
5361
   invalid for later calls.  This is because we relocate debug info
5362
   sections, so the stashed section contents depend on symbol values,
5363
   which in turn depend on section VMAs.  */
5364
5365
static bool
5366
section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
5367
537k
{
5368
537k
  asection *s;
5369
537k
  unsigned int i;
5370
5371
  /* PR 24334: If the number of sections in ABFD has changed between
5372
     when the stash was created and now, then we cannot trust the
5373
     stashed vma information.  */
5374
537k
  if (abfd->section_count != stash->sec_vma_count)
5375
0
    return false;
5376
5377
537k
  for (i = 0, s = abfd->sections;
5378
458M
       s != NULL && i < abfd->section_count;
5379
457M
       i++, s = s->next)
5380
457M
    {
5381
457M
      bfd_vma vma;
5382
5383
457M
      if (s->output_section != NULL)
5384
0
  vma = s->output_section->vma + s->output_offset;
5385
457M
      else
5386
457M
  vma = s->vma;
5387
457M
      if (vma != stash->sec_vma[i])
5388
0
  return false;
5389
457M
    }
5390
537k
  return true;
5391
537k
}
5392
5393
/* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
5394
   If DEBUG_BFD is not specified, we read debug information from ABFD
5395
   or its gnu_debuglink. The results will be stored in PINFO.
5396
   The function returns TRUE iff debug information is ready.  */
5397
5398
bool
5399
_bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
5400
            const struct dwarf_debug_section *debug_sections,
5401
            asymbol **symbols,
5402
            void **pinfo,
5403
            bool do_place)
5404
543k
{
5405
543k
  bfd_size_type total_size;
5406
543k
  asection *msec;
5407
543k
  struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
5408
5409
543k
  if (stash != NULL)
5410
537k
    {
5411
537k
      if (stash->orig_bfd_id == abfd->id
5412
537k
    && section_vma_same (abfd, stash))
5413
537k
  {
5414
    /* Check that we did previously find some debug information
5415
       before attempting to make use of it.  */
5416
537k
    if (stash->f.dwarf_info_size != 0)
5417
346k
      {
5418
346k
        if (do_place && !place_sections (abfd, stash))
5419
0
    return false;
5420
346k
        return true;
5421
346k
      }
5422
5423
191k
    return false;
5424
537k
  }
5425
0
      _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
5426
0
      memset (stash, 0, sizeof (*stash));
5427
0
    }
5428
5.85k
  else
5429
5.85k
    {
5430
5.85k
      stash = (struct dwarf2_debug *) bfd_zalloc (abfd, sizeof (*stash));
5431
5.85k
      if (! stash)
5432
0
  return false;
5433
5.85k
      *pinfo = stash;
5434
5.85k
    }
5435
5.85k
  stash->orig_bfd_id = abfd->id;
5436
5.85k
  stash->debug_sections = debug_sections;
5437
5.85k
  stash->f.syms = symbols;
5438
5.85k
  if (!save_section_vma (abfd, stash))
5439
0
    return false;
5440
5441
5.85k
  stash->f.abbrev_offsets = htab_create_alloc (10, hash_abbrev, eq_abbrev,
5442
5.85k
                 del_abbrev, calloc, free);
5443
5.85k
  if (!stash->f.abbrev_offsets)
5444
0
    return false;
5445
5446
5.85k
  stash->alt.abbrev_offsets = htab_create_alloc (10, hash_abbrev, eq_abbrev,
5447
5.85k
             del_abbrev, calloc, free);
5448
5.85k
  if (!stash->alt.abbrev_offsets)
5449
0
    return false;
5450
5451
5.85k
  stash->f.trie_root = alloc_trie_leaf (abfd);
5452
5.85k
  if (!stash->f.trie_root)
5453
0
    return false;
5454
5455
5.85k
  stash->alt.trie_root = alloc_trie_leaf (abfd);
5456
5.85k
  if (!stash->alt.trie_root)
5457
0
    return false;
5458
5459
5.85k
  if (debug_bfd == NULL)
5460
5.85k
    debug_bfd = abfd;
5461
5462
5.85k
  msec = find_debug_info (debug_bfd, debug_sections, NULL);
5463
5.85k
  if (msec == NULL && abfd == debug_bfd)
5464
3.22k
    {
5465
3.22k
      char * debug_filename;
5466
5467
3.22k
      debug_filename = bfd_follow_build_id_debuglink (abfd, DEBUGDIR);
5468
3.22k
      if (debug_filename == NULL)
5469
3.22k
  debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
5470
5471
3.22k
      if (debug_filename == NULL)
5472
  /* No dwarf2 info, and no gnu_debuglink to follow.
5473
     Note that at this point the stash has been allocated, but
5474
     contains zeros.  This lets future calls to this function
5475
     fail more quickly.  */
5476
3.22k
  return false;
5477
5478
0
      debug_bfd = bfd_openr (debug_filename, NULL);
5479
0
      free (debug_filename);
5480
0
      if (debug_bfd == NULL)
5481
  /* FIXME: Should we report our failure to follow the debuglink ?  */
5482
0
  return false;
5483
5484
      /* Set BFD_DECOMPRESS to decompress debug sections.  */
5485
0
      debug_bfd->flags |= BFD_DECOMPRESS;
5486
0
      if (!bfd_check_format (debug_bfd, bfd_object)
5487
0
    || (msec = find_debug_info (debug_bfd,
5488
0
              debug_sections, NULL)) == NULL
5489
0
    || !bfd_generic_link_read_symbols (debug_bfd))
5490
0
  {
5491
0
    bfd_close (debug_bfd);
5492
0
    return false;
5493
0
  }
5494
5495
0
      symbols = bfd_get_outsymbols (debug_bfd);
5496
0
      stash->f.syms = symbols;
5497
0
      stash->close_on_cleanup = true;
5498
0
    }
5499
2.62k
  stash->f.bfd_ptr = debug_bfd;
5500
5501
2.62k
  if (do_place
5502
2.62k
      && !place_sections (abfd, stash))
5503
0
    return false;
5504
5505
  /* There can be more than one DWARF2 info section in a BFD these
5506
     days.  First handle the easy case when there's only one.  If
5507
     there's more than one, try case two: read them all in and produce
5508
     one large stash.  We do this in two passes - in the first pass we
5509
     just accumulate the section sizes, and in the second pass we
5510
     read in the section's contents.  (The allows us to avoid
5511
     reallocing the data as we add sections to the stash.)  */
5512
5513
2.62k
  if (! find_debug_info (debug_bfd, debug_sections, msec))
5514
2.51k
    {
5515
      /* Case 1: only one info section.  */
5516
2.51k
      total_size = bfd_get_section_limit_octets (debug_bfd, msec);
5517
2.51k
      if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
5518
2.51k
        symbols, 0,
5519
2.51k
        &stash->f.dwarf_info_buffer, &total_size))
5520
437
  goto restore_vma;
5521
2.51k
    }
5522
114
  else
5523
114
    {
5524
      /* Case 2: multiple sections.  */
5525
114
      for (total_size = 0;
5526
368
     msec;
5527
254
     msec = find_debug_info (debug_bfd, debug_sections, msec))
5528
267
  {
5529
267
    if (bfd_section_size_insane (debug_bfd, msec))
5530
13
      goto restore_vma;
5531
254
    bfd_size_type readsz = bfd_get_section_limit_octets (debug_bfd, msec);
5532
    /* Catch PR25070 testcase overflowing size calculation here.  */
5533
254
    if (total_size + readsz < total_size)
5534
0
      {
5535
0
        bfd_set_error (bfd_error_no_memory);
5536
0
        goto restore_vma;
5537
0
      }
5538
254
    total_size += readsz;
5539
254
  }
5540
5541
101
      stash->f.dwarf_info_buffer = (bfd_byte *) bfd_malloc (total_size);
5542
101
      if (stash->f.dwarf_info_buffer == NULL)
5543
0
  goto restore_vma;
5544
5545
101
      total_size = 0;
5546
101
      for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
5547
267
     msec;
5548
166
     msec = find_debug_info (debug_bfd, debug_sections, msec))
5549
206
  {
5550
206
    bfd_size_type readsz = bfd_get_section_limit_octets (debug_bfd, msec);
5551
206
    if (readsz == 0)
5552
21
      continue;
5553
5554
185
    if (!(bfd_simple_get_relocated_section_contents
5555
185
    (debug_bfd, msec, stash->f.dwarf_info_buffer + total_size,
5556
185
     symbols)))
5557
40
      goto restore_vma;
5558
5559
145
    total_size += readsz;
5560
145
  }
5561
101
    }
5562
5563
2.13k
  stash->f.info_ptr = stash->f.dwarf_info_buffer;
5564
2.13k
  stash->f.dwarf_info_size = total_size;
5565
2.13k
  return true;
5566
5567
490
 restore_vma:
5568
490
  unset_sections (stash);
5569
490
  return false;
5570
2.62k
}
5571
5572
/* Parse the next DWARF2 compilation unit at FILE->INFO_PTR.  */
5573
5574
static struct comp_unit *
5575
stash_comp_unit (struct dwarf2_debug *stash, struct dwarf2_debug_file *file)
5576
294k
{
5577
294k
  bfd_size_type length;
5578
294k
  unsigned int offset_size;
5579
294k
  bfd_byte *info_ptr_unit = file->info_ptr;
5580
294k
  bfd_byte *info_ptr_end = file->dwarf_info_buffer + file->dwarf_info_size;
5581
5582
294k
  if (file->info_ptr >= info_ptr_end)
5583
278k
    return NULL;
5584
5585
16.1k
  length = read_4_bytes (file->bfd_ptr, &file->info_ptr, info_ptr_end);
5586
  /* A 0xffffff length is the DWARF3 way of indicating
5587
     we use 64-bit offsets, instead of 32-bit offsets.  */
5588
16.1k
  if (length == 0xffffffff)
5589
10
    {
5590
10
      offset_size = 8;
5591
10
      length = read_8_bytes (file->bfd_ptr, &file->info_ptr, info_ptr_end);
5592
10
    }
5593
  /* A zero length is the IRIX way of indicating 64-bit offsets,
5594
     mostly because the 64-bit length will generally fit in 32
5595
     bits, and the endianness helps.  */
5596
16.1k
  else if (length == 0)
5597
89
    {
5598
89
      offset_size = 8;
5599
89
      length = read_4_bytes (file->bfd_ptr, &file->info_ptr, info_ptr_end);
5600
89
    }
5601
  /* In the absence of the hints above, we assume 32-bit DWARF2
5602
     offsets even for targets with 64-bit addresses, because:
5603
     a) most of the time these targets will not have generated
5604
     more than 2Gb of debug info and so will not need 64-bit
5605
     offsets,
5606
     and
5607
     b) if they do use 64-bit offsets but they are not using
5608
     the size hints that are tested for above then they are
5609
     not conforming to the DWARF3 standard anyway.  */
5610
16.0k
  else
5611
16.0k
    offset_size = 4;
5612
5613
16.1k
  if (length != 0
5614
16.1k
      && length <= (size_t) (info_ptr_end - file->info_ptr))
5615
15.8k
    {
5616
15.8k
      struct comp_unit *each = parse_comp_unit (stash, file,
5617
15.8k
            file->info_ptr, length,
5618
15.8k
            info_ptr_unit, offset_size);
5619
15.8k
      if (each)
5620
15.5k
  {
5621
15.5k
    if (file->comp_unit_tree == NULL)
5622
1.69k
      file->comp_unit_tree
5623
1.69k
        = splay_tree_new (splay_tree_compare_addr_range,
5624
1.69k
        splay_tree_free_addr_range, NULL);
5625
5626
15.5k
    struct addr_range *r
5627
15.5k
      = (struct addr_range *)bfd_malloc (sizeof (struct addr_range));
5628
15.5k
    r->start = each->info_ptr_unit;
5629
15.5k
    r->end = each->end_ptr;
5630
15.5k
    splay_tree_node v = splay_tree_lookup (file->comp_unit_tree,
5631
15.5k
             (splay_tree_key)r);
5632
15.5k
    if (v != NULL || r->end <= r->start)
5633
0
      abort ();
5634
15.5k
    splay_tree_insert (file->comp_unit_tree, (splay_tree_key)r,
5635
15.5k
           (splay_tree_value)each);
5636
5637
15.5k
    if (file->all_comp_units)
5638
13.8k
      file->all_comp_units->prev_unit = each;
5639
1.69k
    else
5640
1.69k
      file->last_comp_unit = each;
5641
5642
15.5k
    each->next_unit = file->all_comp_units;
5643
15.5k
    file->all_comp_units = each;
5644
5645
15.5k
    if (each->arange.high == 0)
5646
1.77k
      {
5647
1.77k
        each->next_unit_without_ranges = file->all_comp_units_without_ranges;
5648
1.77k
        file->all_comp_units_without_ranges = each->next_unit_without_ranges;
5649
1.77k
      }
5650
5651
15.5k
    file->info_ptr += length;
5652
15.5k
    return each;
5653
15.5k
  }
5654
15.8k
    }
5655
5656
  /* Don't trust any of the DWARF info after a corrupted length or
5657
     parse error.  */
5658
625
  file->info_ptr = info_ptr_end;
5659
625
  return NULL;
5660
16.1k
}
5661
5662
/* Hash function for an asymbol.  */
5663
5664
static hashval_t
5665
hash_asymbol (const void *sym)
5666
15.8k
{
5667
15.8k
  const asymbol *asym = sym;
5668
15.8k
  return htab_hash_string (asym->name);
5669
15.8k
}
5670
5671
/* Equality function for asymbols.  */
5672
5673
static int
5674
eq_asymbol (const void *a, const void *b)
5675
7.01k
{
5676
7.01k
  const asymbol *sa = a;
5677
7.01k
  const asymbol *sb = b;
5678
7.01k
  return strcmp (sa->name, sb->name) == 0;
5679
7.01k
}
5680
5681
/* Scan the debug information in PINFO looking for a DW_TAG_subprogram
5682
   abbrev with a DW_AT_low_pc attached to it.  Then lookup that same
5683
   symbol in SYMBOLS and return the difference between the low_pc and
5684
   the symbol's address.  Returns 0 if no suitable symbol could be found.  */
5685
5686
bfd_signed_vma
5687
_bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
5688
795
{
5689
795
  struct dwarf2_debug *stash;
5690
795
  struct comp_unit * unit;
5691
795
  htab_t sym_hash;
5692
795
  bfd_signed_vma result = 0;
5693
795
  asymbol ** psym;
5694
5695
795
  stash = (struct dwarf2_debug *) *pinfo;
5696
5697
795
  if (stash == NULL || symbols == NULL)
5698
0
    return 0;
5699
5700
795
  sym_hash = htab_create_alloc (10, hash_asymbol, eq_asymbol,
5701
795
        NULL, xcalloc, free);
5702
135k
  for (psym = symbols; * psym != NULL; psym++)
5703
134k
    {
5704
134k
      asymbol * sym = * psym;
5705
5706
134k
      if (sym->flags & BSF_FUNCTION && sym->section != NULL)
5707
8.65k
  {
5708
8.65k
    void **slot = htab_find_slot (sym_hash, sym, INSERT);
5709
8.65k
    *slot = sym;
5710
8.65k
  }
5711
134k
    }
5712
5713
2.97k
  for (unit = stash->f.all_comp_units; unit; unit = unit->next_unit)
5714
2.35k
    {
5715
2.35k
      struct funcinfo * func;
5716
5717
2.35k
      comp_unit_maybe_decode_line_info (unit);
5718
5719
3.36k
      for (func = unit->function_table; func != NULL; func = func->prev_func)
5720
1.18k
  if (func->name && func->arange.low)
5721
466
    {
5722
466
      asymbol search, *sym;
5723
5724
      /* FIXME: Do we need to scan the aranges looking for the
5725
         lowest pc value?  */
5726
5727
466
      search.name = func->name;
5728
466
      sym = htab_find (sym_hash, &search);
5729
466
      if (sym != NULL)
5730
170
        {
5731
170
    result = func->arange.low - (sym->value + sym->section->vma);
5732
170
    goto done;
5733
170
        }
5734
466
    }
5735
2.35k
    }
5736
5737
795
 done:
5738
795
  htab_delete (sym_hash);
5739
795
  return result;
5740
795
}
5741
5742
/* See _bfd_dwarf2_find_nearest_line_with_alt.  */
5743
5744
int
5745
_bfd_dwarf2_find_nearest_line (bfd *abfd,
5746
             asymbol **symbols,
5747
             asymbol *symbol,
5748
             asection *section,
5749
             bfd_vma offset,
5750
             const char **filename_ptr,
5751
             const char **functionname_ptr,
5752
             unsigned int *linenumber_ptr,
5753
             unsigned int *discriminator_ptr,
5754
             const struct dwarf_debug_section *debug_sections,
5755
             void **pinfo)
5756
277k
{
5757
277k
  return _bfd_dwarf2_find_nearest_line_with_alt
5758
277k
    (abfd, NULL, symbols, symbol, section, offset, filename_ptr,
5759
277k
     functionname_ptr, linenumber_ptr, discriminator_ptr, debug_sections,
5760
277k
     pinfo);
5761
277k
}
5762
5763
/* Find the source code location of SYMBOL.  If SYMBOL is NULL
5764
   then find the nearest source code location corresponding to
5765
   the address SECTION + OFFSET.
5766
   Returns 1 if the line is found without error and fills in
5767
   FILENAME_PTR and LINENUMBER_PTR.  In the case where SYMBOL was
5768
   NULL the FUNCTIONNAME_PTR is also filled in.
5769
   Returns 2 if partial information from _bfd_elf_find_function is
5770
   returned (function and maybe file) by looking at symbols.  DWARF2
5771
   info is present but not regarding the requested code location.
5772
   Returns 0 otherwise.
5773
   SYMBOLS contains the symbol table for ABFD.
5774
   DEBUG_SECTIONS contains the name of the dwarf debug sections.
5775
   If ALT_FILENAME is given, attempt to open the file and use it
5776
   as the .gnu_debugaltlink file. Otherwise this file will be
5777
   searched for when needed.  */
5778
5779
int
5780
_bfd_dwarf2_find_nearest_line_with_alt
5781
  (bfd *abfd,
5782
   const char *alt_filename,
5783
   asymbol **symbols,
5784
   asymbol *symbol,
5785
   asection *section,
5786
   bfd_vma offset,
5787
   const char **filename_ptr,
5788
   const char **functionname_ptr,
5789
   unsigned int *linenumber_ptr,
5790
   unsigned int *discriminator_ptr,
5791
   const struct dwarf_debug_section *debug_sections,
5792
   void **pinfo)
5793
543k
{
5794
  /* Read each compilation unit from the section .debug_info, and check
5795
     to see if it contains the address we are searching for.  If yes,
5796
     lookup the address, and return the line number info.  If no, go
5797
     on to the next compilation unit.
5798
5799
     We keep a list of all the previously read compilation units, and
5800
     a pointer to the next un-read compilation unit.  Check the
5801
     previously read units before reading more.  */
5802
543k
  struct dwarf2_debug *stash;
5803
  /* What address are we looking for?  */
5804
543k
  bfd_vma addr;
5805
543k
  struct comp_unit* each;
5806
543k
  struct funcinfo *function = NULL;
5807
543k
  int found = false;
5808
543k
  bool do_line;
5809
5810
543k
  *filename_ptr = NULL;
5811
543k
  if (functionname_ptr != NULL)
5812
364k
    *functionname_ptr = NULL;
5813
543k
  *linenumber_ptr = 0;
5814
543k
  if (discriminator_ptr)
5815
14.8k
    *discriminator_ptr = 0;
5816
5817
543k
  if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
5818
543k
              symbols, pinfo,
5819
543k
              (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
5820
195k
    return false;
5821
5822
348k
  stash = (struct dwarf2_debug *) *pinfo;
5823
5824
348k
  if (stash->alt.bfd_ptr == NULL && alt_filename != NULL)
5825
0
    {
5826
0
      bfd *alt_bfd = bfd_openr (alt_filename, NULL);
5827
5828
0
      if (alt_bfd == NULL)
5829
  /* bfd_openr will have set the bfd_error.  */
5830
0
  return false;
5831
0
      if (!bfd_check_format (alt_bfd, bfd_object))
5832
0
  {
5833
0
    bfd_set_error (bfd_error_wrong_format);
5834
0
    bfd_close (alt_bfd);
5835
0
    return false;
5836
0
  }
5837
5838
0
      stash->alt.bfd_ptr = alt_bfd;
5839
0
    }
5840
5841
348k
  do_line = symbol != NULL;
5842
348k
  if (do_line)
5843
162k
    {
5844
162k
      BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
5845
162k
      section = bfd_asymbol_section (symbol);
5846
162k
      addr = symbol->value;
5847
162k
    }
5848
185k
  else
5849
185k
    {
5850
185k
      BFD_ASSERT (section != NULL && functionname_ptr != NULL);
5851
185k
      addr = offset;
5852
5853
      /* If we have no SYMBOL but the section we're looking at is not a
5854
   code section, then take a look through the list of symbols to see
5855
   if we have a symbol at the address we're looking for.  If we do
5856
   then use this to look up line information.  This will allow us to
5857
   give file and line results for data symbols.  We exclude code
5858
   symbols here, if we look up a function symbol and then look up the
5859
   line information we'll actually return the line number for the
5860
   opening '{' rather than the function definition line.  This is
5861
   because looking up by symbol uses the line table, in which the
5862
   first line for a function is usually the opening '{', while
5863
   looking up the function by section + offset uses the
5864
   DW_AT_decl_line from the function DW_TAG_subprogram for the line,
5865
   which will be the line of the function name.  */
5866
185k
      if (symbols != NULL && (section->flags & SEC_CODE) == 0)
5867
85.9k
  {
5868
85.9k
    asymbol **tmp;
5869
5870
42.2M
    for (tmp = symbols; (*tmp) != NULL; ++tmp)
5871
42.2M
      if ((*tmp)->the_bfd == abfd
5872
42.2M
    && (*tmp)->section == section
5873
42.2M
    && (*tmp)->value == offset
5874
42.2M
    && ((*tmp)->flags & BSF_SECTION_SYM) == 0)
5875
110k
        {
5876
110k
    symbol = *tmp;
5877
110k
    do_line = true;
5878
    /* For local symbols, keep going in the hope we find a
5879
       global.  */
5880
110k
    if ((symbol->flags & BSF_GLOBAL) != 0)
5881
9.51k
      break;
5882
110k
        }
5883
85.9k
  }
5884
185k
    }
5885
5886
348k
  if (section->output_section)
5887
0
    addr += section->output_section->vma + section->output_offset;
5888
348k
  else
5889
348k
    addr += section->vma;
5890
5891
  /* A null info_ptr indicates that there is no dwarf2 info
5892
     (or that an error occured while setting up the stash).  */
5893
348k
  if (! stash->f.info_ptr)
5894
0
    return false;
5895
5896
348k
  stash->inliner_chain = NULL;
5897
5898
  /* Check the previously read comp. units first.  */
5899
348k
  if (do_line)
5900
239k
    {
5901
      /* The info hash tables use quite a bit of memory.  We may not want to
5902
   always use them.  We use some heuristics to decide if and when to
5903
   turn it on.  */
5904
239k
      if (stash->info_hash_status == STASH_INFO_HASH_OFF)
5905
66.8k
  stash_maybe_enable_info_hash_tables (abfd, stash);
5906
5907
      /* Keep info hash table up to date if they are available.  Note that we
5908
   may disable the hash tables if there is any error duing update.  */
5909
239k
      if (stash->info_hash_status == STASH_INFO_HASH_ON)
5910
54.2k
  stash_maybe_update_info_hash_tables (stash);
5911
5912
239k
      if (stash->info_hash_status == STASH_INFO_HASH_ON)
5913
54.2k
  {
5914
54.2k
    found = stash_find_line_fast (stash, symbol, addr,
5915
54.2k
          filename_ptr, linenumber_ptr);
5916
54.2k
    if (found)
5917
4.16k
      goto done;
5918
54.2k
  }
5919
5920
      /* Check the previously read comp. units first.  */
5921
7.08M
      for (each = stash->f.all_comp_units; each; each = each->next_unit)
5922
6.87M
  if ((symbol->flags & BSF_FUNCTION) == 0
5923
6.87M
      || comp_unit_may_contain_address (each, addr))
5924
4.25M
    {
5925
4.25M
      found = comp_unit_find_line (each, symbol, addr, filename_ptr,
5926
4.25M
           linenumber_ptr);
5927
4.25M
      if (found)
5928
29.8k
        goto done;
5929
4.25M
    }
5930
235k
    }
5931
109k
  else
5932
109k
    {
5933
109k
      struct trie_node *trie = stash->f.trie_root;
5934
109k
      unsigned int bits = VMA_BITS - 8;
5935
109k
      struct comp_unit **prev_each;
5936
5937
      /* Traverse interior nodes until we get to a leaf.  */
5938
461k
      while (trie && trie->num_room_in_leaf == 0)
5939
352k
  {
5940
352k
    int ch = (addr >> bits) & 0xff;
5941
352k
    trie = ((struct trie_interior *) trie)->children[ch];
5942
352k
    bits -= 8;
5943
352k
  }
5944
5945
109k
      if (trie)
5946
106k
  {
5947
106k
    const struct trie_leaf *leaf = (struct trie_leaf *) trie;
5948
106k
    unsigned int i;
5949
5950
407k
    for (i = 0; i < leaf->num_stored_in_leaf; ++i)
5951
300k
      leaf->ranges[i].unit->mark = false;
5952
5953
308k
    for (i = 0; i < leaf->num_stored_in_leaf; ++i)
5954
237k
      {
5955
237k
        struct comp_unit *unit = leaf->ranges[i].unit;
5956
237k
        if (unit->mark
5957
237k
      || addr < leaf->ranges[i].low_pc
5958
237k
      || addr >= leaf->ranges[i].high_pc)
5959
161k
          continue;
5960
75.7k
        unit->mark = true;
5961
5962
75.7k
        found = comp_unit_find_nearest_line (unit, addr,
5963
75.7k
               filename_ptr,
5964
75.7k
               &function,
5965
75.7k
               linenumber_ptr,
5966
75.7k
               discriminator_ptr);
5967
75.7k
        if (found)
5968
35.1k
    goto done;
5969
75.7k
     }
5970
106k
  }
5971
5972
      /* Also scan through all compilation units without any ranges,
5973
         taking them out of the list if they have acquired any since
5974
   last time.  */
5975
74.2k
      prev_each = &stash->f.all_comp_units_without_ranges;
5976
74.2k
      for (each = *prev_each; each; each = each->next_unit_without_ranges)
5977
0
        {
5978
0
    if (each->arange.high != 0)
5979
0
      {
5980
0
        *prev_each = each->next_unit_without_ranges;
5981
0
        continue;
5982
0
      }
5983
5984
0
    found = comp_unit_find_nearest_line (each, addr,
5985
0
                 filename_ptr,
5986
0
                 &function,
5987
0
                 linenumber_ptr,
5988
0
                 discriminator_ptr);
5989
0
    if (found)
5990
0
      goto done;
5991
0
    prev_each = &each->next_unit_without_ranges;
5992
0
  }
5993
74.2k
    }
5994
5995
  /* Read each remaining comp. units checking each as they are read.  */
5996
294k
  while ((each = stash_comp_unit (stash, &stash->f)) != NULL)
5997
15.5k
    {
5998
      /* DW_AT_low_pc and DW_AT_high_pc are optional for
5999
   compilation units.  If we don't have them (i.e.,
6000
   unit->high == 0), we need to consult the line info table
6001
   to see if a compilation unit contains the given
6002
   address.  */
6003
15.5k
      if (do_line)
6004
13.7k
  found = (((symbol->flags & BSF_FUNCTION) == 0
6005
13.7k
      || comp_unit_may_contain_address (each, addr))
6006
13.7k
     && comp_unit_find_line (each, symbol, addr,
6007
13.7k
           filename_ptr, linenumber_ptr));
6008
1.81k
      else
6009
1.81k
  found = (comp_unit_may_contain_address (each, addr)
6010
1.81k
     && comp_unit_find_nearest_line (each, addr,
6011
1.81k
             filename_ptr,
6012
1.81k
             &function,
6013
1.81k
             linenumber_ptr,
6014
1.81k
             discriminator_ptr));
6015
6016
15.5k
      if (found)
6017
508
  break;
6018
15.5k
    }
6019
6020
348k
 done:
6021
348k
  if (functionname_ptr && function && function->is_linkage)
6022
28.0k
    {
6023
28.0k
      *functionname_ptr = function->name;
6024
28.0k
      if (!found)
6025
0
        found = 2;
6026
28.0k
    }
6027
320k
  else if (functionname_ptr
6028
320k
     && (!*functionname_ptr
6029
157k
         || (function && !function->is_linkage)))
6030
157k
    {
6031
157k
      asymbol *fun;
6032
157k
      asymbol **syms = symbols;
6033
157k
      asection *sec = section;
6034
6035
157k
      _bfd_dwarf2_stash_syms (stash, abfd, &sec, &syms);
6036
157k
      fun = _bfd_elf_find_function (abfd, syms, sec, offset,
6037
157k
            *filename_ptr ? NULL : filename_ptr,
6038
157k
            functionname_ptr);
6039
6040
157k
      if (!found && fun != NULL)
6041
82.8k
  found = 2;
6042
6043
157k
      if (function && !function->is_linkage)
6044
309
  {
6045
309
    bfd_vma sec_vma;
6046
6047
309
    sec_vma = section->vma;
6048
309
    if (section->output_section != NULL)
6049
0
      sec_vma = section->output_section->vma + section->output_offset;
6050
309
    if (fun == NULL)
6051
73
      *functionname_ptr = function->name;
6052
236
    else if (fun->value + sec_vma == function->arange.low)
6053
92
      function->name = *functionname_ptr;
6054
    /* Even if we didn't find a linkage name, say that we have
6055
       to stop a repeated search of symbols.  */
6056
309
    function->is_linkage = true;
6057
309
  }
6058
157k
    }
6059
6060
348k
  unset_sections (stash);
6061
6062
348k
  return found;
6063
279k
}
6064
6065
bool
6066
_bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
6067
             const char **filename_ptr,
6068
             const char **functionname_ptr,
6069
             unsigned int *linenumber_ptr,
6070
             void **pinfo)
6071
0
{
6072
0
  struct dwarf2_debug *stash;
6073
6074
0
  stash = (struct dwarf2_debug *) *pinfo;
6075
0
  if (stash)
6076
0
    {
6077
0
      struct funcinfo *func = stash->inliner_chain;
6078
6079
0
      if (func && func->caller_func)
6080
0
  {
6081
0
    *filename_ptr = func->caller_file;
6082
0
    *functionname_ptr = func->caller_func->name;
6083
0
    *linenumber_ptr = func->caller_line;
6084
0
    stash->inliner_chain = func->caller_func;
6085
0
    return true;
6086
0
  }
6087
0
    }
6088
6089
0
  return false;
6090
0
}
6091
6092
void
6093
_bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
6094
1.57M
{
6095
1.57M
  struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
6096
1.57M
  struct comp_unit *each;
6097
1.57M
  struct dwarf2_debug_file *file;
6098
6099
1.57M
  if (abfd == NULL || stash == NULL)
6100
1.57M
    return;
6101
6102
5.85k
  if (stash->varinfo_hash_table)
6103
525
    bfd_hash_table_free (&stash->varinfo_hash_table->base);
6104
5.85k
  if (stash->funcinfo_hash_table)
6105
525
    bfd_hash_table_free (&stash->funcinfo_hash_table->base);
6106
6107
5.85k
  file = &stash->f;
6108
11.7k
  while (1)
6109
11.7k
    {
6110
27.2k
      for (each = file->all_comp_units; each; each = each->next_unit)
6111
15.5k
  {
6112
15.5k
    struct funcinfo *function_table = each->function_table;
6113
15.5k
    struct varinfo *variable_table = each->variable_table;
6114
6115
15.5k
    if (each->line_table && each->line_table != file->line_table)
6116
10.2k
      {
6117
10.2k
        free (each->line_table->files);
6118
10.2k
        free (each->line_table->dirs);
6119
10.2k
      }
6120
6121
15.5k
    free (each->lookup_funcinfo_table);
6122
15.5k
    each->lookup_funcinfo_table = NULL;
6123
6124
166k
    while (function_table)
6125
150k
      {
6126
150k
        free (function_table->file);
6127
150k
        function_table->file = NULL;
6128
150k
        free (function_table->caller_file);
6129
150k
        function_table->caller_file = NULL;
6130
150k
        function_table = function_table->prev_func;
6131
150k
      }
6132
6133
375k
    while (variable_table)
6134
360k
      {
6135
360k
        free (variable_table->file);
6136
360k
        variable_table->file = NULL;
6137
360k
        variable_table = variable_table->prev_var;
6138
360k
      }
6139
15.5k
  }
6140
6141
11.7k
      if (file->line_table)
6142
1.26k
  {
6143
1.26k
    free (file->line_table->files);
6144
1.26k
    free (file->line_table->dirs);
6145
1.26k
  }
6146
11.7k
      htab_delete (file->abbrev_offsets);
6147
11.7k
      if (file->comp_unit_tree != NULL)
6148
1.69k
  splay_tree_delete (file->comp_unit_tree);
6149
6150
11.7k
      free (file->dwarf_line_str_buffer);
6151
11.7k
      free (file->dwarf_str_buffer);
6152
11.7k
      free (file->dwarf_ranges_buffer);
6153
11.7k
      free (file->dwarf_rnglists_buffer);
6154
11.7k
      free (file->dwarf_line_buffer);
6155
11.7k
      free (file->dwarf_abbrev_buffer);
6156
11.7k
      free (file->dwarf_info_buffer);
6157
11.7k
      free (file->dwarf_addr_buffer);
6158
11.7k
      free (file->dwarf_str_offsets_buffer);
6159
11.7k
      if (file == &stash->alt)
6160
5.85k
  break;
6161
5.85k
      file = &stash->alt;
6162
5.85k
    }
6163
5.85k
  free (stash->sec_vma);
6164
5.85k
  free (stash->adjusted_sections);
6165
5.85k
  if (stash->close_on_cleanup)
6166
0
    bfd_close (stash->f.bfd_ptr);
6167
5.85k
  if (stash->alt.bfd_ptr)
6168
0
    bfd_close (stash->alt.bfd_ptr);
6169
5.85k
}
6170
6171
typedef struct elf_find_function_cache
6172
{
6173
  asection *     last_section;
6174
  asymbol *      func;
6175
  const char *   filename;
6176
  bfd_size_type  code_size;
6177
  bfd_vma        code_off;
6178
6179
} elf_find_function_cache;
6180
6181
6182
/* Returns TRUE if symbol SYM with address CODE_OFF and size CODE_SIZE
6183
   is a better fit to match OFFSET than whatever is currenly stored in
6184
   CACHE.  */
6185
6186
static inline bool
6187
better_fit (elf_find_function_cache *  cache,
6188
      asymbol *                  sym,
6189
      bfd_vma                    code_off,
6190
      bfd_size_type              code_size,
6191
      bfd_vma                    offset)
6192
12.3M
{
6193
  /* If the symbol is beyond the desired offset, ignore it.  */
6194
12.3M
  if (code_off > offset)
6195
6.11M
    return false;
6196
6197
  /* If the symbol is further away from the desired
6198
     offset than our current best, then ignore it.  */
6199
6.24M
  if (code_off < cache->code_off)
6200
4.31M
    return false;
6201
6202
  /* On the other hand, if it is closer, then use it.  */
6203
1.92M
  if (code_off > cache->code_off)
6204
1.58M
    return true;
6205
6206
  /* assert (code_off == cache->code_off);  */
6207
6208
  /* If our current best fit does not actually reach the desired
6209
     offset...  */
6210
342k
  if (cache->code_off + cache->code_size <= offset)
6211
    /* ... then return whichever candidate covers
6212
       more area and hence gets closer to OFFSET.  */
6213
339k
    return code_size > cache->code_size;
6214
6215
  /* The current cache'd symbol covers OFFSET.  */
6216
6217
  /* If the new symbol does not cover the desired offset then skip it.  */  
6218
3.48k
  if (code_off + code_size <= offset)
6219
798
    return false;
6220
6221
  /* Both symbols cover OFFSET.  */
6222
6223
  /* Prefer functions over non-functions.  */
6224
2.68k
  flagword cache_flags = cache->func->flags;
6225
2.68k
  flagword sym_flags   = sym->flags;
6226
6227
2.68k
  if ((cache_flags & BSF_FUNCTION) && ((sym_flags & BSF_FUNCTION) == 0))
6228
47
    return false;
6229
2.63k
  if ((sym_flags & BSF_FUNCTION) && ((cache_flags & BSF_FUNCTION) == 0))
6230
138
    return true;
6231
6232
  /* FIXME: Should we choose LOCAL over GLOBAL ?  */
6233
6234
  /* Prefer typed symbols over notyped.  */
6235
2.50k
  int cache_type = ELF_ST_TYPE (((elf_symbol_type *) cache->func)->internal_elf_sym.st_info);
6236
2.50k
  int sym_type   = ELF_ST_TYPE (((elf_symbol_type *) sym)->internal_elf_sym.st_info);
6237
6238
2.50k
  if (cache_type == STT_NOTYPE && sym_type != STT_NOTYPE)
6239
4
    return true;
6240
2.49k
  if (cache_type != STT_NOTYPE && sym_type == STT_NOTYPE)
6241
4
    return false;
6242
6243
  /* Otherwise choose whichever symbol covers a smaller area.  */
6244
2.49k
  return code_size < cache->code_size;
6245
2.49k
}
6246
6247
/* Find the function to a particular section and offset,
6248
   for error reporting.  */
6249
6250
asymbol *
6251
_bfd_elf_find_function (bfd *abfd,
6252
      asymbol **symbols,
6253
      asection *section,
6254
      bfd_vma offset,
6255
      const char **filename_ptr,
6256
      const char **functionname_ptr)
6257
300k
{
6258
300k
  if (symbols == NULL)
6259
3.19k
    return NULL;
6260
6261
297k
  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
6262
6.39k
    return NULL;
6263
6264
291k
  elf_find_function_cache * cache = elf_tdata (abfd)->elf_find_function_cache;
6265
6266
291k
  if (cache == NULL)
6267
2.56k
    {
6268
2.56k
      cache = bfd_zalloc (abfd, sizeof (*cache));
6269
2.56k
      elf_tdata (abfd)->elf_find_function_cache = cache;
6270
2.56k
      if (cache == NULL)
6271
0
  return NULL;
6272
2.56k
    }
6273
6274
291k
  if (cache->last_section != section
6275
291k
      || cache->func == NULL
6276
291k
      || offset < cache->func->value
6277
291k
      || offset >= cache->func->value + cache->code_size)
6278
276k
    {
6279
276k
      asymbol *file;
6280
276k
      asymbol **p;
6281
      /* ??? Given multiple file symbols, it is impossible to reliably
6282
   choose the right file name for global symbols.  File symbols are
6283
   local symbols, and thus all file symbols must sort before any
6284
   global symbols.  The ELF spec may be interpreted to say that a
6285
   file symbol must sort before other local symbols, but currently
6286
   ld -r doesn't do this.  So, for ld -r output, it is possible to
6287
   make a better choice of file name for local symbols by ignoring
6288
   file symbols appearing after a given local symbol.  */
6289
276k
      enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6290
276k
      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6291
6292
276k
      file = NULL;
6293
276k
      state = nothing_seen;
6294
276k
      cache->filename = NULL;
6295
276k
      cache->func = NULL;
6296
276k
      cache->code_size = 0;
6297
276k
      cache->code_off = 0;
6298
276k
      cache->last_section = section;
6299
6300
123M
      for (p = symbols; *p != NULL; p++)
6301
123M
  {
6302
123M
    asymbol *sym = *p;
6303
123M
    bfd_vma code_off;
6304
123M
    bfd_size_type size;
6305
6306
123M
    if ((sym->flags & BSF_FILE) != 0)
6307
6.47M
      {
6308
6.47M
        file = sym;
6309
6.47M
        if (state == symbol_seen)
6310
92.1k
    state = file_after_symbol_seen;
6311
6.47M
        continue;
6312
6.47M
      }
6313
6314
117M
    if (state == nothing_seen)
6315
276k
      state = symbol_seen;
6316
6317
117M
    size = bed->maybe_function_sym (sym, section, &code_off);
6318
6319
117M
    if (size == 0)
6320
104M
      continue;
6321
6322
12.3M
    if (better_fit (cache, sym, code_off, size, offset))
6323
1.75M
      {
6324
1.75M
        cache->func = sym;
6325
1.75M
        cache->code_size = size;
6326
1.75M
        cache->code_off = code_off;
6327
1.75M
        cache->filename = NULL;
6328
6329
1.75M
        if (file != NULL
6330
1.75M
      && ((sym->flags & BSF_LOCAL) != 0
6331
1.47M
          || state != file_after_symbol_seen))
6332
1.43M
    cache->filename = bfd_asymbol_name (file);
6333
1.75M
      }
6334
    /* Otherwise, if the symbol is beyond the desired offset but it
6335
       lies within the bounds of the current best match then reduce
6336
       the size of the current best match so that future searches
6337
       will not not used the cached symbol by mistake.  */
6338
10.6M
    else if (code_off > offset 
6339
10.6M
       && code_off > cache->code_off
6340
10.6M
       && code_off < cache->code_off + cache->code_size)
6341
2.24k
      {
6342
2.24k
        cache->code_size = code_off - cache->code_off;
6343
2.24k
      }
6344
12.3M
  }
6345
276k
    }
6346
6347
291k
  if (cache->func == NULL)
6348
177k
    return NULL;
6349
6350
113k
  if (filename_ptr)
6351
106k
    *filename_ptr = cache->filename;
6352
113k
  if (functionname_ptr)
6353
113k
    *functionname_ptr = bfd_asymbol_name (cache->func);
6354
6355
113k
  return cache->func;
6356
291k
}