← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to binutils/bfd/dwarf2.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils/bfd/dwarf2.c
 
1
/* DWARF 2 support.
 
2
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
 
3
   Free Software Foundation, Inc.
 
4
 
 
5
   Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
 
6
   (gavin@cygnus.com).
 
7
 
 
8
   From the dwarf2read.c header:
 
9
   Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
 
10
   Inc.  with support from Florida State University (under contract
 
11
   with the Ada Joint Program Office), and Silicon Graphics, Inc.
 
12
   Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
 
13
   based on Fred Fish's (Cygnus Support) implementation of DWARF 1
 
14
   support in dwarfread.c
 
15
 
 
16
This file is part of BFD.
 
17
 
 
18
This program is free software; you can redistribute it and/or modify
 
19
it under the terms of the GNU General Public License as published by
 
20
the Free Software Foundation; either version 2 of the License, or (at
 
21
your option) any later version.
 
22
 
 
23
This program is distributed in the hope that it will be useful, but
 
24
WITHOUT ANY WARRANTY; without even the implied warranty of
 
25
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
26
General Public License for more details.
 
27
 
 
28
You should have received a copy of the GNU General Public License
 
29
along with this program; if not, write to the Free Software
 
30
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
31
 
 
32
#include "bfd.h"
 
33
#include "sysdep.h"
 
34
#include "libiberty.h"
 
35
#include "libbfd.h"
 
36
#include "elf-bfd.h"
 
37
#include "elf/dwarf2.h"
 
38
 
 
39
/* The data in the .debug_line statement prologue looks like this.  */
 
40
 
 
41
struct line_head
 
42
{
 
43
  bfd_vma total_length;
 
44
  unsigned short version;
 
45
  bfd_vma prologue_length;
 
46
  unsigned char minimum_instruction_length;
 
47
  unsigned char default_is_stmt;
 
48
  int line_base;
 
49
  unsigned char line_range;
 
50
  unsigned char opcode_base;
 
51
  unsigned char *standard_opcode_lengths;
 
52
};
 
53
 
 
54
/* Attributes have a name and a value.  */
 
55
 
 
56
struct attribute
 
57
{
 
58
  enum dwarf_attribute name;
 
59
  enum dwarf_form form;
 
60
  union
 
61
  {
 
62
    char *str;
 
63
    struct dwarf_block *blk;
 
64
    unsigned int unsnd;
 
65
    int snd;
 
66
    bfd_vma addr;
 
67
  }
 
68
  u;
 
69
};
 
70
 
 
71
/* Get at parts of an attribute structure.  */
 
72
 
 
73
#define DW_STRING(attr)    ((attr)->u.str)
 
74
#define DW_UNSND(attr)     ((attr)->u.unsnd)
 
75
#define DW_BLOCK(attr)     ((attr)->u.blk)
 
76
#define DW_SND(attr)       ((attr)->u.snd)
 
77
#define DW_ADDR(attr)      ((attr)->u.addr)
 
78
 
 
79
/* Blocks are a bunch of untyped bytes.  */
 
80
struct dwarf_block
 
81
{
 
82
  unsigned int size;
 
83
  char *data;
 
84
};
 
85
 
 
86
struct dwarf2_debug
 
87
{
 
88
  /* A list of all previously read comp_units.  */
 
89
  struct comp_unit* all_comp_units;
 
90
 
 
91
  /* The next unread compilation unit within the .debug_info section.
 
92
     Zero indicates that the .debug_info section has not been loaded
 
93
     into a buffer yet.  */
 
94
  char* info_ptr;
 
95
 
 
96
  /* Pointer to the end of the .debug_info section memory buffer.  */
 
97
  char* info_ptr_end;
 
98
 
 
99
  /* Pointer to the section and address of the beginning of the
 
100
     section.  */
 
101
  asection* sec;
 
102
  char* sec_info_ptr;
 
103
 
 
104
  /* Pointer to the symbol table.  */
 
105
  asymbol** syms;
 
106
 
 
107
  /* Pointer to the .debug_abbrev section loaded into memory.  */
 
108
  char* dwarf_abbrev_buffer;
 
109
 
 
110
  /* Length of the loaded .debug_abbrev section.  */
 
111
  unsigned long dwarf_abbrev_size;
 
112
 
 
113
  /* Buffer for decode_line_info.  */
 
114
  char *dwarf_line_buffer;
 
115
 
 
116
  /* Length of the loaded .debug_line section.  */
 
117
  unsigned long dwarf_line_size;
 
118
 
 
119
  /* Pointer to the .debug_str section loaded into memory.  */
 
120
  char* dwarf_str_buffer;
 
121
 
 
122
  /* Length of the loaded .debug_str section.  */
 
123
  unsigned long dwarf_str_size;
 
124
};
 
125
 
 
126
struct arange
 
127
{
 
128
  struct arange *next;
 
129
  bfd_vma low;
 
130
  bfd_vma high;
 
131
};
 
132
 
 
133
/* A minimal decoding of DWARF2 compilation units.  We only decode
 
134
   what's needed to get to the line number information.  */
 
135
 
 
136
struct comp_unit
 
137
{
 
138
  /* Chain the previously read compilation units.  */
 
139
  struct comp_unit* next_unit;
 
140
 
 
141
  /* Keep the bdf convenient (for memory allocation).  */
 
142
  bfd* abfd;
 
143
 
 
144
  /* The lowest and higest addresses contained in this compilation
 
145
     unit as specified in the compilation unit header.  */
 
146
  struct arange arange;
 
147
 
 
148
  /* The DW_AT_name attribute (for error messages).  */
 
149
  char* name;
 
150
 
 
151
  /* The abbrev hash table.  */
 
152
  struct abbrev_info** abbrevs;
 
153
 
 
154
  /* Note that an error was found by comp_unit_find_nearest_line.  */
 
155
  int error;
 
156
 
 
157
  /* The DW_AT_comp_dir attribute.  */
 
158
  char* comp_dir;
 
159
 
 
160
  /* True if there is a line number table associated with this comp. unit.  */
 
161
  int stmtlist;
 
162
 
 
163
  /* The offset into .debug_line of the line number table.  */
 
164
  unsigned long line_offset;
 
165
 
 
166
  /* Pointer to the first child die for the comp unit.  */
 
167
  char *first_child_die_ptr;
 
168
 
 
169
  /* The end of the comp unit.  */
 
170
  char *end_ptr;
 
171
 
 
172
  /* The decoded line number, NULL if not yet decoded.  */
 
173
  struct line_info_table* line_table;
 
174
 
 
175
  /* A list of the functions found in this comp. unit.  */
 
176
  struct funcinfo* function_table;
 
177
 
 
178
  /* Pointer to dwarf2_debug structure.  */
 
179
  struct dwarf2_debug *stash;
 
180
 
 
181
  /* Address size for this unit - from unit header.  */
 
182
  unsigned char addr_size;
 
183
 
 
184
  /* Offset size for this unit - from unit header.  */
 
185
  unsigned char offset_size;
 
186
};
 
187
 
 
188
/* This data structure holds the information of an abbrev.  */
 
189
struct abbrev_info
 
190
{
 
191
  unsigned int number;          /* Number identifying abbrev.  */
 
192
  enum dwarf_tag tag;           /* DWARF tag.  */
 
193
  int has_children;             /* Boolean.  */
 
194
  unsigned int num_attrs;       /* Number of attributes.  */
 
195
  struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
 
196
  struct abbrev_info *next;     /* Next in chain.  */
 
197
};
 
198
 
 
199
struct attr_abbrev
 
200
{
 
201
  enum dwarf_attribute name;
 
202
  enum dwarf_form form;
 
203
};
 
204
 
 
205
#ifndef ABBREV_HASH_SIZE
 
206
#define ABBREV_HASH_SIZE 121
 
207
#endif
 
208
#ifndef ATTR_ALLOC_CHUNK
 
209
#define ATTR_ALLOC_CHUNK 4
 
210
#endif
 
211
 
 
212
static unsigned int read_1_byte PARAMS ((bfd *, char *));
 
213
static int read_1_signed_byte PARAMS ((bfd *, char *));
 
214
static unsigned int read_2_bytes PARAMS ((bfd *, char *));
 
215
static unsigned int read_4_bytes PARAMS ((bfd *, char *));
 
216
static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
 
217
static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
 
218
static char *read_string PARAMS ((bfd *, char *, unsigned int *));
 
219
static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
 
220
static unsigned int read_unsigned_leb128
 
221
  PARAMS ((bfd *, char *, unsigned int *));
 
222
static int read_signed_leb128
 
223
  PARAMS ((bfd *, char *, unsigned int *));
 
224
static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
 
225
static struct abbrev_info *lookup_abbrev
 
226
  PARAMS ((unsigned int, struct abbrev_info **));
 
227
static struct abbrev_info **read_abbrevs
 
228
  PARAMS ((bfd *, bfd_vma, struct dwarf2_debug *));
 
229
static char *read_attribute
 
230
  PARAMS ((struct attribute *, struct attr_abbrev *,
 
231
           struct comp_unit *, char *));
 
232
static char *read_attribute_value
 
233
  PARAMS ((struct attribute *, unsigned,
 
234
           struct comp_unit *, char *));
 
235
static void add_line_info
 
236
  PARAMS ((struct line_info_table *, bfd_vma, char *,
 
237
           unsigned int, unsigned int, int));
 
238
static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
 
239
static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
 
240
static struct line_info_table *decode_line_info
 
241
  PARAMS ((struct comp_unit *, struct dwarf2_debug *));
 
242
static boolean lookup_address_in_line_info_table
 
243
  PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
 
244
           const char **, unsigned int *));
 
245
static boolean lookup_address_in_function_table
 
246
  PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
 
247
static boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
 
248
static bfd_vma find_rela_addend
 
249
  PARAMS ((bfd *, asection *, bfd_size_type, asymbol**));
 
250
static struct comp_unit *parse_comp_unit
 
251
  PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
 
252
static boolean comp_unit_contains_address
 
253
  PARAMS ((struct comp_unit *, bfd_vma));
 
254
static boolean comp_unit_find_nearest_line
 
255
  PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
 
256
           unsigned int *, struct dwarf2_debug *));
 
257
static asection *find_debug_info PARAMS ((bfd *, asection *));
 
258
 
 
259
/* VERBATIM
 
260
   The following function up to the END VERBATIM mark are
 
261
   copied directly from dwarf2read.c.  */
 
262
 
 
263
/* Read dwarf information from a buffer.  */
 
264
 
 
265
static unsigned int
 
266
read_1_byte (abfd, buf)
 
267
     bfd *abfd ATTRIBUTE_UNUSED;
 
268
     char *buf;
 
269
{
 
270
  return bfd_get_8 (abfd, (bfd_byte *) buf);
 
271
}
 
272
 
 
273
static int
 
274
read_1_signed_byte (abfd, buf)
 
275
     bfd *abfd ATTRIBUTE_UNUSED;
 
276
     char *buf;
 
277
{
 
278
  return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
 
279
}
 
280
 
 
281
static unsigned int
 
282
read_2_bytes (abfd, buf)
 
283
     bfd *abfd;
 
284
     char *buf;
 
285
{
 
286
  return bfd_get_16 (abfd, (bfd_byte *) buf);
 
287
}
 
288
 
 
289
#if 0  /* This is not used.  */
 
290
 
 
291
static int
 
292
read_2_signed_bytes (abfd, buf)
 
293
     bfd *abfd;
 
294
     char *buf;
 
295
{
 
296
  return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
 
297
}
 
298
 
 
299
#endif
 
300
 
 
301
static unsigned int
 
302
read_4_bytes (abfd, buf)
 
303
     bfd *abfd;
 
304
     char *buf;
 
305
{
 
306
  return bfd_get_32 (abfd, (bfd_byte *) buf);
 
307
}
 
308
 
 
309
#if 0  /* This is not used.  */
 
310
 
 
311
static int
 
312
read_4_signed_bytes (abfd, buf)
 
313
     bfd *abfd;
 
314
     char *buf;
 
315
{
 
316
  return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
 
317
}
 
318
 
 
319
#endif
 
320
 
 
321
static bfd_vma
 
322
read_8_bytes (abfd, buf)
 
323
     bfd *abfd;
 
324
     char *buf;
 
325
{
 
326
  return bfd_get_64 (abfd, (bfd_byte *) buf);
 
327
}
 
328
 
 
329
static char *
 
330
read_n_bytes (abfd, buf, size)
 
331
     bfd *abfd ATTRIBUTE_UNUSED;
 
332
     char *buf;
 
333
     unsigned int size ATTRIBUTE_UNUSED;
 
334
{
 
335
  /* If the size of a host char is 8 bits, we can return a pointer
 
336
     to the buffer, otherwise we have to copy the data to a buffer
 
337
     allocated on the temporary obstack.  */
 
338
  return buf;
 
339
}
 
340
 
 
341
static char *
 
342
read_string (abfd, buf, bytes_read_ptr)
 
343
     bfd *abfd ATTRIBUTE_UNUSED;
 
344
     char *buf;
 
345
     unsigned int *bytes_read_ptr;
 
346
{
 
347
  /* Return a pointer to the embedded string.  */
 
348
  if (*buf == '\0')
 
349
    {
 
350
      *bytes_read_ptr = 1;
 
351
      return NULL;
 
352
    }
 
353
 
 
354
  *bytes_read_ptr = strlen (buf) + 1;
 
355
  return buf;
 
356
}
 
357
 
 
358
static char *
 
359
read_indirect_string (unit, buf, bytes_read_ptr)
 
360
     struct comp_unit* unit;
 
361
     char *buf;
 
362
     unsigned int *bytes_read_ptr;
 
363
{
 
364
  bfd_vma offset;
 
365
  struct dwarf2_debug *stash = unit->stash;
 
366
 
 
367
  if (unit->offset_size == 4)
 
368
    offset = read_4_bytes (unit->abfd, buf);
 
369
  else
 
370
    offset = read_8_bytes (unit->abfd, buf);
 
371
  *bytes_read_ptr = unit->offset_size;
 
372
 
 
373
  if (! stash->dwarf_str_buffer)
 
374
    {
 
375
      asection *msec;
 
376
      bfd *abfd = unit->abfd;
 
377
 
 
378
      msec = bfd_get_section_by_name (abfd, ".debug_str");
 
379
      if (! msec)
 
380
        {
 
381
          (*_bfd_error_handler)
 
382
            (_("Dwarf Error: Can't find .debug_str section."));
 
383
          bfd_set_error (bfd_error_bad_value);
 
384
          return NULL;
 
385
        }
 
386
 
 
387
      stash->dwarf_str_size = msec->_raw_size;
 
388
      stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
 
389
      if (! stash->dwarf_abbrev_buffer)
 
390
        return NULL;
 
391
 
 
392
      if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
 
393
                                      (bfd_vma) 0, msec->_raw_size))
 
394
        return NULL;
 
395
    }
 
396
 
 
397
  if (offset >= stash->dwarf_str_size)
 
398
    {
 
399
      (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
 
400
                             (unsigned long) offset, stash->dwarf_str_size);
 
401
      bfd_set_error (bfd_error_bad_value);
 
402
      return NULL;
 
403
    }
 
404
 
 
405
  buf = stash->dwarf_str_buffer + offset;  
 
406
  if (*buf == '\0')
 
407
    return NULL;
 
408
  return buf;
 
409
}
 
410
 
 
411
static unsigned int
 
412
read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
 
413
     bfd *abfd ATTRIBUTE_UNUSED;
 
414
     char *buf;
 
415
     unsigned int *bytes_read_ptr;
 
416
{
 
417
  unsigned int  result;
 
418
  unsigned int  num_read;
 
419
  int           shift;
 
420
  unsigned char byte;
 
421
 
 
422
  result   = 0;
 
423
  shift    = 0;
 
424
  num_read = 0;
 
425
 
 
426
  do
 
427
    {
 
428
      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 
429
      buf ++;
 
430
      num_read ++;
 
431
      result |= ((byte & 0x7f) << shift);
 
432
      shift += 7;
 
433
    }
 
434
  while (byte & 0x80);
 
435
 
 
436
  * bytes_read_ptr = num_read;
 
437
 
 
438
  return result;
 
439
}
 
440
 
 
441
static int
 
442
read_signed_leb128 (abfd, buf, bytes_read_ptr)
 
443
     bfd *abfd ATTRIBUTE_UNUSED;
 
444
     char *buf;
 
445
     unsigned int * bytes_read_ptr;
 
446
{
 
447
  int           result;
 
448
  int           shift;
 
449
  int           num_read;
 
450
  unsigned char byte;
 
451
 
 
452
  result = 0;
 
453
  shift = 0;
 
454
  num_read = 0;
 
455
 
 
456
  do
 
457
    {
 
458
      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 
459
      buf ++;
 
460
      num_read ++;
 
461
      result |= ((byte & 0x7f) << shift);
 
462
      shift += 7;
 
463
    }
 
464
  while (byte & 0x80);
 
465
 
 
466
  if ((shift < 32) && (byte & 0x40))
 
467
    result |= -(1 << shift);
 
468
 
 
469
  * bytes_read_ptr = num_read;
 
470
 
 
471
  return result;
 
472
}
 
473
 
 
474
/* END VERBATIM */
 
475
 
 
476
static bfd_vma
 
477
read_address (unit, buf)
 
478
     struct comp_unit* unit;
 
479
     char *buf;
 
480
{
 
481
  switch (unit->addr_size)
 
482
    {
 
483
    case 8:
 
484
      return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
 
485
    case 4:
 
486
      return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
 
487
    case 2:
 
488
      return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
 
489
    default:
 
490
      abort ();
 
491
    }
 
492
}
 
493
 
 
494
/* Lookup an abbrev_info structure in the abbrev hash table.  */
 
495
 
 
496
static struct abbrev_info *
 
497
lookup_abbrev (number,abbrevs)
 
498
     unsigned int number;
 
499
     struct abbrev_info **abbrevs;
 
500
{
 
501
  unsigned int hash_number;
 
502
  struct abbrev_info *abbrev;
 
503
 
 
504
  hash_number = number % ABBREV_HASH_SIZE;
 
505
  abbrev = abbrevs[hash_number];
 
506
 
 
507
  while (abbrev)
 
508
    {
 
509
      if (abbrev->number == number)
 
510
        return abbrev;
 
511
      else
 
512
        abbrev = abbrev->next;
 
513
    }
 
514
 
 
515
  return NULL;
 
516
}
 
517
 
 
518
/* In DWARF version 2, the description of the debugging information is
 
519
   stored in a separate .debug_abbrev section.  Before we read any
 
520
   dies from a section we read in all abbreviations and install them
 
521
   in a hash table.  */
 
522
 
 
523
static struct abbrev_info**
 
524
read_abbrevs (abfd, offset, stash)
 
525
     bfd * abfd;
 
526
     bfd_vma offset;
 
527
     struct dwarf2_debug *stash;
 
528
{
 
529
  struct abbrev_info **abbrevs;
 
530
  char *abbrev_ptr;
 
531
  struct abbrev_info *cur_abbrev;
 
532
  unsigned int abbrev_number, bytes_read, abbrev_name;
 
533
  unsigned int abbrev_form, hash_number;
 
534
  bfd_size_type amt;
 
535
 
 
536
  if (! stash->dwarf_abbrev_buffer)
 
537
    {
 
538
      asection *msec;
 
539
 
 
540
      msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
 
541
      if (! msec)
 
542
        {
 
543
          (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
 
544
          bfd_set_error (bfd_error_bad_value);
 
545
          return 0;
 
546
        }
 
547
 
 
548
      stash->dwarf_abbrev_size = msec->_raw_size;
 
549
      stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
 
550
      if (! stash->dwarf_abbrev_buffer)
 
551
          return 0;
 
552
 
 
553
      if (! bfd_get_section_contents (abfd, msec, stash->dwarf_abbrev_buffer,
 
554
                                      (bfd_vma) 0, msec->_raw_size))
 
555
        return 0;
 
556
    }
 
557
 
 
558
  if (offset >= stash->dwarf_abbrev_size)
 
559
    {
 
560
      (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
 
561
                             (unsigned long) offset, stash->dwarf_abbrev_size);
 
562
      bfd_set_error (bfd_error_bad_value);
 
563
      return 0;
 
564
    }
 
565
 
 
566
  amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
 
567
  abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
 
568
 
 
569
  abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
 
570
  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
571
  abbrev_ptr += bytes_read;
 
572
 
 
573
  /* Loop until we reach an abbrev number of 0.  */
 
574
  while (abbrev_number)
 
575
    {
 
576
      amt = sizeof (struct abbrev_info);
 
577
      cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
 
578
 
 
579
      /* Read in abbrev header.  */
 
580
      cur_abbrev->number = abbrev_number;
 
581
      cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
582
      abbrev_ptr += bytes_read;
 
583
      cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
 
584
      abbrev_ptr += 1;
 
585
 
 
586
      /* Now read in declarations.  */
 
587
      abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
588
      abbrev_ptr += bytes_read;
 
589
      abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
590
      abbrev_ptr += bytes_read;
 
591
 
 
592
      while (abbrev_name)
 
593
        {
 
594
          if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
 
595
            {
 
596
              amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
 
597
              amt *= sizeof (struct attr_abbrev);
 
598
              cur_abbrev->attrs = ((struct attr_abbrev *)
 
599
                                   bfd_realloc (cur_abbrev->attrs, amt));
 
600
              if (! cur_abbrev->attrs)
 
601
                return 0;
 
602
            }
 
603
 
 
604
          cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
 
605
          cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
 
606
          abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
607
          abbrev_ptr += bytes_read;
 
608
          abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
609
          abbrev_ptr += bytes_read;
 
610
        }
 
611
 
 
612
      hash_number = abbrev_number % ABBREV_HASH_SIZE;
 
613
      cur_abbrev->next = abbrevs[hash_number];
 
614
      abbrevs[hash_number] = cur_abbrev;
 
615
 
 
616
      /* Get next abbreviation.
 
617
         Under Irix6 the abbreviations for a compilation unit are not
 
618
         always properly terminated with an abbrev number of 0.
 
619
         Exit loop if we encounter an abbreviation which we have
 
620
         already read (which means we are about to read the abbreviations
 
621
         for the next compile unit) or if the end of the abbreviation
 
622
         table is reached.  */
 
623
      if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
 
624
            >= stash->dwarf_abbrev_size)
 
625
        break;
 
626
      abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 
627
      abbrev_ptr += bytes_read;
 
628
      if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
 
629
        break;
 
630
    }
 
631
 
 
632
  return abbrevs;
 
633
}
 
634
 
 
635
/* Read an attribute value described by an attribute form.  */
 
636
 
 
637
static char *
 
638
read_attribute_value (attr, form, unit, info_ptr)
 
639
     struct attribute   *attr;
 
640
     unsigned form;
 
641
     struct comp_unit   *unit;
 
642
     char               *info_ptr;
 
643
{
 
644
  bfd *abfd = unit->abfd;
 
645
  unsigned int bytes_read;
 
646
  struct dwarf_block *blk;
 
647
  bfd_size_type amt;
 
648
 
 
649
  attr->form = form;
 
650
 
 
651
  switch (form)
 
652
    {
 
653
    case DW_FORM_addr:
 
654
      /* FIXME: DWARF3 draft sais DW_FORM_ref_addr is offset_size.  */
 
655
    case DW_FORM_ref_addr:
 
656
      DW_ADDR (attr) = read_address (unit, info_ptr);
 
657
      info_ptr += unit->addr_size;
 
658
      break;
 
659
    case DW_FORM_block2:
 
660
      amt = sizeof (struct dwarf_block);
 
661
      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 
662
      blk->size = read_2_bytes (abfd, info_ptr);
 
663
      info_ptr += 2;
 
664
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 
665
      info_ptr += blk->size;
 
666
      DW_BLOCK (attr) = blk;
 
667
      break;
 
668
    case DW_FORM_block4:
 
669
      amt = sizeof (struct dwarf_block);
 
670
      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 
671
      blk->size = read_4_bytes (abfd, info_ptr);
 
672
      info_ptr += 4;
 
673
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 
674
      info_ptr += blk->size;
 
675
      DW_BLOCK (attr) = blk;
 
676
      break;
 
677
    case DW_FORM_data2:
 
678
      DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 
679
      info_ptr += 2;
 
680
      break;
 
681
    case DW_FORM_data4:
 
682
      DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 
683
      info_ptr += 4;
 
684
      break;
 
685
    case DW_FORM_data8:
 
686
      DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
 
687
      info_ptr += 8;
 
688
      break;
 
689
    case DW_FORM_string:
 
690
      DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
 
691
      info_ptr += bytes_read;
 
692
      break;
 
693
    case DW_FORM_strp:
 
694
      DW_STRING (attr) = read_indirect_string (unit, info_ptr, &bytes_read);
 
695
      info_ptr += bytes_read;
 
696
      break;
 
697
    case DW_FORM_block:
 
698
      amt = sizeof (struct dwarf_block);
 
699
      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 
700
      blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
701
      info_ptr += bytes_read;
 
702
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 
703
      info_ptr += blk->size;
 
704
      DW_BLOCK (attr) = blk;
 
705
      break;
 
706
    case DW_FORM_block1:
 
707
      amt = sizeof (struct dwarf_block);
 
708
      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 
709
      blk->size = read_1_byte (abfd, info_ptr);
 
710
      info_ptr += 1;
 
711
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 
712
      info_ptr += blk->size;
 
713
      DW_BLOCK (attr) = blk;
 
714
      break;
 
715
    case DW_FORM_data1:
 
716
      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 
717
      info_ptr += 1;
 
718
      break;
 
719
    case DW_FORM_flag:
 
720
      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 
721
      info_ptr += 1;
 
722
      break;
 
723
    case DW_FORM_sdata:
 
724
      DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
 
725
      info_ptr += bytes_read;
 
726
      break;
 
727
    case DW_FORM_udata:
 
728
      DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
729
      info_ptr += bytes_read;
 
730
      break;
 
731
    case DW_FORM_ref1:
 
732
      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 
733
      info_ptr += 1;
 
734
      break;
 
735
    case DW_FORM_ref2:
 
736
      DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 
737
      info_ptr += 2;
 
738
      break;
 
739
    case DW_FORM_ref4:
 
740
      DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 
741
      info_ptr += 4;
 
742
      break;
 
743
    case DW_FORM_ref8:
 
744
      DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
 
745
      info_ptr += 8;
 
746
      break;
 
747
    case DW_FORM_ref_udata:
 
748
      DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
749
      info_ptr += bytes_read;
 
750
      break;
 
751
    case DW_FORM_indirect:
 
752
      form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
753
      info_ptr += bytes_read;
 
754
      info_ptr = read_attribute_value (attr, form, unit, info_ptr);
 
755
      break;
 
756
    default:
 
757
      (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
 
758
                             form);
 
759
      bfd_set_error (bfd_error_bad_value);
 
760
    }
 
761
  return info_ptr;
 
762
}
 
763
 
 
764
/* Read an attribute described by an abbreviated attribute.  */
 
765
 
 
766
static char *
 
767
read_attribute (attr, abbrev, unit, info_ptr)
 
768
     struct attribute   *attr;
 
769
     struct attr_abbrev *abbrev;
 
770
     struct comp_unit   *unit;
 
771
     char               *info_ptr;
 
772
{
 
773
  attr->name = abbrev->name;
 
774
  info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
 
775
  return info_ptr;
 
776
}
 
777
 
 
778
/* Source line information table routines.  */
 
779
 
 
780
#define FILE_ALLOC_CHUNK 5
 
781
#define DIR_ALLOC_CHUNK 5
 
782
 
 
783
struct line_info
 
784
{
 
785
  struct line_info* prev_line;
 
786
  bfd_vma address;
 
787
  char* filename;
 
788
  unsigned int line;
 
789
  unsigned int column;
 
790
  int end_sequence;             /* End of (sequential) code sequence.  */
 
791
};
 
792
 
 
793
struct fileinfo
 
794
{
 
795
  char *name;
 
796
  unsigned int dir;
 
797
  unsigned int time;
 
798
  unsigned int size;
 
799
};
 
800
 
 
801
struct line_info_table
 
802
{
 
803
  bfd* abfd;
 
804
  unsigned int num_files;
 
805
  unsigned int num_dirs;
 
806
  char* comp_dir;
 
807
  char** dirs;
 
808
  struct fileinfo* files;
 
809
  struct line_info* last_line;
 
810
};
 
811
 
 
812
struct funcinfo
 
813
{
 
814
  struct funcinfo *prev_func;
 
815
  char* name;
 
816
  bfd_vma low;
 
817
  bfd_vma high;
 
818
};
 
819
 
 
820
static void
 
821
add_line_info (table, address, filename, line, column, end_sequence)
 
822
     struct line_info_table* table;
 
823
     bfd_vma address;
 
824
     char* filename;
 
825
     unsigned int line;
 
826
     unsigned int column;
 
827
     int end_sequence;
 
828
{
 
829
  bfd_size_type amt = sizeof (struct line_info);
 
830
  struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
 
831
 
 
832
  info->prev_line = table->last_line;
 
833
  table->last_line = info;
 
834
 
 
835
  info->address = address;
 
836
  info->filename = filename;
 
837
  info->line = line;
 
838
  info->column = column;
 
839
  info->end_sequence = end_sequence;
 
840
}
 
841
 
 
842
static char *
 
843
concat_filename (table, file)
 
844
     struct line_info_table* table;
 
845
     unsigned int file;
 
846
{
 
847
  char* filename;
 
848
 
 
849
  if (file - 1 >= table->num_files)
 
850
    {
 
851
      (*_bfd_error_handler)
 
852
        (_("Dwarf Error: mangled line number section (bad file number)."));
 
853
      return "<unknown>";
 
854
    }
 
855
 
 
856
  filename = table->files[file - 1].name;
 
857
  if (IS_ABSOLUTE_PATH(filename))
 
858
    return filename;
 
859
  else
 
860
    {
 
861
      char* dirname = (table->files[file - 1].dir
 
862
                       ? table->dirs[table->files[file - 1].dir - 1]
 
863
                       : table->comp_dir);
 
864
 
 
865
      /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.  The
 
866
         best we can do is return the filename part.  */
 
867
      if (dirname == NULL)
 
868
        return filename;
 
869
      else
 
870
        return (char*) concat (dirname, "/", filename, NULL);
 
871
    }
 
872
}
 
873
 
 
874
static void
 
875
arange_add (unit, low_pc, high_pc)
 
876
     struct comp_unit *unit;
 
877
     bfd_vma low_pc;
 
878
     bfd_vma high_pc;
 
879
{
 
880
  struct arange *arange;
 
881
 
 
882
  /* First see if we can cheaply extend an existing range.  */
 
883
  arange = &unit->arange;
 
884
 
 
885
  do
 
886
    {
 
887
      if (low_pc == arange->high)
 
888
        {
 
889
          arange->high = high_pc;
 
890
          return;
 
891
        }
 
892
      if (high_pc == arange->low)
 
893
        {
 
894
          arange->low = low_pc;
 
895
          return;
 
896
        }
 
897
      arange = arange->next;
 
898
    }
 
899
  while (arange);
 
900
 
 
901
  if (unit->arange.high == 0)
 
902
    {
 
903
      /* This is the first address range: store it in unit->arange.  */
 
904
      unit->arange.next = 0;
 
905
      unit->arange.low = low_pc;
 
906
      unit->arange.high = high_pc;
 
907
      return;
 
908
    }
 
909
 
 
910
  /* Need to allocate a new arange and insert it into the arange list.  */
 
911
  arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
 
912
  arange->low = low_pc;
 
913
  arange->high = high_pc;
 
914
 
 
915
  arange->next = unit->arange.next;
 
916
  unit->arange.next = arange;
 
917
}
 
918
 
 
919
/* Decode the line number information for UNIT.  */
 
920
 
 
921
static struct line_info_table*
 
922
decode_line_info (unit, stash)
 
923
     struct comp_unit *unit;
 
924
     struct dwarf2_debug *stash;
 
925
{
 
926
  bfd *abfd = unit->abfd;
 
927
  struct line_info_table* table;
 
928
  char *line_ptr;
 
929
  char *line_end;
 
930
  struct line_head lh;
 
931
  unsigned int i, bytes_read, offset_size;
 
932
  char *cur_file, *cur_dir;
 
933
  unsigned char op_code, extended_op, adj_opcode;
 
934
  bfd_size_type amt;
 
935
 
 
936
  if (! stash->dwarf_line_buffer)
 
937
    {
 
938
      asection *msec;
 
939
 
 
940
      msec = bfd_get_section_by_name (abfd, ".debug_line");
 
941
      if (! msec)
 
942
        {
 
943
          (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
 
944
          bfd_set_error (bfd_error_bad_value);
 
945
          return 0;
 
946
        }
 
947
 
 
948
      stash->dwarf_line_size = msec->_raw_size;
 
949
      stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, msec->_raw_size);
 
950
      if (! stash->dwarf_line_buffer)
 
951
        return 0;
 
952
 
 
953
      if (! bfd_get_section_contents (abfd, msec, stash->dwarf_line_buffer,
 
954
                                      (bfd_vma) 0, msec->_raw_size))
 
955
        return 0;
 
956
 
 
957
      /* FIXME: We ought to apply the relocs against this section before
 
958
         we process it...  */
 
959
    }
 
960
 
 
961
  /* Since we are using un-relocated data, it is possible to get a bad value
 
962
     for the line_offset.  Validate it here so that we won't get a segfault
 
963
     below.  */
 
964
  if (unit->line_offset >= stash->dwarf_line_size)
 
965
    {
 
966
      (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
 
967
                             unit->line_offset, stash->dwarf_line_size);
 
968
      bfd_set_error (bfd_error_bad_value);
 
969
      return 0;
 
970
    }
 
971
 
 
972
  amt = sizeof (struct line_info_table);
 
973
  table = (struct line_info_table*) bfd_alloc (abfd, amt);
 
974
  table->abfd = abfd;
 
975
  table->comp_dir = unit->comp_dir;
 
976
 
 
977
  table->num_files = 0;
 
978
  table->files = NULL;
 
979
 
 
980
  table->num_dirs = 0;
 
981
  table->dirs = NULL;
 
982
 
 
983
  table->files = NULL;
 
984
  table->last_line = NULL;
 
985
 
 
986
  line_ptr = stash->dwarf_line_buffer + unit->line_offset;
 
987
 
 
988
  /* Read in the prologue.  */
 
989
  lh.total_length = read_4_bytes (abfd, line_ptr);
 
990
  line_ptr += 4;
 
991
  offset_size = 4;
 
992
  if (lh.total_length == 0xffffffff)
 
993
    {
 
994
      lh.total_length = read_8_bytes (abfd, line_ptr);
 
995
      line_ptr += 8;
 
996
      offset_size = 8;
 
997
    }
 
998
  else if (lh.total_length == 0 && unit->addr_size == 8)
 
999
    {
 
1000
      /* Handle (non-standard) 64-bit DWARF2 formats.  */
 
1001
      lh.total_length = read_4_bytes (abfd, line_ptr);
 
1002
      line_ptr += 4;
 
1003
      offset_size = 8;
 
1004
    }
 
1005
  line_end = line_ptr + lh.total_length;
 
1006
  lh.version = read_2_bytes (abfd, line_ptr);
 
1007
  line_ptr += 2;
 
1008
  if (offset_size == 4)
 
1009
    lh.prologue_length = read_4_bytes (abfd, line_ptr);
 
1010
  else
 
1011
    lh.prologue_length = read_8_bytes (abfd, line_ptr);
 
1012
  line_ptr += offset_size;
 
1013
  lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
 
1014
  line_ptr += 1;
 
1015
  lh.default_is_stmt = read_1_byte (abfd, line_ptr);
 
1016
  line_ptr += 1;
 
1017
  lh.line_base = read_1_signed_byte (abfd, line_ptr);
 
1018
  line_ptr += 1;
 
1019
  lh.line_range = read_1_byte (abfd, line_ptr);
 
1020
  line_ptr += 1;
 
1021
  lh.opcode_base = read_1_byte (abfd, line_ptr);
 
1022
  line_ptr += 1;
 
1023
  amt = lh.opcode_base * sizeof (unsigned char);
 
1024
  lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
 
1025
 
 
1026
  lh.standard_opcode_lengths[0] = 1;
 
1027
 
 
1028
  for (i = 1; i < lh.opcode_base; ++i)
 
1029
    {
 
1030
      lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
 
1031
      line_ptr += 1;
 
1032
    }
 
1033
 
 
1034
  /* Read directory table.  */
 
1035
  while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
 
1036
    {
 
1037
      line_ptr += bytes_read;
 
1038
 
 
1039
      if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
 
1040
        {
 
1041
          amt = table->num_dirs + DIR_ALLOC_CHUNK;
 
1042
          amt *= sizeof (char *);
 
1043
          table->dirs = (char **) bfd_realloc (table->dirs, amt);
 
1044
          if (! table->dirs)
 
1045
            return 0;
 
1046
        }
 
1047
 
 
1048
      table->dirs[table->num_dirs++] = cur_dir;
 
1049
    }
 
1050
 
 
1051
  line_ptr += bytes_read;
 
1052
 
 
1053
  /* Read file name table.  */
 
1054
  while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
 
1055
    {
 
1056
      line_ptr += bytes_read;
 
1057
 
 
1058
      if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
 
1059
        {
 
1060
          amt = table->num_files + FILE_ALLOC_CHUNK;
 
1061
          amt *= sizeof (struct fileinfo);
 
1062
          table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
 
1063
          if (! table->files)
 
1064
            return 0;
 
1065
        }
 
1066
 
 
1067
      table->files[table->num_files].name = cur_file;
 
1068
      table->files[table->num_files].dir =
 
1069
        read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1070
      line_ptr += bytes_read;
 
1071
      table->files[table->num_files].time =
 
1072
        read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1073
      line_ptr += bytes_read;
 
1074
      table->files[table->num_files].size =
 
1075
        read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1076
      line_ptr += bytes_read;
 
1077
      table->num_files++;
 
1078
    }
 
1079
 
 
1080
  line_ptr += bytes_read;
 
1081
 
 
1082
  /* Read the statement sequences until there's nothing left.  */
 
1083
  while (line_ptr < line_end)
 
1084
    {
 
1085
      /* State machine registers.  */
 
1086
      bfd_vma address = 0;
 
1087
      char* filename = concat_filename (table, 1);
 
1088
      unsigned int line = 1;
 
1089
      unsigned int column = 0;
 
1090
      int is_stmt = lh.default_is_stmt;
 
1091
      int basic_block = 0;
 
1092
      int end_sequence = 0, need_low_pc = 1;
 
1093
      bfd_vma low_pc = 0;
 
1094
 
 
1095
      /* Decode the table.  */
 
1096
      while (! end_sequence)
 
1097
        {
 
1098
          op_code = read_1_byte (abfd, line_ptr);
 
1099
          line_ptr += 1;
 
1100
 
 
1101
          if (op_code >= lh.opcode_base)
 
1102
            {           /* Special operand.  */
 
1103
              adj_opcode = op_code - lh.opcode_base;
 
1104
              address += (adj_opcode / lh.line_range)
 
1105
                * lh.minimum_instruction_length;
 
1106
              line += lh.line_base + (adj_opcode % lh.line_range);
 
1107
              /* Append row to matrix using current values.  */
 
1108
              add_line_info (table, address, filename, line, column, 0);
 
1109
              basic_block = 1;
 
1110
              if (need_low_pc)
 
1111
                {
 
1112
                  need_low_pc = 0;
 
1113
                  low_pc = address;
 
1114
                }
 
1115
            }
 
1116
          else switch (op_code)
 
1117
            {
 
1118
            case DW_LNS_extended_op:
 
1119
              line_ptr += 1;    /* Ignore length.  */
 
1120
              extended_op = read_1_byte (abfd, line_ptr);
 
1121
              line_ptr += 1;
 
1122
              switch (extended_op)
 
1123
                {
 
1124
                case DW_LNE_end_sequence:
 
1125
                  end_sequence = 1;
 
1126
                  add_line_info (table, address, filename, line, column,
 
1127
                                 end_sequence);
 
1128
                  if (need_low_pc)
 
1129
                    {
 
1130
                      need_low_pc = 0;
 
1131
                      low_pc = address;
 
1132
                    }
 
1133
                  arange_add (unit, low_pc, address);
 
1134
                  break;
 
1135
                case DW_LNE_set_address:
 
1136
                  address = read_address (unit, line_ptr);
 
1137
                  line_ptr += unit->addr_size;
 
1138
                  break;
 
1139
                case DW_LNE_define_file:
 
1140
                  cur_file = read_string (abfd, line_ptr, &bytes_read);
 
1141
                  line_ptr += bytes_read;
 
1142
                  if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
 
1143
                    {
 
1144
                      amt = table->num_files + FILE_ALLOC_CHUNK;
 
1145
                      amt *= sizeof (struct fileinfo);
 
1146
                      table->files =
 
1147
                        (struct fileinfo *) bfd_realloc (table->files, amt);
 
1148
                      if (! table->files)
 
1149
                        return 0;
 
1150
                    }
 
1151
                  table->files[table->num_files].name = cur_file;
 
1152
                  table->files[table->num_files].dir =
 
1153
                    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1154
                  line_ptr += bytes_read;
 
1155
                  table->files[table->num_files].time =
 
1156
                    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1157
                  line_ptr += bytes_read;
 
1158
                  table->files[table->num_files].size =
 
1159
                    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1160
                  line_ptr += bytes_read;
 
1161
                  table->num_files++;
 
1162
                  break;
 
1163
                default:
 
1164
                  (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
 
1165
                  bfd_set_error (bfd_error_bad_value);
 
1166
                  return 0;
 
1167
                }
 
1168
              break;
 
1169
            case DW_LNS_copy:
 
1170
              add_line_info (table, address, filename, line, column, 0);
 
1171
              basic_block = 0;
 
1172
              if (need_low_pc)
 
1173
                {
 
1174
                  need_low_pc = 0;
 
1175
                  low_pc = address;
 
1176
                }
 
1177
              break;
 
1178
            case DW_LNS_advance_pc:
 
1179
              address += lh.minimum_instruction_length
 
1180
                * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1181
              line_ptr += bytes_read;
 
1182
              break;
 
1183
            case DW_LNS_advance_line:
 
1184
              line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
 
1185
              line_ptr += bytes_read;
 
1186
              break;
 
1187
            case DW_LNS_set_file:
 
1188
              {
 
1189
                unsigned int file;
 
1190
 
 
1191
                /* The file and directory tables are 0 based, the references
 
1192
                   are 1 based.  */
 
1193
                file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1194
                line_ptr += bytes_read;
 
1195
                filename = concat_filename (table, file);
 
1196
                break;
 
1197
              }
 
1198
            case DW_LNS_set_column:
 
1199
              column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1200
              line_ptr += bytes_read;
 
1201
              break;
 
1202
            case DW_LNS_negate_stmt:
 
1203
              is_stmt = (!is_stmt);
 
1204
              break;
 
1205
            case DW_LNS_set_basic_block:
 
1206
              basic_block = 1;
 
1207
              break;
 
1208
            case DW_LNS_const_add_pc:
 
1209
              address += lh.minimum_instruction_length
 
1210
                      * ((255 - lh.opcode_base) / lh.line_range);
 
1211
              break;
 
1212
            case DW_LNS_fixed_advance_pc:
 
1213
              address += read_2_bytes (abfd, line_ptr);
 
1214
              line_ptr += 2;
 
1215
              break;
 
1216
            default:
 
1217
              {  /* Unknown standard opcode, ignore it.  */
 
1218
                int i;
 
1219
                for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
 
1220
                  {
 
1221
                    (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 
1222
                    line_ptr += bytes_read;
 
1223
                  }
 
1224
              }
 
1225
            }
 
1226
        }
 
1227
    }
 
1228
 
 
1229
  return table;
 
1230
}
 
1231
 
 
1232
/* If ADDR is within TABLE set the output parameters and return true,
 
1233
   otherwise return false.  The output parameters, FILENAME_PTR and
 
1234
   LINENUMBER_PTR, are pointers to the objects to be filled in.  */
 
1235
 
 
1236
static boolean
 
1237
lookup_address_in_line_info_table (table,
 
1238
                                   addr,
 
1239
                                   function,
 
1240
                                   filename_ptr,
 
1241
                                   linenumber_ptr)
 
1242
     struct line_info_table* table;
 
1243
     bfd_vma addr;
 
1244
     struct funcinfo *function;
 
1245
     const char **filename_ptr;
 
1246
     unsigned int *linenumber_ptr;
 
1247
{
 
1248
  struct line_info* next_line = table->last_line;
 
1249
  struct line_info* each_line;
 
1250
 
 
1251
  if (!next_line)
 
1252
    return false;
 
1253
 
 
1254
  each_line = next_line->prev_line;
 
1255
 
 
1256
  while (each_line && next_line)
 
1257
    {
 
1258
      if (!each_line->end_sequence
 
1259
          && addr >= each_line->address && addr < next_line->address)
 
1260
        {
 
1261
          /* If this line appears to span functions, and addr is in the
 
1262
             later function, return the first line of that function instead
 
1263
             of the last line of the earlier one.  This check is for GCC
 
1264
             2.95, which emits the first line number for a function late.  */
 
1265
          if (function != NULL
 
1266
              && each_line->address < function->low
 
1267
              && next_line->address > function->low)
 
1268
            {
 
1269
              *filename_ptr = next_line->filename;
 
1270
              *linenumber_ptr = next_line->line;
 
1271
            }
 
1272
          else
 
1273
            {
 
1274
              *filename_ptr = each_line->filename;
 
1275
              *linenumber_ptr = each_line->line;
 
1276
            }
 
1277
          return true;
 
1278
        }
 
1279
      next_line = each_line;
 
1280
      each_line = each_line->prev_line;
 
1281
    }
 
1282
 
 
1283
  /* At this point each_line is NULL but next_line is not.  If we found the
 
1284
     containing function in this compilation unit, return the first line we
 
1285
     have a number for.  This is also for compatibility with GCC 2.95.  */
 
1286
  if (function != NULL)
 
1287
    {
 
1288
      *filename_ptr = next_line->filename;
 
1289
      *linenumber_ptr = next_line->line;
 
1290
      return true;
 
1291
    }
 
1292
 
 
1293
  return false;
 
1294
}
 
1295
 
 
1296
/* Function table functions.  */
 
1297
 
 
1298
/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true.  */
 
1299
 
 
1300
static boolean
 
1301
lookup_address_in_function_table (table,
 
1302
                                  addr,
 
1303
                                  function_ptr,
 
1304
                                  functionname_ptr)
 
1305
     struct funcinfo* table;
 
1306
     bfd_vma addr;
 
1307
     struct funcinfo** function_ptr;
 
1308
     const char **functionname_ptr;
 
1309
{
 
1310
  struct funcinfo* each_func;
 
1311
 
 
1312
  for (each_func = table;
 
1313
       each_func;
 
1314
       each_func = each_func->prev_func)
 
1315
    {
 
1316
      if (addr >= each_func->low && addr < each_func->high)
 
1317
        {
 
1318
          *functionname_ptr = each_func->name;
 
1319
          *function_ptr = each_func;
 
1320
          return true;
 
1321
        }
 
1322
    }
 
1323
 
 
1324
  return false;
 
1325
}
 
1326
 
 
1327
/* DWARF2 Compilation unit functions.  */
 
1328
 
 
1329
/* Scan over each die in a comp. unit looking for functions to add
 
1330
   to the function table.  */
 
1331
 
 
1332
static boolean
 
1333
scan_unit_for_functions (unit)
 
1334
     struct comp_unit *unit;
 
1335
{
 
1336
  bfd *abfd = unit->abfd;
 
1337
  char *info_ptr = unit->first_child_die_ptr;
 
1338
  int nesting_level = 1;
 
1339
 
 
1340
  while (nesting_level)
 
1341
    {
 
1342
      unsigned int abbrev_number, bytes_read, i;
 
1343
      struct abbrev_info *abbrev;
 
1344
      struct attribute attr;
 
1345
      struct funcinfo *func;
 
1346
      char* name = 0;
 
1347
 
 
1348
      abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
1349
      info_ptr += bytes_read;
 
1350
 
 
1351
      if (! abbrev_number)
 
1352
        {
 
1353
          nesting_level--;
 
1354
          continue;
 
1355
        }
 
1356
 
 
1357
      abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
 
1358
      if (! abbrev)
 
1359
        {
 
1360
          (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
 
1361
                             abbrev_number);
 
1362
          bfd_set_error (bfd_error_bad_value);
 
1363
          return false;
 
1364
        }
 
1365
 
 
1366
      if (abbrev->tag == DW_TAG_subprogram)
 
1367
        {
 
1368
          bfd_size_type amt = sizeof (struct funcinfo);
 
1369
          func = (struct funcinfo *) bfd_zalloc (abfd, amt);
 
1370
          func->prev_func = unit->function_table;
 
1371
          unit->function_table = func;
 
1372
        }
 
1373
      else
 
1374
        func = NULL;
 
1375
 
 
1376
      for (i = 0; i < abbrev->num_attrs; ++i)
 
1377
        {
 
1378
          info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
 
1379
 
 
1380
          if (func)
 
1381
            {
 
1382
              switch (attr.name)
 
1383
                {
 
1384
                case DW_AT_name:
 
1385
 
 
1386
                  name = DW_STRING (&attr);
 
1387
 
 
1388
                  /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
 
1389
                  if (func->name == NULL)
 
1390
                    func->name = DW_STRING (&attr);
 
1391
                  break;
 
1392
 
 
1393
                case DW_AT_MIPS_linkage_name:
 
1394
                  func->name = DW_STRING (&attr);
 
1395
                  break;
 
1396
 
 
1397
                case DW_AT_low_pc:
 
1398
                  func->low = DW_ADDR (&attr);
 
1399
                  break;
 
1400
 
 
1401
                case DW_AT_high_pc:
 
1402
                  func->high = DW_ADDR (&attr);
 
1403
                  break;
 
1404
 
 
1405
                default:
 
1406
                  break;
 
1407
                }
 
1408
            }
 
1409
          else
 
1410
            {
 
1411
              switch (attr.name)
 
1412
                {
 
1413
                case DW_AT_name:
 
1414
                  name = DW_STRING (&attr);
 
1415
                  break;
 
1416
 
 
1417
                default:
 
1418
                  break;
 
1419
                }
 
1420
            }
 
1421
        }
 
1422
 
 
1423
      if (abbrev->has_children)
 
1424
        nesting_level++;
 
1425
    }
 
1426
 
 
1427
  return true;
 
1428
}
 
1429
 
 
1430
/* Look for a RELA relocation to be applied on OFFSET of section SEC,
 
1431
   and return the addend if such a relocation is found.  Since this is
 
1432
   only used to find relocations referring to the .debug_abbrev
 
1433
   section, we make sure the relocation refers to this section, but
 
1434
   this is not strictly necessary, and it can probably be safely
 
1435
   removed if needed.  However, it is important to note that this
 
1436
   function only returns the addend, it doesn't serve the purpose of
 
1437
   applying a generic relocation.
 
1438
 
 
1439
   If no suitable relocation is found, or if it is not a real RELA
 
1440
   relocation, this function returns 0.  */
 
1441
 
 
1442
static bfd_vma
 
1443
find_rela_addend (abfd, sec, offset, syms)
 
1444
     bfd* abfd;
 
1445
     asection* sec;
 
1446
     bfd_size_type offset;
 
1447
     asymbol** syms;
 
1448
{
 
1449
  long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
 
1450
  arelent **relocs = NULL;
 
1451
  long reloc_count, relc;
 
1452
 
 
1453
  if (reloc_size <= 0)
 
1454
    return 0;
 
1455
 
 
1456
  relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
 
1457
  if (relocs == NULL)
 
1458
    return 0;
 
1459
 
 
1460
  reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, syms);
 
1461
 
 
1462
  if (reloc_count <= 0)
 
1463
    {
 
1464
      free (relocs);
 
1465
      return 0;
 
1466
    }
 
1467
 
 
1468
  for (relc = 0; relc < reloc_count; relc++)
 
1469
    if (relocs[relc]->address == offset
 
1470
        && (*relocs[relc]->sym_ptr_ptr)->flags & BSF_SECTION_SYM
 
1471
        && strcmp ((*relocs[relc]->sym_ptr_ptr)->name,
 
1472
                   ".debug_abbrev") == 0)
 
1473
      {
 
1474
        bfd_vma addend = (relocs[relc]->howto->partial_inplace
 
1475
                          ? 0 : relocs[relc]->addend);
 
1476
        free (relocs);
 
1477
        return addend;
 
1478
      }
 
1479
 
 
1480
  free (relocs);
 
1481
  return 0;
 
1482
}
 
1483
 
 
1484
/* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
 
1485
   includes the compilation unit header that proceeds the DIE's, but
 
1486
   does not include the length field that preceeds each compilation
 
1487
   unit header.  END_PTR points one past the end of this comp unit.
 
1488
   OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
 
1489
 
 
1490
   This routine does not read the whole compilation unit; only enough
 
1491
   to get to the line number information for the compilation unit.  */
 
1492
 
 
1493
static struct comp_unit *
 
1494
parse_comp_unit (abfd, stash, unit_length, offset_size)
 
1495
     bfd* abfd;
 
1496
     struct dwarf2_debug *stash;
 
1497
     bfd_vma unit_length;
 
1498
     unsigned int offset_size;
 
1499
{
 
1500
  struct comp_unit* unit;
 
1501
  unsigned int version;
 
1502
  bfd_vma abbrev_offset = 0;
 
1503
  unsigned int addr_size;
 
1504
  struct abbrev_info** abbrevs;
 
1505
  unsigned int abbrev_number, bytes_read, i;
 
1506
  struct abbrev_info *abbrev;
 
1507
  struct attribute attr;
 
1508
  char *info_ptr = stash->info_ptr;
 
1509
  char *end_ptr = info_ptr + unit_length;
 
1510
  bfd_size_type amt;
 
1511
  bfd_size_type off;
 
1512
 
 
1513
  version = read_2_bytes (abfd, info_ptr);
 
1514
  info_ptr += 2;
 
1515
  BFD_ASSERT (offset_size == 4 || offset_size == 8);
 
1516
  if (offset_size == 4)
 
1517
    abbrev_offset = read_4_bytes (abfd, info_ptr);
 
1518
  else
 
1519
    abbrev_offset = read_8_bytes (abfd, info_ptr);
 
1520
  /* The abbrev offset is generally a relocation pointing to
 
1521
     .debug_abbrev+offset.  On RELA targets, we have to find the
 
1522
     relocation and extract the addend to obtain the actual
 
1523
     abbrev_offset, so do it here.  */
 
1524
  off = info_ptr - stash->sec_info_ptr;
 
1525
  abbrev_offset += find_rela_addend (abfd, stash->sec, off, stash->syms);
 
1526
  info_ptr += offset_size;
 
1527
  addr_size = read_1_byte (abfd, info_ptr);
 
1528
  info_ptr += 1;
 
1529
 
 
1530
  if (version != 2)
 
1531
    {
 
1532
      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
 
1533
      bfd_set_error (bfd_error_bad_value);
 
1534
      return 0;
 
1535
    }
 
1536
 
 
1537
  if (addr_size > sizeof (bfd_vma))
 
1538
    {
 
1539
      (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
 
1540
                         addr_size,
 
1541
                         (unsigned int) sizeof (bfd_vma));
 
1542
      bfd_set_error (bfd_error_bad_value);
 
1543
      return 0;
 
1544
    }
 
1545
 
 
1546
  if (addr_size != 2 && addr_size != 4 && addr_size != 8)
 
1547
    {
 
1548
      (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
 
1549
      bfd_set_error (bfd_error_bad_value);
 
1550
      return 0;
 
1551
    }
 
1552
 
 
1553
  /* Read the abbrevs for this compilation unit into a table.  */
 
1554
  abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
 
1555
  if (! abbrevs)
 
1556
      return 0;
 
1557
 
 
1558
  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 
1559
  info_ptr += bytes_read;
 
1560
  if (! abbrev_number)
 
1561
    {
 
1562
      (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
 
1563
                         abbrev_number);
 
1564
      bfd_set_error (bfd_error_bad_value);
 
1565
      return 0;
 
1566
    }
 
1567
 
 
1568
  abbrev = lookup_abbrev (abbrev_number, abbrevs);
 
1569
  if (! abbrev)
 
1570
    {
 
1571
      (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
 
1572
                         abbrev_number);
 
1573
      bfd_set_error (bfd_error_bad_value);
 
1574
      return 0;
 
1575
    }
 
1576
 
 
1577
  amt = sizeof (struct comp_unit);
 
1578
  unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
 
1579
  unit->abfd = abfd;
 
1580
  unit->addr_size = addr_size;
 
1581
  unit->offset_size = offset_size;
 
1582
  unit->abbrevs = abbrevs;
 
1583
  unit->end_ptr = end_ptr;
 
1584
  unit->stash = stash;
 
1585
 
 
1586
  for (i = 0; i < abbrev->num_attrs; ++i)
 
1587
    {
 
1588
      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
 
1589
 
 
1590
      /* Store the data if it is of an attribute we want to keep in a
 
1591
         partial symbol table.  */
 
1592
      switch (attr.name)
 
1593
        {
 
1594
        case DW_AT_stmt_list:
 
1595
          unit->stmtlist = 1;
 
1596
          unit->line_offset = DW_UNSND (&attr);
 
1597
          break;
 
1598
 
 
1599
        case DW_AT_name:
 
1600
          unit->name = DW_STRING (&attr);
 
1601
          break;
 
1602
 
 
1603
        case DW_AT_low_pc:
 
1604
          unit->arange.low = DW_ADDR (&attr);
 
1605
          break;
 
1606
 
 
1607
        case DW_AT_high_pc:
 
1608
          unit->arange.high = DW_ADDR (&attr);
 
1609
          break;
 
1610
 
 
1611
        case DW_AT_comp_dir:
 
1612
          {
 
1613
            char* comp_dir = DW_STRING (&attr);
 
1614
            if (comp_dir)
 
1615
              {
 
1616
                /* Irix 6.2 native cc prepends <machine>.: to the compilation
 
1617
                   directory, get rid of it.  */
 
1618
                char *cp = (char*) strchr (comp_dir, ':');
 
1619
 
 
1620
                if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
 
1621
                  comp_dir = cp + 1;
 
1622
              }
 
1623
            unit->comp_dir = comp_dir;
 
1624
            break;
 
1625
          }
 
1626
 
 
1627
        default:
 
1628
          break;
 
1629
        }
 
1630
    }
 
1631
 
 
1632
  unit->first_child_die_ptr = info_ptr;
 
1633
  return unit;
 
1634
}
 
1635
 
 
1636
/* Return true if UNIT contains the address given by ADDR.  */
 
1637
 
 
1638
static boolean
 
1639
comp_unit_contains_address (unit, addr)
 
1640
     struct comp_unit* unit;
 
1641
     bfd_vma addr;
 
1642
{
 
1643
  struct arange *arange;
 
1644
 
 
1645
  if (unit->error)
 
1646
    return 0;
 
1647
 
 
1648
  arange = &unit->arange;
 
1649
  do
 
1650
    {
 
1651
      if (addr >= arange->low && addr < arange->high)
 
1652
        return 1;
 
1653
      arange = arange->next;
 
1654
    }
 
1655
  while (arange);
 
1656
 
 
1657
  return 0;
 
1658
}
 
1659
 
 
1660
/* If UNIT contains ADDR, set the output parameters to the values for
 
1661
   the line containing ADDR.  The output parameters, FILENAME_PTR,
 
1662
   FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
 
1663
   to be filled in.
 
1664
 
 
1665
   Return true of UNIT contains ADDR, and no errors were encountered;
 
1666
   false otherwise.  */
 
1667
 
 
1668
static boolean
 
1669
comp_unit_find_nearest_line (unit, addr,
 
1670
                             filename_ptr, functionname_ptr, linenumber_ptr,
 
1671
                             stash)
 
1672
     struct comp_unit* unit;
 
1673
     bfd_vma addr;
 
1674
     const char **filename_ptr;
 
1675
     const char **functionname_ptr;
 
1676
     unsigned int *linenumber_ptr;
 
1677
     struct dwarf2_debug *stash;
 
1678
{
 
1679
  boolean line_p;
 
1680
  boolean func_p;
 
1681
  struct funcinfo *function;
 
1682
 
 
1683
  if (unit->error)
 
1684
    return false;
 
1685
 
 
1686
  if (! unit->line_table)
 
1687
    {
 
1688
      if (! unit->stmtlist)
 
1689
        {
 
1690
          unit->error = 1;
 
1691
          return false;
 
1692
        }
 
1693
 
 
1694
      unit->line_table = decode_line_info (unit, stash);
 
1695
 
 
1696
      if (! unit->line_table)
 
1697
        {
 
1698
          unit->error = 1;
 
1699
          return false;
 
1700
        }
 
1701
 
 
1702
      if (unit->first_child_die_ptr < unit->end_ptr
 
1703
          && ! scan_unit_for_functions (unit))
 
1704
        {
 
1705
          unit->error = 1;
 
1706
          return false;
 
1707
        }
 
1708
    }
 
1709
 
 
1710
  function = NULL;
 
1711
  func_p = lookup_address_in_function_table (unit->function_table,
 
1712
                                             addr,
 
1713
                                             &function,
 
1714
                                             functionname_ptr);
 
1715
  line_p = lookup_address_in_line_info_table (unit->line_table,
 
1716
                                              addr,
 
1717
                                              function,
 
1718
                                              filename_ptr,
 
1719
                                              linenumber_ptr);
 
1720
  return line_p || func_p;
 
1721
}
 
1722
 
 
1723
/* Locate a section in a BFD containing debugging info.  The search starts from the
 
1724
   section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
 
1725
   NULL.  The search works by examining the names of the sections.  There are two
 
1726
   permissiable names.  The first is .debug_info.  This is the standard DWARF2 name.
 
1727
   The second is a prefix .gnu.linkonce.wi.  This is a variation on the .debug_info
 
1728
   section which has a checksum describing the contents appended onto the name.  This
 
1729
   allows the linker to identify and discard duplicate debugging sections for
 
1730
   different compilation units.  */
 
1731
#define DWARF2_DEBUG_INFO ".debug_info"
 
1732
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
 
1733
 
 
1734
static asection *
 
1735
find_debug_info (abfd, after_sec)
 
1736
     bfd * abfd;
 
1737
     asection * after_sec;
 
1738
{
 
1739
  asection * msec;
 
1740
 
 
1741
  if (after_sec)
 
1742
    msec = after_sec->next;
 
1743
  else
 
1744
    msec = abfd->sections;
 
1745
 
 
1746
  while (msec)
 
1747
    {
 
1748
      if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
 
1749
        return msec;
 
1750
 
 
1751
      if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
 
1752
        return msec;
 
1753
 
 
1754
      msec = msec->next;
 
1755
    }
 
1756
 
 
1757
  return NULL;
 
1758
}
 
1759
 
 
1760
/* The DWARF2 version of find_nearest line.  Return true if the line
 
1761
   is found without error.  ADDR_SIZE is the number of bytes in the
 
1762
   initial .debug_info length field and in the abbreviation offset.
 
1763
   You may use zero to indicate that the default value should be
 
1764
   used.  */
 
1765
 
 
1766
boolean
 
1767
_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
 
1768
                               filename_ptr, functionname_ptr,
 
1769
                               linenumber_ptr,
 
1770
                               addr_size, pinfo)
 
1771
     bfd *abfd;
 
1772
     asection *section;
 
1773
     asymbol **symbols;
 
1774
     bfd_vma offset;
 
1775
     const char **filename_ptr;
 
1776
     const char **functionname_ptr;
 
1777
     unsigned int *linenumber_ptr;
 
1778
     unsigned int addr_size;
 
1779
     PTR *pinfo;
 
1780
{
 
1781
  /* Read each compilation unit from the section .debug_info, and check
 
1782
     to see if it contains the address we are searching for.  If yes,
 
1783
     lookup the address, and return the line number info.  If no, go
 
1784
     on to the next compilation unit.
 
1785
 
 
1786
     We keep a list of all the previously read compilation units, and
 
1787
     a pointer to the next un-read compilation unit.  Check the
 
1788
     previously read units before reading more.  */
 
1789
  struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
 
1790
 
 
1791
  /* What address are we looking for?  */
 
1792
  bfd_vma addr = offset + section->vma;
 
1793
 
 
1794
  struct comp_unit* each;
 
1795
 
 
1796
  *filename_ptr = NULL;
 
1797
  *functionname_ptr = NULL;
 
1798
  *linenumber_ptr = 0;
 
1799
 
 
1800
  /* The DWARF2 spec says that the initial length field, and the
 
1801
     offset of the abbreviation table, should both be 4-byte values.
 
1802
     However, some compilers do things differently.  */
 
1803
  if (addr_size == 0)
 
1804
    addr_size = 4;
 
1805
  BFD_ASSERT (addr_size == 4 || addr_size == 8);
 
1806
 
 
1807
  if (! stash)
 
1808
    {
 
1809
      bfd_size_type total_size;
 
1810
      asection *msec;
 
1811
      bfd_size_type amt = sizeof (struct dwarf2_debug);
 
1812
 
 
1813
      stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
 
1814
      if (! stash)
 
1815
        return false;
 
1816
 
 
1817
      *pinfo = (PTR) stash;
 
1818
 
 
1819
      msec = find_debug_info (abfd, NULL);
 
1820
      if (! msec)
 
1821
        /* No dwarf2 info.  Note that at this point the stash
 
1822
           has been allocated, but contains zeros, this lets
 
1823
           future calls to this function fail quicker.  */
 
1824
         return false;
 
1825
 
 
1826
      /* There can be more than one DWARF2 info section in a BFD these days.
 
1827
         Read them all in and produce one large stash.  We do this in two
 
1828
         passes - in the first pass we just accumulate the section sizes.
 
1829
         In the second pass we read in the section's contents.  The allows
 
1830
         us to avoid reallocing the data as we add sections to the stash.  */
 
1831
      for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
 
1832
        total_size += msec->_raw_size;
 
1833
 
 
1834
      stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
 
1835
      if (stash->info_ptr == NULL)
 
1836
        return false;
 
1837
 
 
1838
      stash->info_ptr_end = stash->info_ptr;
 
1839
 
 
1840
      for (msec = find_debug_info (abfd, NULL);
 
1841
           msec;
 
1842
           msec = find_debug_info (abfd, msec))
 
1843
        {
 
1844
          bfd_size_type size;
 
1845
          bfd_size_type start;
 
1846
 
 
1847
          size = msec->_raw_size;
 
1848
          if (size == 0)
 
1849
            continue;
 
1850
 
 
1851
          start = stash->info_ptr_end - stash->info_ptr;
 
1852
 
 
1853
          if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start,
 
1854
                                          (bfd_vma) 0, size))
 
1855
            continue;
 
1856
 
 
1857
          stash->info_ptr_end = stash->info_ptr + start + size;
 
1858
        }
 
1859
 
 
1860
      BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
 
1861
 
 
1862
      stash->sec = find_debug_info (abfd, NULL);
 
1863
      stash->sec_info_ptr = stash->info_ptr;
 
1864
      stash->syms = symbols;
 
1865
    }
 
1866
 
 
1867
  /* FIXME: There is a problem with the contents of the
 
1868
     .debug_info section.  The 'low' and 'high' addresses of the
 
1869
     comp_units are computed by relocs against symbols in the
 
1870
     .text segment.  We need these addresses in order to determine
 
1871
     the nearest line number, and so we have to resolve the
 
1872
     relocs.  There is a similar problem when the .debug_line
 
1873
     section is processed as well (e.g., there may be relocs
 
1874
     against the operand of the DW_LNE_set_address operator).
 
1875
 
 
1876
     Unfortunately getting hold of the reloc information is hard...
 
1877
 
 
1878
     For now, this means that disassembling object files (as
 
1879
     opposed to fully executables) does not always work as well as
 
1880
     we would like.  */
 
1881
 
 
1882
  /* A null info_ptr indicates that there is no dwarf2 info
 
1883
     (or that an error occured while setting up the stash).  */
 
1884
  if (! stash->info_ptr)
 
1885
    return false;
 
1886
 
 
1887
  /* Check the previously read comp. units first.  */
 
1888
  for (each = stash->all_comp_units; each; each = each->next_unit)
 
1889
    if (comp_unit_contains_address (each, addr))
 
1890
      return comp_unit_find_nearest_line (each, addr, filename_ptr,
 
1891
                                          functionname_ptr, linenumber_ptr,
 
1892
                                          stash);
 
1893
 
 
1894
  /* Read each remaining comp. units checking each as they are read.  */
 
1895
  while (stash->info_ptr < stash->info_ptr_end)
 
1896
    {
 
1897
      bfd_vma length;
 
1898
      boolean found;
 
1899
      unsigned int offset_size = addr_size;
 
1900
 
 
1901
      if (addr_size == 4)
 
1902
        {
 
1903
          length = read_4_bytes (abfd, stash->info_ptr);
 
1904
          if (length == 0xffffffff)
 
1905
            {
 
1906
              offset_size = 8;
 
1907
              length = read_8_bytes (abfd, stash->info_ptr + 4);
 
1908
              stash->info_ptr += 8;
 
1909
            }
 
1910
        }
 
1911
      else
 
1912
        length = read_8_bytes (abfd, stash->info_ptr);
 
1913
      stash->info_ptr += addr_size;
 
1914
 
 
1915
      if (length > 0)
 
1916
        {
 
1917
          each = parse_comp_unit (abfd, stash, length, offset_size);
 
1918
          stash->info_ptr += length;
 
1919
 
 
1920
          if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
 
1921
              == stash->sec->_raw_size)
 
1922
            {
 
1923
              stash->sec = find_debug_info (abfd, stash->sec);
 
1924
              stash->sec_info_ptr = stash->info_ptr;
 
1925
            }
 
1926
 
 
1927
          if (each)
 
1928
            {
 
1929
              each->next_unit = stash->all_comp_units;
 
1930
              stash->all_comp_units = each;
 
1931
 
 
1932
              /* DW_AT_low_pc and DW_AT_high_pc are optional for
 
1933
                 compilation units.  If we don't have them (i.e.,
 
1934
                 unit->high == 0), we need to consult the line info
 
1935
                 table to see if a compilation unit contains the given
 
1936
                 address.  */
 
1937
              if (each->arange.high > 0)
 
1938
                {
 
1939
                  if (comp_unit_contains_address (each, addr))
 
1940
                    return comp_unit_find_nearest_line (each, addr,
 
1941
                                                       filename_ptr,
 
1942
                                                       functionname_ptr,
 
1943
                                                       linenumber_ptr,
 
1944
                                                       stash);
 
1945
                }
 
1946
              else
 
1947
                {
 
1948
                  found = comp_unit_find_nearest_line (each, addr,
 
1949
                                                       filename_ptr,
 
1950
                                                       functionname_ptr,
 
1951
                                                       linenumber_ptr,
 
1952
                                                       stash);
 
1953
                  if (found)
 
1954
                    return true;
 
1955
                }
 
1956
            }
 
1957
        }
 
1958
    }
 
1959
 
 
1960
  return false;
 
1961
}