OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [dwarf2.c] - Blame information for rev 90

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.