2000-03-08 H.J. Lu (hjl@gnu.org)
[binutils.git] / bfd / dwarf2.c
blob5710d1adbd0d00b1c09fd2a0572e661adc997ab4
1 /* DWARF 2 support.
2 Copyright 1994, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
4 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
5 (gavin@cygnus.com).
7 From the dwarf2read.c header:
8 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
9 Inc. with support from Florida State University (under contract
10 with the Ada Joint Program Office), and Silicon Graphics, Inc.
11 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
12 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 support in dwarfread.c
15 This file is part of BFD.
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 2 of the License, or (at
20 your option) any later version.
22 This program is distributed in the hope that it will be useful, but
23 WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 #include "bfd.h"
32 #include "sysdep.h"
33 #include "libiberty.h"
34 #include "libbfd.h"
35 #include "elf-bfd.h"
36 #include "elf/dwarf2.h"
38 /* The data in the .debug_line statement prologue looks like this. */
39 struct line_head
41 unsigned int total_length;
42 unsigned short version;
43 unsigned int prologue_length;
44 unsigned char minimum_instruction_length;
45 unsigned char default_is_stmt;
46 int line_base;
47 unsigned char line_range;
48 unsigned char opcode_base;
49 unsigned char *standard_opcode_lengths;
52 /* Attributes have a name and a value */
53 struct attribute
55 enum dwarf_attribute name;
56 enum dwarf_form form;
57 union
59 char *str;
60 struct dwarf_block *blk;
61 unsigned int unsnd;
62 int snd;
63 bfd_vma addr;
68 /* Get at parts of an attribute structure */
70 #define DW_STRING(attr) ((attr)->u.str)
71 #define DW_UNSND(attr) ((attr)->u.unsnd)
72 #define DW_BLOCK(attr) ((attr)->u.blk)
73 #define DW_SND(attr) ((attr)->u.snd)
74 #define DW_ADDR(attr) ((attr)->u.addr)
76 /* Blocks are a bunch of untyped bytes. */
77 struct dwarf_block
79 unsigned int size;
80 char *data;
84 struct dwarf2_debug {
86 /* A list of all previously read comp_units. */
87 struct comp_unit* all_comp_units;
89 /* The next unread compilation unit within the .debug_info section.
90 Zero indicates that the .debug_info section has not been loaded
91 into a buffer yet.*/
92 char* info_ptr;
94 /* Pointer to the end of the .debug_info section memory buffer. */
95 char* info_ptr_end;
97 /* Pointer to the .debug_abbrev section loaded into memory. */
98 char* dwarf_abbrev_buffer;
100 /* Length of the loaded .debug_abbrev section. */
101 unsigned long dwarf_abbrev_size;
103 /* Buffer for decode_line_info. */
104 char *dwarf_line_buffer;
107 struct arange {
108 struct arange *next;
109 bfd_vma low;
110 bfd_vma high;
114 /* A minimal decoding of DWARF2 compilation units. We only decode
115 what's needed to get to the line number information. */
117 struct comp_unit {
119 /* Chain the previously read compilation units. */
120 struct comp_unit* next_unit;
122 /* Keep the bdf convenient (for memory allocation). */
123 bfd* abfd;
125 /* The lowest and higest addresses contained in this compilation
126 unit as specified in the compilation unit header. */
127 struct arange arange;
129 /* The DW_AT_name attribute (for error messages). */
130 char* name;
132 /* The abbrev hash table. */
133 struct abbrev_info** abbrevs;
135 /* Note that an error was found by comp_unit_find_nearest_line. */
136 int error;
138 /* The DW_AT_comp_dir attribute */
139 char* comp_dir;
141 /* True if there is a line number table associated with this comp. unit. */
142 int stmtlist;
144 /* The offset into .debug_line of the line number table. */
145 unsigned long line_offset;
147 /* Pointer to the first child die for the comp unit. */
148 char *first_child_die_ptr;
150 /* The end of the comp unit. */
151 char *end_ptr;
153 /* The decoded line number, NULL if not yet decoded. */
154 struct line_info_table* line_table;
156 /* A list of the functions found in this comp. unit. */
157 struct funcinfo* function_table;
159 /* Address size for this unit - from unit header */
160 unsigned char addr_size;
165 /* VERBATIM
166 The following function up to the END VERBATIM mark are
167 copied directly from dwarf2read.c. */
169 /* read dwarf information from a buffer */
171 static unsigned int
172 read_1_byte (abfd, buf)
173 bfd *abfd ATTRIBUTE_UNUSED;
174 char *buf;
176 return bfd_get_8 (abfd, (bfd_byte *) buf);
179 static int
180 read_1_signed_byte (abfd, buf)
181 bfd *abfd ATTRIBUTE_UNUSED;
182 char *buf;
184 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
187 static unsigned int
188 read_2_bytes (abfd, buf)
189 bfd *abfd;
190 char *buf;
192 return bfd_get_16 (abfd, (bfd_byte *) buf);
195 #if 0
197 /* This is not used. */
199 static int
200 read_2_signed_bytes (abfd, buf)
201 bfd *abfd;
202 char *buf;
204 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
207 #endif
209 static unsigned int
210 read_4_bytes (abfd, buf)
211 bfd *abfd;
212 char *buf;
214 return bfd_get_32 (abfd, (bfd_byte *) buf);
217 #if 0
219 /* This is not used. */
221 static int
222 read_4_signed_bytes (abfd, buf)
223 bfd *abfd;
224 char *buf;
226 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
229 #endif
231 static unsigned int
232 read_8_bytes (abfd, buf)
233 bfd *abfd;
234 char *buf;
236 return bfd_get_64 (abfd, (bfd_byte *) buf);
239 static char *
240 read_n_bytes (abfd, buf, size)
241 bfd *abfd ATTRIBUTE_UNUSED;
242 char *buf;
243 unsigned int size ATTRIBUTE_UNUSED;
245 /* If the size of a host char is 8 bits, we can return a pointer
246 to the buffer, otherwise we have to copy the data to a buffer
247 allocated on the temporary obstack. */
248 return buf;
251 static char *
252 read_string (abfd, buf, bytes_read_ptr)
253 bfd *abfd ATTRIBUTE_UNUSED;
254 char *buf;
255 unsigned int *bytes_read_ptr;
257 /* If the size of a host char is 8 bits, we can return a pointer
258 to the string, otherwise we have to copy the string to a buffer
259 allocated on the temporary obstack. */
260 if (*buf == '\0')
262 *bytes_read_ptr = 1;
263 return NULL;
265 *bytes_read_ptr = strlen (buf) + 1;
266 return buf;
269 static unsigned int
270 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
271 bfd *abfd ATTRIBUTE_UNUSED;
272 char *buf;
273 unsigned int *bytes_read_ptr;
275 unsigned int result;
276 unsigned int num_read;
277 int shift;
278 unsigned char byte;
280 result = 0;
281 shift = 0;
282 num_read = 0;
286 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
287 buf ++;
288 num_read ++;
289 result |= ((byte & 0x7f) << shift);
290 shift += 7;
292 while (byte & 0x80);
294 * bytes_read_ptr = num_read;
296 return result;
299 static int
300 read_signed_leb128 (abfd, buf, bytes_read_ptr)
301 bfd *abfd ATTRIBUTE_UNUSED;
302 char *buf;
303 unsigned int * bytes_read_ptr;
305 int result;
306 int shift;
307 int num_read;
308 unsigned char byte;
310 result = 0;
311 shift = 0;
312 num_read = 0;
316 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
317 buf ++;
318 num_read ++;
319 result |= ((byte & 0x7f) << shift);
320 shift += 7;
322 while (byte & 0x80);
324 if ((shift < 32) && (byte & 0x40))
325 result |= -(1 << shift);
327 * bytes_read_ptr = num_read;
329 return result;
332 /* END VERBATIM */
334 static bfd_vma
335 read_address (unit, buf)
336 struct comp_unit* unit;
337 char *buf;
339 switch (unit->addr_size)
341 case 8:
342 return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
343 case 4:
344 return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
345 case 2:
346 return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
347 default:
348 abort ();
356 /* This data structure holds the information of an abbrev. */
357 struct abbrev_info
359 unsigned int number; /* number identifying abbrev */
360 enum dwarf_tag tag; /* dwarf tag */
361 int has_children; /* boolean */
362 unsigned int num_attrs; /* number of attributes */
363 struct attr_abbrev *attrs; /* an array of attribute descriptions */
364 struct abbrev_info *next; /* next in chain */
367 struct attr_abbrev
369 enum dwarf_attribute name;
370 enum dwarf_form form;
373 #ifndef ABBREV_HASH_SIZE
374 #define ABBREV_HASH_SIZE 121
375 #endif
376 #ifndef ATTR_ALLOC_CHUNK
377 #define ATTR_ALLOC_CHUNK 4
378 #endif
380 /* Lookup an abbrev_info structure in the abbrev hash table. */
382 static struct abbrev_info *
383 lookup_abbrev (number,abbrevs)
384 unsigned int number;
385 struct abbrev_info **abbrevs;
387 unsigned int hash_number;
388 struct abbrev_info *abbrev;
390 hash_number = number % ABBREV_HASH_SIZE;
391 abbrev = abbrevs[hash_number];
393 while (abbrev)
395 if (abbrev->number == number)
396 return abbrev;
397 else
398 abbrev = abbrev->next;
400 return NULL;
403 /* In DWARF version 2, the description of the debugging information is
404 stored in a separate .debug_abbrev section. Before we read any
405 dies from a section we read in all abbreviations and install them
406 in a hash table. */
408 static struct abbrev_info**
409 read_abbrevs (abfd, offset)
410 bfd * abfd;
411 unsigned int offset;
413 struct abbrev_info **abbrevs;
414 char *abbrev_ptr;
415 struct abbrev_info *cur_abbrev;
416 unsigned int abbrev_number, bytes_read, abbrev_name;
417 unsigned int abbrev_form, hash_number;
418 struct dwarf2_debug *stash;
420 stash = elf_tdata(abfd)->dwarf2_find_line_info;
422 if (! stash->dwarf_abbrev_buffer)
424 asection *msec;
426 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
427 if (! msec)
429 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
430 bfd_set_error (bfd_error_bad_value);
431 return 0;
434 stash->dwarf_abbrev_size = msec->_raw_size;
435 stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, stash->dwarf_abbrev_size);
436 if (! stash->dwarf_abbrev_buffer)
437 return 0;
439 if (! bfd_get_section_contents (abfd, msec,
440 stash->dwarf_abbrev_buffer, 0,
441 stash->dwarf_abbrev_size))
442 return 0;
445 if (offset > stash->dwarf_abbrev_size)
447 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."),
448 offset, stash->dwarf_abbrev_size );
449 bfd_set_error (bfd_error_bad_value);
450 return 0;
453 abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof(struct abbrev_info*) * ABBREV_HASH_SIZE);
455 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
456 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
457 abbrev_ptr += bytes_read;
459 /* loop until we reach an abbrev number of 0 */
460 while (abbrev_number)
462 cur_abbrev = (struct abbrev_info*)bfd_zalloc (abfd, sizeof (struct abbrev_info));
464 /* read in abbrev header */
465 cur_abbrev->number = abbrev_number;
466 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
467 abbrev_ptr += bytes_read;
468 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
469 abbrev_ptr += 1;
471 /* now read in declarations */
472 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
473 abbrev_ptr += bytes_read;
474 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
475 abbrev_ptr += bytes_read;
476 while (abbrev_name)
478 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
480 cur_abbrev->attrs = (struct attr_abbrev *)
481 bfd_realloc (cur_abbrev->attrs,
482 (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
483 * sizeof (struct attr_abbrev));
484 if (! cur_abbrev->attrs)
485 return 0;
487 cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
488 cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
489 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
490 abbrev_ptr += bytes_read;
491 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
492 abbrev_ptr += bytes_read;
495 hash_number = abbrev_number % ABBREV_HASH_SIZE;
496 cur_abbrev->next = abbrevs[hash_number];
497 abbrevs[hash_number] = cur_abbrev;
499 /* Get next abbreviation.
500 Under Irix6 the abbreviations for a compilation unit are not
501 always properly terminated with an abbrev number of 0.
502 Exit loop if we encounter an abbreviation which we have
503 already read (which means we are about to read the abbreviations
504 for the next compile unit) or if the end of the abbreviation
505 table is reached. */
506 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
507 >= stash->dwarf_abbrev_size)
508 break;
509 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
510 abbrev_ptr += bytes_read;
511 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
512 break;
515 return abbrevs;
518 /* Read an attribute described by an abbreviated attribute. */
520 static char *
521 read_attribute (attr, abbrev, unit, info_ptr)
522 struct attribute *attr;
523 struct attr_abbrev *abbrev;
524 struct comp_unit *unit;
525 char *info_ptr;
527 bfd *abfd = unit->abfd;
528 unsigned int bytes_read;
529 struct dwarf_block *blk;
531 attr->name = abbrev->name;
532 attr->form = abbrev->form;
533 switch (abbrev->form)
535 case DW_FORM_addr:
536 case DW_FORM_ref_addr:
537 DW_ADDR (attr) = read_address (unit, info_ptr);
538 info_ptr += unit->addr_size;
539 break;
540 case DW_FORM_block2:
541 blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
542 blk->size = read_2_bytes (abfd, info_ptr);
543 info_ptr += 2;
544 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
545 info_ptr += blk->size;
546 DW_BLOCK (attr) = blk;
547 break;
548 case DW_FORM_block4:
549 blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
550 blk->size = read_4_bytes (abfd, info_ptr);
551 info_ptr += 4;
552 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
553 info_ptr += blk->size;
554 DW_BLOCK (attr) = blk;
555 break;
556 case DW_FORM_data2:
557 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
558 info_ptr += 2;
559 break;
560 case DW_FORM_data4:
561 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
562 info_ptr += 4;
563 break;
564 case DW_FORM_data8:
565 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
566 info_ptr += 8;
567 break;
568 case DW_FORM_string:
569 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
570 info_ptr += bytes_read;
571 break;
572 case DW_FORM_block:
573 blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
574 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
575 info_ptr += bytes_read;
576 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
577 info_ptr += blk->size;
578 DW_BLOCK (attr) = blk;
579 break;
580 case DW_FORM_block1:
581 blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
582 blk->size = read_1_byte (abfd, info_ptr);
583 info_ptr += 1;
584 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
585 info_ptr += blk->size;
586 DW_BLOCK (attr) = blk;
587 break;
588 case DW_FORM_data1:
589 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
590 info_ptr += 1;
591 break;
592 case DW_FORM_flag:
593 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
594 info_ptr += 1;
595 break;
596 case DW_FORM_sdata:
597 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
598 info_ptr += bytes_read;
599 break;
600 case DW_FORM_udata:
601 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
602 info_ptr += bytes_read;
603 break;
604 case DW_FORM_ref1:
605 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
606 info_ptr += 1;
607 break;
608 case DW_FORM_ref2:
609 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
610 info_ptr += 2;
611 break;
612 case DW_FORM_ref4:
613 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
614 info_ptr += 4;
615 break;
616 case DW_FORM_ref8:
617 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
618 info_ptr += 8;
619 break;
620 case DW_FORM_ref_udata:
621 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
622 info_ptr += bytes_read;
623 break;
624 case DW_FORM_strp:
625 case DW_FORM_indirect:
626 default:
627 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %d."),
628 abbrev->form);
629 bfd_set_error (bfd_error_bad_value);
631 return info_ptr;
635 /* Source line information table routines. */
637 #define FILE_ALLOC_CHUNK 5
638 #define DIR_ALLOC_CHUNK 5
640 struct line_info {
641 struct line_info* prev_line;
643 bfd_vma address;
644 char* filename;
645 unsigned int line;
646 unsigned int column;
647 int end_sequence; /* end of (sequential) code sequence */
650 struct fileinfo {
651 char *name;
652 unsigned int dir;
653 unsigned int time;
654 unsigned int size;
657 struct line_info_table {
658 bfd* abfd;
660 unsigned int num_files;
661 unsigned int num_dirs;
663 char* comp_dir;
664 char** dirs;
665 struct fileinfo* files;
666 struct line_info* last_line;
669 static void
670 add_line_info (table, address, filename, line, column, end_sequence)
671 struct line_info_table* table;
672 bfd_vma address;
673 char* filename;
674 unsigned int line;
675 unsigned int column;
676 int end_sequence;
678 struct line_info* info = (struct line_info*)
679 bfd_alloc (table->abfd, sizeof (struct line_info));
681 info->prev_line = table->last_line;
682 table->last_line = info;
684 info->address = address;
685 info->filename = filename;
686 info->line = line;
687 info->column = column;
688 info->end_sequence = end_sequence;
691 static char*
692 concat_filename (table, file)
693 struct line_info_table* table;
694 unsigned int file;
696 char* filename;
698 if (file - 1 >= table->num_files)
700 (*_bfd_error_handler) (_("Dwarf Error: mangled line number "
701 "section (bad file number)."));
702 return "<unknown>";
705 filename = table->files[file - 1].name;
706 if (*filename == '/')
707 return filename;
709 else
711 char* dirname = (table->files[file - 1].dir
712 ? table->dirs[table->files[file - 1].dir - 1]
713 : table->comp_dir);
714 return (char*) concat (dirname, "/", filename, NULL);
718 static void
719 arange_add (unit, low_pc, high_pc)
720 struct comp_unit *unit;
721 bfd_vma low_pc;
722 bfd_vma high_pc;
724 struct arange *arange;
726 /* first see if we can cheaply extend an existing range: */
727 arange = &unit->arange;
730 if (low_pc == arange->high)
732 arange->high = high_pc;
733 return;
735 if (high_pc == arange->low)
737 arange->low = low_pc;
738 return;
740 arange = arange->next;
742 while (arange);
744 if (unit->arange.high == 0)
746 /* this is the first address range: store it in unit->arange: */
747 unit->arange.next = 0;
748 unit->arange.low = low_pc;
749 unit->arange.high = high_pc;
750 return;
753 /* need to allocate a new arange and insert it into the arange list: */
754 arange = bfd_zalloc (unit->abfd, sizeof (*arange));
755 arange->low = low_pc;
756 arange->high = high_pc;
758 arange->next = unit->arange.next;
759 unit->arange.next = arange;
762 /* Decode the line number information for UNIT. */
764 static struct line_info_table*
765 decode_line_info (unit)
766 struct comp_unit *unit;
768 bfd *abfd = unit->abfd;
770 struct dwarf2_debug *stash;
772 struct line_info_table* table;
774 char *line_ptr;
775 char *line_end;
776 struct line_head lh;
777 unsigned int i, bytes_read;
778 char *cur_file, *cur_dir;
779 unsigned char op_code, extended_op, adj_opcode;
781 stash = elf_tdata (abfd)->dwarf2_find_line_info;
783 if (! stash->dwarf_line_buffer)
785 asection *msec;
786 unsigned long size;
788 msec = bfd_get_section_by_name (abfd, ".debug_line");
789 if (! msec)
791 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
792 bfd_set_error (bfd_error_bad_value);
793 return 0;
796 size = msec->_raw_size;
797 stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, size);
798 if (! stash->dwarf_line_buffer)
799 return 0;
801 if (! bfd_get_section_contents (abfd, msec,
802 stash->dwarf_line_buffer, 0,
803 size))
804 return 0;
806 /* FIXME: We ought to apply the relocs against this section before
807 we process it.... */
810 table = (struct line_info_table*) bfd_alloc (abfd,
811 sizeof (struct line_info_table));
812 table->abfd = abfd;
813 table->comp_dir = unit->comp_dir;
815 table->num_files = 0;
816 table->files = NULL;
818 table->num_dirs = 0;
819 table->dirs = NULL;
821 table->files = NULL;
822 table->last_line = NULL;
824 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
826 /* read in the prologue */
827 lh.total_length = read_4_bytes (abfd, line_ptr);
828 line_ptr += 4;
829 line_end = line_ptr + lh.total_length;
830 lh.version = read_2_bytes (abfd, line_ptr);
831 line_ptr += 2;
832 lh.prologue_length = read_4_bytes (abfd, line_ptr);
833 line_ptr += 4;
834 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
835 line_ptr += 1;
836 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
837 line_ptr += 1;
838 lh.line_base = read_1_signed_byte (abfd, line_ptr);
839 line_ptr += 1;
840 lh.line_range = read_1_byte (abfd, line_ptr);
841 line_ptr += 1;
842 lh.opcode_base = read_1_byte (abfd, line_ptr);
843 line_ptr += 1;
844 lh.standard_opcode_lengths = (unsigned char *)
845 bfd_alloc (abfd, lh.opcode_base * sizeof (unsigned char));
847 lh.standard_opcode_lengths[0] = 1;
848 for (i = 1; i < lh.opcode_base; ++i)
850 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
851 line_ptr += 1;
854 /* Read directory table */
855 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
857 line_ptr += bytes_read;
858 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
860 table->dirs = (char **)
861 bfd_realloc (table->dirs,
862 (table->num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
863 if (! table->dirs)
864 return 0;
866 table->dirs[table->num_dirs++] = cur_dir;
868 line_ptr += bytes_read;
870 /* Read file name table */
871 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
873 line_ptr += bytes_read;
874 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
876 table->files = (struct fileinfo *)
877 bfd_realloc (table->files,
878 (table->num_files + FILE_ALLOC_CHUNK)
879 * sizeof (struct fileinfo));
880 if (! table->files)
881 return 0;
883 table->files[table->num_files].name = cur_file;
884 table->files[table->num_files].dir =
885 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
886 line_ptr += bytes_read;
887 table->files[table->num_files].time =
888 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
889 line_ptr += bytes_read;
890 table->files[table->num_files].size =
891 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
892 line_ptr += bytes_read;
893 table->num_files++;
895 line_ptr += bytes_read;
897 /* Read the statement sequences until there's nothing left. */
898 while (line_ptr < line_end)
900 /* state machine registers */
901 bfd_vma address = 0;
902 char* filename = concat_filename (table, 1);
903 unsigned int line = 1;
904 unsigned int column = 0;
905 int is_stmt = lh.default_is_stmt;
906 int basic_block = 0;
907 int end_sequence = 0, need_low_pc = 1;
908 bfd_vma low_pc = 0;
910 /* Decode the table. */
911 while (! end_sequence)
913 op_code = read_1_byte (abfd, line_ptr);
914 line_ptr += 1;
915 switch (op_code)
917 case DW_LNS_extended_op:
918 line_ptr += 1; /* ignore length */
919 extended_op = read_1_byte (abfd, line_ptr);
920 line_ptr += 1;
921 switch (extended_op)
923 case DW_LNE_end_sequence:
924 end_sequence = 1;
925 add_line_info (table, address, filename, line, column,
926 end_sequence);
927 if (need_low_pc)
929 need_low_pc = 0;
930 low_pc = address;
932 arange_add (unit, low_pc, address);
933 break;
934 case DW_LNE_set_address:
935 address = read_address (unit, line_ptr);
936 line_ptr += unit->addr_size;
937 break;
938 case DW_LNE_define_file:
939 cur_file = read_string (abfd, line_ptr, &bytes_read);
940 line_ptr += bytes_read;
941 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
943 table->files = (struct fileinfo *)
944 bfd_realloc (table->files,
945 (table->num_files + FILE_ALLOC_CHUNK)
946 * sizeof (struct fileinfo));
947 if (! table->files)
948 return 0;
950 table->files[table->num_files].name = cur_file;
951 table->files[table->num_files].dir =
952 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
953 line_ptr += bytes_read;
954 table->files[table->num_files].time =
955 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
956 line_ptr += bytes_read;
957 table->files[table->num_files].size =
958 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
959 line_ptr += bytes_read;
960 table->num_files++;
961 break;
962 default:
963 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
964 bfd_set_error (bfd_error_bad_value);
965 return 0;
967 break;
968 case DW_LNS_copy:
969 add_line_info (table, address, filename, line, column, 0);
970 basic_block = 0;
971 if (need_low_pc)
973 need_low_pc = 0;
974 low_pc = address;
976 break;
977 case DW_LNS_advance_pc:
978 address += lh.minimum_instruction_length
979 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
980 line_ptr += bytes_read;
981 break;
982 case DW_LNS_advance_line:
983 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
984 line_ptr += bytes_read;
985 break;
986 case DW_LNS_set_file:
988 unsigned int file;
990 /* The file and directory tables are 0 based, the references
991 are 1 based. */
992 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
993 line_ptr += bytes_read;
994 filename = concat_filename (table, file);
995 break;
997 case DW_LNS_set_column:
998 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
999 line_ptr += bytes_read;
1000 break;
1001 case DW_LNS_negate_stmt:
1002 is_stmt = (!is_stmt);
1003 break;
1004 case DW_LNS_set_basic_block:
1005 basic_block = 1;
1006 break;
1007 case DW_LNS_const_add_pc:
1008 address += lh.minimum_instruction_length
1009 * ((255 - lh.opcode_base) / lh.line_range);
1010 break;
1011 case DW_LNS_fixed_advance_pc:
1012 address += read_2_bytes (abfd, line_ptr);
1013 line_ptr += 2;
1014 break;
1015 default: /* special operand */
1016 adj_opcode = op_code - lh.opcode_base;
1017 address += (adj_opcode / lh.line_range)
1018 * lh.minimum_instruction_length;
1019 line += lh.line_base + (adj_opcode % lh.line_range);
1020 /* append row to matrix using current values */
1021 add_line_info (table, address, filename, line, column, 0);
1022 basic_block = 1;
1023 if (need_low_pc)
1025 need_low_pc = 0;
1026 low_pc = address;
1032 return table;
1036 /* If ADDR is within TABLE set the output parameters and return true,
1037 otherwise return false. The output parameters, FILENAME_PTR and
1038 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1040 static boolean
1041 lookup_address_in_line_info_table (table,
1042 addr,
1043 filename_ptr,
1044 linenumber_ptr)
1045 struct line_info_table* table;
1046 bfd_vma addr;
1047 const char **filename_ptr;
1048 unsigned int *linenumber_ptr;
1050 struct line_info* next_line = table->last_line;
1051 struct line_info* each_line;
1053 if (!next_line)
1054 return false;
1056 each_line = next_line->prev_line;
1058 while (each_line && next_line)
1060 if (!each_line->end_sequence
1061 && addr >= each_line->address && addr < next_line->address)
1063 *filename_ptr = each_line->filename;
1064 *linenumber_ptr = each_line->line;
1065 return true;
1067 next_line = each_line;
1068 each_line = each_line->prev_line;
1071 return false;
1077 /* Function table functions. */
1079 struct funcinfo {
1080 struct funcinfo *prev_func;
1082 char* name;
1083 bfd_vma low;
1084 bfd_vma high;
1088 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
1090 static boolean
1091 lookup_address_in_function_table (table,
1092 addr,
1093 functionname_ptr)
1094 struct funcinfo* table;
1095 bfd_vma addr;
1096 const char **functionname_ptr;
1098 struct funcinfo* each_func;
1100 for (each_func = table;
1101 each_func;
1102 each_func = each_func->prev_func)
1104 if (addr >= each_func->low && addr < each_func->high)
1106 *functionname_ptr = each_func->name;
1107 return true;
1111 return false;
1117 /* DWARF2 Compilation unit functions. */
1120 /* Scan over each die in a comp. unit looking for functions to add
1121 to the function table. */
1123 static boolean
1124 scan_unit_for_functions (unit)
1125 struct comp_unit *unit;
1127 bfd *abfd = unit->abfd;
1128 char *info_ptr = unit->first_child_die_ptr;
1129 int nesting_level = 1;
1131 while (nesting_level)
1133 unsigned int abbrev_number, bytes_read, i;
1134 struct abbrev_info *abbrev;
1135 struct attribute attr;
1136 struct funcinfo *func;
1137 char* name = 0;
1139 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1140 info_ptr += bytes_read;
1142 if (! abbrev_number)
1144 nesting_level--;
1145 continue;
1148 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1149 if (! abbrev)
1151 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
1152 abbrev_number);
1153 bfd_set_error (bfd_error_bad_value);
1154 return false;
1157 if (abbrev->tag == DW_TAG_subprogram)
1159 func = (struct funcinfo*) bfd_zalloc (abfd, sizeof (struct funcinfo));
1160 func->prev_func = unit->function_table;
1161 unit->function_table = func;
1163 else
1164 func = NULL;
1166 for (i = 0; i < abbrev->num_attrs; ++i)
1168 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1170 if (func)
1172 switch (attr.name)
1174 case DW_AT_name:
1176 name = DW_STRING (&attr);
1178 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1179 if (func->name == NULL)
1180 func->name = DW_STRING (&attr);
1181 break;
1183 case DW_AT_MIPS_linkage_name:
1184 func->name = DW_STRING (&attr);
1185 break;
1187 case DW_AT_low_pc:
1188 func->low = DW_ADDR (&attr);
1189 break;
1191 case DW_AT_high_pc:
1192 func->high = DW_ADDR (&attr);
1193 break;
1195 default:
1196 break;
1199 else
1201 switch (attr.name)
1203 case DW_AT_name:
1204 name = DW_STRING (&attr);
1205 break;
1207 default:
1208 break;
1213 if (abbrev->has_children)
1214 nesting_level++;
1217 return true;
1225 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1226 includes the compilation unit header that proceeds the DIE's, but
1227 does not include the length field that preceeds each compilation
1228 unit header. END_PTR points one past the end of this comp unit.
1229 If ABBREV_LENGTH is 0, then the length of the abbreviation offset
1230 is assumed to be four bytes. Otherwise, it it is the size given.
1232 This routine does not read the whole compilation unit; only enough
1233 to get to the line number information for the compilation unit. */
1235 static struct comp_unit *
1236 parse_comp_unit (abfd, info_ptr, end_ptr, abbrev_length)
1237 bfd* abfd;
1238 char* info_ptr;
1239 char* end_ptr;
1240 unsigned int abbrev_length;
1242 struct comp_unit* unit;
1244 unsigned short version;
1245 unsigned int abbrev_offset = 0;
1246 unsigned char addr_size;
1247 struct abbrev_info** abbrevs;
1249 unsigned int abbrev_number, bytes_read, i;
1250 struct abbrev_info *abbrev;
1251 struct attribute attr;
1253 version = read_2_bytes (abfd, info_ptr);
1254 info_ptr += 2;
1255 BFD_ASSERT (abbrev_length == 0
1256 || abbrev_length == 4
1257 || abbrev_length == 8);
1258 if (abbrev_length == 0 || abbrev_length == 4)
1259 abbrev_offset = read_4_bytes (abfd, info_ptr);
1260 else if (abbrev_length == 8)
1261 abbrev_offset = read_8_bytes (abfd, info_ptr);
1262 info_ptr += abbrev_length;
1263 addr_size = read_1_byte (abfd, info_ptr);
1264 info_ptr += 1;
1266 if (version != 2)
1268 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%hu', this reader only handles version 2 information."), version );
1269 bfd_set_error (bfd_error_bad_value);
1270 return 0;
1273 if (addr_size > sizeof (bfd_vma))
1275 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1276 addr_size,
1277 sizeof (bfd_vma));
1278 bfd_set_error (bfd_error_bad_value);
1279 return 0;
1282 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1284 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size );
1285 bfd_set_error (bfd_error_bad_value);
1286 return 0;
1289 /* Read the abbrevs for this compilation unit into a table */
1290 abbrevs = read_abbrevs (abfd, abbrev_offset);
1291 if (! abbrevs)
1292 return 0;
1294 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1295 info_ptr += bytes_read;
1296 if (! abbrev_number)
1298 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %d."),
1299 abbrev_number);
1300 bfd_set_error (bfd_error_bad_value);
1301 return 0;
1304 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1305 if (! abbrev)
1307 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
1308 abbrev_number);
1309 bfd_set_error (bfd_error_bad_value);
1310 return 0;
1313 unit = (struct comp_unit*) bfd_zalloc (abfd, sizeof (struct comp_unit));
1314 unit->abfd = abfd;
1315 unit->addr_size = addr_size;
1316 unit->abbrevs = abbrevs;
1317 unit->end_ptr = end_ptr;
1319 for (i = 0; i < abbrev->num_attrs; ++i)
1321 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1323 /* Store the data if it is of an attribute we want to keep in a
1324 partial symbol table. */
1325 switch (attr.name)
1327 case DW_AT_stmt_list:
1328 unit->stmtlist = 1;
1329 unit->line_offset = DW_UNSND (&attr);
1330 break;
1332 case DW_AT_name:
1333 unit->name = DW_STRING (&attr);
1334 break;
1336 case DW_AT_low_pc:
1337 unit->arange.low = DW_ADDR (&attr);
1338 break;
1340 case DW_AT_high_pc:
1341 unit->arange.high = DW_ADDR (&attr);
1342 break;
1344 case DW_AT_comp_dir:
1346 char* comp_dir = DW_STRING (&attr);
1347 if (comp_dir)
1349 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1350 directory, get rid of it. */
1351 char *cp = (char*) strchr (comp_dir, ':');
1353 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1354 comp_dir = cp + 1;
1356 unit->comp_dir = comp_dir;
1357 break;
1360 default:
1361 break;
1365 unit->first_child_die_ptr = info_ptr;
1366 return unit;
1373 /* Return true if UNIT contains the address given by ADDR. */
1375 static boolean
1376 comp_unit_contains_address (unit, addr)
1377 struct comp_unit* unit;
1378 bfd_vma addr;
1380 struct arange *arange;
1382 if (unit->error)
1383 return 0;
1385 arange = &unit->arange;
1388 if (addr >= arange->low && addr < arange->high)
1389 return 1;
1390 arange = arange->next;
1392 while (arange);
1393 return 0;
1397 /* If UNIT contains ADDR, set the output parameters to the values for
1398 the line containing ADDR. The output parameters, FILENAME_PTR,
1399 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1400 to be filled in.
1402 Return true of UNIT contains ADDR, and no errors were encountered;
1403 false otherwise. */
1405 static boolean
1406 comp_unit_find_nearest_line (unit, addr,
1407 filename_ptr, functionname_ptr, linenumber_ptr)
1408 struct comp_unit* unit;
1409 bfd_vma addr;
1410 const char **filename_ptr;
1411 const char **functionname_ptr;
1412 unsigned int *linenumber_ptr;
1414 boolean line_p;
1415 boolean func_p;
1417 if (unit->error)
1418 return false;
1420 if (! unit->line_table)
1422 if (! unit->stmtlist)
1424 unit->error = 1;
1425 return false;
1428 unit->line_table = decode_line_info (unit);
1430 if (! unit->line_table)
1432 unit->error = 1;
1433 return false;
1436 if (! scan_unit_for_functions (unit))
1438 unit->error = 1;
1439 return false;
1443 line_p = lookup_address_in_line_info_table (unit->line_table,
1444 addr,
1445 filename_ptr,
1446 linenumber_ptr);
1447 func_p = lookup_address_in_function_table (unit->function_table,
1448 addr,
1449 functionname_ptr);
1450 return line_p || func_p;
1453 /* The DWARF2 version of find_nearest line. Return true if the line
1454 is found without error. ADDR_SIZE is the number of bytes in the
1455 initial .debug_info length field and in the abbreviation offset.
1456 You may use zero to indicate that the default value should be
1457 used. */
1459 boolean
1460 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1461 filename_ptr, functionname_ptr,
1462 linenumber_ptr,
1463 addr_size)
1464 bfd *abfd;
1465 asection *section;
1466 asymbol **symbols ATTRIBUTE_UNUSED;
1467 bfd_vma offset;
1468 const char **filename_ptr;
1469 const char **functionname_ptr;
1470 unsigned int *linenumber_ptr;
1471 unsigned int addr_size;
1473 /* Read each compilation unit from the section .debug_info, and check
1474 to see if it contains the address we are searching for. If yes,
1475 lookup the address, and return the line number info. If no, go
1476 on to the next compilation unit.
1478 We keep a list of all the previously read compilation units, and
1479 a pointer to the next un-read compilation unit. Check the
1480 previously read units before reading more.
1483 struct dwarf2_debug *stash = elf_tdata (abfd)->dwarf2_find_line_info;
1485 /* What address are we looking for? */
1486 bfd_vma addr = offset + section->vma;
1488 struct comp_unit* each;
1490 *filename_ptr = NULL;
1491 *functionname_ptr = NULL;
1492 *linenumber_ptr = 0;
1494 /* The DWARF2 spec says that the initial length field, and the
1495 offset of the abbreviation table, should both be 4-byte values.
1496 However, some compilers do things differently. */
1497 if (addr_size == 0)
1498 addr_size = 4;
1499 BFD_ASSERT (addr_size == 4 || addr_size == 8);
1501 if (! stash)
1503 asection *msec;
1504 unsigned long size;
1506 stash = elf_tdata (abfd)->dwarf2_find_line_info =
1507 (struct dwarf2_debug*) bfd_zalloc (abfd, sizeof (struct dwarf2_debug));
1509 if (! stash)
1510 return false;
1512 msec = bfd_get_section_by_name (abfd, ".debug_info");
1513 if (! msec)
1515 /* No dwarf2 info. Note that at this point the stash
1516 has been allocated, but contains zeros, this lets
1517 future calls to this function fail quicker. */
1518 return false;
1521 size = msec->_raw_size;
1522 if (size == 0)
1523 return false;
1525 stash->info_ptr = (char *) bfd_alloc (abfd, size);
1527 if (! stash->info_ptr)
1528 return false;
1530 if (! bfd_get_section_contents (abfd, msec, stash->info_ptr, 0, size))
1532 stash->info_ptr = 0;
1533 return false;
1536 stash->info_ptr_end = stash->info_ptr + size;
1538 /* FIXME: There is a problem with the contents of the
1539 .debug_info section. The 'low' and 'high' addresses of the
1540 comp_units are computed by relocs against symbols in the
1541 .text segment. We need these addresses in order to determine
1542 the nearest line number, and so we have to resolve the
1543 relocs. There is a similar problem when the .debug_line
1544 section is processed as well (e.g., there may be relocs
1545 against the operand of the DW_LNE_set_address operator).
1547 Unfortunately getting hold of the reloc information is hard...
1549 For now, this means that disassembling object files (as
1550 opposed to fully executables) does not always work as well as
1551 we would like. */
1554 /* A null info_ptr indicates that there is no dwarf2 info
1555 (or that an error occured while setting up the stash). */
1557 if (! stash->info_ptr)
1558 return false;
1560 /* Check the previously read comp. units first. */
1562 for (each = stash->all_comp_units; each; each = each->next_unit)
1563 if (comp_unit_contains_address (each, addr))
1564 return comp_unit_find_nearest_line (each, addr, filename_ptr,
1565 functionname_ptr, linenumber_ptr);
1567 /* Read each remaining comp. units checking each as they are read. */
1568 while (stash->info_ptr < stash->info_ptr_end)
1570 struct comp_unit* each;
1571 bfd_vma length;
1572 boolean found;
1574 if (addr_size == 4)
1575 length = read_4_bytes (abfd, stash->info_ptr);
1576 else
1577 length = read_8_bytes (abfd, stash->info_ptr);
1578 stash->info_ptr += addr_size;
1580 if (length > 0)
1582 each = parse_comp_unit (abfd, stash->info_ptr,
1583 stash->info_ptr + length,
1584 addr_size);
1585 stash->info_ptr += length;
1587 if (each)
1589 each->next_unit = stash->all_comp_units;
1590 stash->all_comp_units = each;
1592 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1593 compilation units. If we don't have them (i.e.,
1594 unit->high == 0), we need to consult the line info
1595 table to see if a compilation unit contains the given
1596 address. */
1597 if (each->arange.high > 0)
1599 if (comp_unit_contains_address (each, addr))
1600 return comp_unit_find_nearest_line (each, addr,
1601 filename_ptr,
1602 functionname_ptr,
1603 linenumber_ptr);
1605 else
1607 found = comp_unit_find_nearest_line (each, addr,
1608 filename_ptr,
1609 functionname_ptr,
1610 linenumber_ptr);
1611 if (found)
1612 return true;
1618 return false;
1621 /* end of file */