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 163

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

powered by: WebSVN 2.1.0

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