1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
46 #include "gdb_string.h"
47 #include "gdb_assert.h"
48 #include <sys/types.h>
50 #ifndef DWARF2_REG_TO_REGNUM
51 #define DWARF2_REG_TO_REGNUM(REG) (REG)
55 /* .debug_info header for a compilation unit
56 Because of alignment constraints, this structure has padding and cannot
57 be mapped directly onto the beginning of the .debug_info section. */
58 typedef struct comp_unit_header
60 unsigned int length
; /* length of the .debug_info
62 unsigned short version
; /* version number -- 2 for DWARF
64 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
65 unsigned char addr_size
; /* byte size of an address -- 4 */
68 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
71 /* .debug_pubnames header
72 Because of alignment constraints, this structure has padding and cannot
73 be mapped directly onto the beginning of the .debug_info section. */
74 typedef struct pubnames_header
76 unsigned int length
; /* length of the .debug_pubnames
78 unsigned char version
; /* version number -- 2 for DWARF
80 unsigned int info_offset
; /* offset into .debug_info section */
81 unsigned int info_size
; /* byte size of .debug_info section
85 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
87 /* .debug_pubnames header
88 Because of alignment constraints, this structure has padding and cannot
89 be mapped directly onto the beginning of the .debug_info section. */
90 typedef struct aranges_header
92 unsigned int length
; /* byte len of the .debug_aranges
94 unsigned short version
; /* version number -- 2 for DWARF
96 unsigned int info_offset
; /* offset into .debug_info section */
97 unsigned char addr_size
; /* byte size of an address */
98 unsigned char seg_size
; /* byte size of segment descriptor */
101 #define _ACTUAL_ARANGES_HEADER_SIZE 12
103 /* .debug_line statement program prologue
104 Because of alignment constraints, this structure has padding and cannot
105 be mapped directly onto the beginning of the .debug_info section. */
106 typedef struct statement_prologue
108 unsigned int total_length
; /* byte length of the statement
110 unsigned short version
; /* version number -- 2 for DWARF
112 unsigned int prologue_length
; /* # bytes between prologue &
114 unsigned char minimum_instruction_length
; /* byte size of
116 unsigned char default_is_stmt
; /* initial value of is_stmt
119 unsigned char line_range
;
120 unsigned char opcode_base
; /* number assigned to first special
122 unsigned char *standard_opcode_lengths
;
126 /* offsets and sizes of debugging sections */
128 static file_ptr dwarf_info_offset
;
129 static file_ptr dwarf_abbrev_offset
;
130 static file_ptr dwarf_line_offset
;
131 static file_ptr dwarf_pubnames_offset
;
132 static file_ptr dwarf_aranges_offset
;
133 static file_ptr dwarf_loc_offset
;
134 static file_ptr dwarf_macinfo_offset
;
135 static file_ptr dwarf_str_offset
;
136 file_ptr dwarf_frame_offset
;
137 file_ptr dwarf_eh_frame_offset
;
139 static unsigned int dwarf_info_size
;
140 static unsigned int dwarf_abbrev_size
;
141 static unsigned int dwarf_line_size
;
142 static unsigned int dwarf_pubnames_size
;
143 static unsigned int dwarf_aranges_size
;
144 static unsigned int dwarf_loc_size
;
145 static unsigned int dwarf_macinfo_size
;
146 static unsigned int dwarf_str_size
;
147 unsigned int dwarf_frame_size
;
148 unsigned int dwarf_eh_frame_size
;
150 /* names of the debugging sections */
152 #define INFO_SECTION ".debug_info"
153 #define ABBREV_SECTION ".debug_abbrev"
154 #define LINE_SECTION ".debug_line"
155 #define PUBNAMES_SECTION ".debug_pubnames"
156 #define ARANGES_SECTION ".debug_aranges"
157 #define LOC_SECTION ".debug_loc"
158 #define MACINFO_SECTION ".debug_macinfo"
159 #define STR_SECTION ".debug_str"
160 #define FRAME_SECTION ".debug_frame"
161 #define EH_FRAME_SECTION ".eh_frame"
163 /* local data types */
165 /* The data in a compilation unit header, after target2host
166 translation, looks like this. */
167 struct comp_unit_head
169 unsigned long length
;
171 unsigned int abbrev_offset
;
172 unsigned char addr_size
;
173 unsigned char signed_addr_p
;
174 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
175 unsigned int initial_length_size
; /* size of the length field; either
179 /* The line number information for a compilation unit (found in the
180 .debug_line section) begins with a "statement program header",
181 which contains the following information. */
184 unsigned int total_length
;
185 unsigned short version
;
186 unsigned int header_length
;
187 unsigned char minimum_instruction_length
;
188 unsigned char default_is_stmt
;
190 unsigned char line_range
;
191 unsigned char opcode_base
;
193 /* standard_opcode_lengths[i] is the number of operands for the
194 standard opcode whose value is i. This means that
195 standard_opcode_lengths[0] is unused, and the last meaningful
196 element is standard_opcode_lengths[opcode_base - 1]. */
197 unsigned char *standard_opcode_lengths
;
199 /* The include_directories table. NOTE! These strings are not
200 allocated with xmalloc; instead, they are pointers into
201 debug_line_buffer. If you try to free them, `free' will get
203 unsigned int num_include_dirs
, include_dirs_size
;
206 /* The file_names table. NOTE! These strings are not allocated
207 with xmalloc; instead, they are pointers into debug_line_buffer.
208 Don't try to free them directly. */
209 unsigned int num_file_names
, file_names_size
;
213 unsigned int dir_index
;
214 unsigned int mod_time
;
218 /* The start and end of the statement program following this
219 header. These point into dwarf_line_buffer. */
220 char *statement_program_start
, *statement_program_end
;
223 /* When we construct a partial symbol table entry we only
224 need this much information. */
225 struct partial_die_info
228 unsigned char has_children
;
229 unsigned char is_external
;
230 unsigned char is_declaration
;
231 unsigned char has_type
;
238 struct dwarf_block
*locdesc
;
239 unsigned int language
;
243 /* This data structure holds the information of an abbrev. */
246 unsigned int number
; /* number identifying abbrev */
247 enum dwarf_tag tag
; /* dwarf tag */
248 int has_children
; /* boolean */
249 unsigned int num_attrs
; /* number of attributes */
250 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
251 struct abbrev_info
*next
; /* next in chain */
256 enum dwarf_attribute name
;
257 enum dwarf_form form
;
260 /* This data structure holds a complete die structure. */
263 enum dwarf_tag tag
; /* Tag indicating type of die */
264 unsigned short has_children
; /* Does the die have children */
265 unsigned int abbrev
; /* Abbrev number */
266 unsigned int offset
; /* Offset in .debug_info section */
267 unsigned int num_attrs
; /* Number of attributes */
268 struct attribute
*attrs
; /* An array of attributes */
269 struct die_info
*next_ref
; /* Next die in ref hash table */
270 struct die_info
*next
; /* Next die in linked list */
271 struct type
*type
; /* Cached type information */
274 /* Attributes have a name and a value */
277 enum dwarf_attribute name
;
278 enum dwarf_form form
;
282 struct dwarf_block
*blk
;
290 struct function_range
293 CORE_ADDR lowpc
, highpc
;
295 struct function_range
*next
;
298 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
300 /* Get at parts of an attribute structure */
302 #define DW_STRING(attr) ((attr)->u.str)
303 #define DW_UNSND(attr) ((attr)->u.unsnd)
304 #define DW_BLOCK(attr) ((attr)->u.blk)
305 #define DW_SND(attr) ((attr)->u.snd)
306 #define DW_ADDR(attr) ((attr)->u.addr)
308 /* Blocks are a bunch of untyped bytes. */
315 /* We only hold one compilation unit's abbrevs in
316 memory at any one time. */
317 #ifndef ABBREV_HASH_SIZE
318 #define ABBREV_HASH_SIZE 121
320 #ifndef ATTR_ALLOC_CHUNK
321 #define ATTR_ALLOC_CHUNK 4
324 static struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
326 /* A hash table of die offsets for following references. */
327 #ifndef REF_HASH_SIZE
328 #define REF_HASH_SIZE 1021
331 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
333 /* Obstack for allocating temporary storage used during symbol reading. */
334 static struct obstack dwarf2_tmp_obstack
;
336 /* Offset to the first byte of the current compilation unit header,
337 for resolving relative reference dies. */
338 static unsigned int cu_header_offset
;
340 /* Allocate fields for structs, unions and enums in this size. */
341 #ifndef DW_FIELD_ALLOC_CHUNK
342 #define DW_FIELD_ALLOC_CHUNK 4
345 /* The language we are debugging. */
346 static enum language cu_language
;
347 static const struct language_defn
*cu_language_defn
;
349 /* Actually data from the sections. */
350 static char *dwarf_info_buffer
;
351 static char *dwarf_abbrev_buffer
;
352 static char *dwarf_line_buffer
;
353 static char *dwarf_str_buffer
;
354 static char *dwarf_macinfo_buffer
;
356 /* A zeroed version of a partial die for initialization purposes. */
357 static struct partial_die_info zeroed_partial_die
;
359 /* The generic symbol table building routines have separate lists for
360 file scope symbols and all all other scopes (local scopes). So
361 we need to select the right one to pass to add_symbol_to_list().
362 We do it by keeping a pointer to the correct list in list_in_scope.
364 FIXME: The original dwarf code just treated the file scope as the first
365 local scope, and all other local scopes as nested local scopes, and worked
366 fine. Check to see if we really need to distinguish these
368 static struct pending
**list_in_scope
= &file_symbols
;
370 /* FIXME: decode_locdesc sets these variables to describe the location
371 to the caller. These ought to be a structure or something. If
372 none of the flags are set, the object lives at the address returned
373 by decode_locdesc. */
375 static int optimized_out
; /* No ops in location in expression,
376 so object was optimized out. */
377 static int isreg
; /* Object lives in register.
378 decode_locdesc's return value is
379 the register number. */
380 static int offreg
; /* Object's address is the sum of the
381 register specified by basereg, plus
382 the offset returned. */
383 static int basereg
; /* See `offreg'. */
384 static int isderef
; /* Value described by flags above is
385 the address of a pointer to the object. */
386 static int islocal
; /* Variable is at the returned offset
387 from the frame start, but there's
388 no identified frame pointer for
389 this function, so we can't say
390 which register it's relative to;
393 /* DW_AT_frame_base values for the current function.
394 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
395 contains the register number for the frame register.
396 frame_base_offset is the offset from the frame register to the
397 virtual stack frame. */
398 static int frame_base_reg
;
399 static CORE_ADDR frame_base_offset
;
401 /* This value is added to each symbol value. FIXME: Generalize to
402 the section_offsets structure used by dbxread (once this is done,
403 pass the appropriate section number to end_symtab). */
404 static CORE_ADDR baseaddr
; /* Add to each symbol value */
406 /* We put a pointer to this structure in the read_symtab_private field
408 The complete dwarf information for an objfile is kept in the
409 psymbol_obstack, so that absolute die references can be handled.
410 Most of the information in this structure is related to an entire
411 object file and could be passed via the sym_private field of the objfile.
412 It is however conceivable that dwarf2 might not be the only type
413 of symbols read from an object file. */
417 /* Pointer to start of dwarf info buffer for the objfile. */
419 char *dwarf_info_buffer
;
421 /* Offset in dwarf_info_buffer for this compilation unit. */
423 unsigned long dwarf_info_offset
;
425 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
427 char *dwarf_abbrev_buffer
;
429 /* Size of dwarf abbreviation section for the objfile. */
431 unsigned int dwarf_abbrev_size
;
433 /* Pointer to start of dwarf line buffer for the objfile. */
435 char *dwarf_line_buffer
;
437 /* Size of dwarf_line_buffer, in bytes. */
439 unsigned int dwarf_line_size
;
441 /* Pointer to start of dwarf string buffer for the objfile. */
443 char *dwarf_str_buffer
;
445 /* Size of dwarf string section for the objfile. */
447 unsigned int dwarf_str_size
;
449 /* Pointer to start of dwarf macro buffer for the objfile. */
451 char *dwarf_macinfo_buffer
;
453 /* Size of dwarf macinfo section for the objfile. */
455 unsigned int dwarf_macinfo_size
;
459 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
460 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
461 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
462 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
463 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
464 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
465 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
466 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
467 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
468 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
469 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
471 /* Maintain an array of referenced fundamental types for the current
472 compilation unit being read. For DWARF version 1, we have to construct
473 the fundamental types on the fly, since no information about the
474 fundamental types is supplied. Each such fundamental type is created by
475 calling a language dependent routine to create the type, and then a
476 pointer to that type is then placed in the array at the index specified
477 by it's FT_<TYPENAME> value. The array has a fixed size set by the
478 FT_NUM_MEMBERS compile time constant, which is the number of predefined
479 fundamental types gdb knows how to construct. */
480 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
482 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
483 but this would require a corresponding change in unpack_field_as_long
485 static int bits_per_byte
= 8;
487 /* The routines that read and process dies for a C struct or C++ class
488 pass lists of data member fields and lists of member function fields
489 in an instance of a field_info structure, as defined below. */
492 /* List of data member and baseclasses fields. */
495 struct nextfield
*next
;
502 /* Number of fields. */
505 /* Number of baseclasses. */
508 /* Set if the accesibility of one of the fields is not public. */
509 int non_public_fields
;
511 /* Member function fields array, entries are allocated in the order they
512 are encountered in the object file. */
515 struct nextfnfield
*next
;
516 struct fn_field fnfield
;
520 /* Member function fieldlist array, contains name of possibly overloaded
521 member function, number of overloaded member functions and a pointer
522 to the head of the member function field chain. */
527 struct nextfnfield
*head
;
531 /* Number of entries in the fnfieldlists array. */
535 /* Various complaints about symbol reading that don't abort the process */
537 static struct complaint dwarf2_const_ignored
=
539 "type qualifier 'const' ignored", 0, 0
541 static struct complaint dwarf2_volatile_ignored
=
543 "type qualifier 'volatile' ignored", 0, 0
545 static struct complaint dwarf2_non_const_array_bound_ignored
=
547 "non-constant array bounds form '%s' ignored", 0, 0
549 static struct complaint dwarf2_missing_line_number_section
=
551 "missing .debug_line section", 0, 0
553 static struct complaint dwarf2_statement_list_fits_in_line_number_section
=
555 "statement list doesn't fit in .debug_line section", 0, 0
557 static struct complaint dwarf2_mangled_line_number_section
=
559 "mangled .debug_line section", 0, 0
561 static struct complaint dwarf2_unsupported_die_ref_attr
=
563 "unsupported die ref attribute form: '%s'", 0, 0
565 static struct complaint dwarf2_unsupported_stack_op
=
567 "unsupported stack op: '%s'", 0, 0
569 static struct complaint dwarf2_complex_location_expr
=
571 "location expression too complex", 0, 0
573 static struct complaint dwarf2_unsupported_tag
=
575 "unsupported tag: '%s'", 0, 0
577 static struct complaint dwarf2_unsupported_at_encoding
=
579 "unsupported DW_AT_encoding: '%s'", 0, 0
581 static struct complaint dwarf2_unsupported_at_frame_base
=
583 "unsupported DW_AT_frame_base for function '%s'", 0, 0
585 static struct complaint dwarf2_unexpected_tag
=
587 "unexepected tag in read_type_die: '%s'", 0, 0
589 static struct complaint dwarf2_missing_at_frame_base
=
591 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
593 static struct complaint dwarf2_bad_static_member_name
=
595 "unrecognized static data member name '%s'", 0, 0
597 static struct complaint dwarf2_unsupported_accessibility
=
599 "unsupported accessibility %d", 0, 0
601 static struct complaint dwarf2_bad_member_name_complaint
=
603 "cannot extract member name from '%s'", 0, 0
605 static struct complaint dwarf2_missing_member_fn_type_complaint
=
607 "member function type missing for '%s'", 0, 0
609 static struct complaint dwarf2_vtbl_not_found_complaint
=
611 "virtual function table pointer not found when defining class '%s'", 0, 0
613 static struct complaint dwarf2_absolute_sibling_complaint
=
615 "ignoring absolute DW_AT_sibling", 0, 0
617 static struct complaint dwarf2_const_value_length_mismatch
=
619 "const value length mismatch for '%s', got %d, expected %d", 0, 0
621 static struct complaint dwarf2_unsupported_const_value_attr
=
623 "unsupported const value attribute form: '%s'", 0, 0
625 static struct complaint dwarf2_misplaced_line_number
=
627 "misplaced first line number at 0x%lx for '%s'", 0, 0
629 static struct complaint dwarf2_line_header_too_long
=
631 "line number info header doesn't fit in `.debug_line' section", 0, 0
633 static struct complaint dwarf2_missing_macinfo_section
=
635 "missing .debug_macinfo section", 0, 0
637 static struct complaint dwarf2_macros_too_long
=
639 "macro info runs off end of `.debug_macinfo' section", 0, 0
641 static struct complaint dwarf2_macros_not_terminated
=
643 "no terminating 0-type entry for macros in `.debug_macinfo' section", 0, 0
645 static struct complaint dwarf2_macro_outside_file
=
647 "debug info gives macro %s outside of any file: %s", 0, 0
649 static struct complaint dwarf2_macro_unmatched_end_file
=
651 "macro debug info has an unmatched `close_file' directive", 0, 0
653 static struct complaint dwarf2_macro_malformed_definition
=
655 "macro debug info contains a malformed macro definition:\n`%s'", 0, 0
657 static struct complaint dwarf2_macro_spaces_in_definition
=
659 "macro definition contains spaces in formal argument list:\n`%s'", 0, 0
662 /* local function prototypes */
664 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
667 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
670 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
672 static char *scan_partial_symbols (char *, struct objfile
*,
673 CORE_ADDR
*, CORE_ADDR
*,
674 const struct comp_unit_head
*);
676 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
677 const struct comp_unit_head
*);
679 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
681 static void psymtab_to_symtab_1 (struct partial_symtab
*);
683 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
685 static void dwarf2_read_abbrevs (bfd
*, unsigned int);
687 static void dwarf2_empty_abbrev_table (PTR
);
689 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int);
691 static char *read_partial_die (struct partial_die_info
*,
693 const struct comp_unit_head
*);
695 static char *read_full_die (struct die_info
**, bfd
*, char *,
696 const struct comp_unit_head
*);
698 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
699 bfd
*, char *, const struct comp_unit_head
*);
701 static char *read_attribute_value (struct attribute
*, unsigned,
702 bfd
*, char *, const struct comp_unit_head
*);
704 static unsigned int read_1_byte (bfd
*, char *);
706 static int read_1_signed_byte (bfd
*, char *);
708 static unsigned int read_2_bytes (bfd
*, char *);
710 static unsigned int read_4_bytes (bfd
*, char *);
712 static unsigned long read_8_bytes (bfd
*, char *);
714 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
717 static LONGEST
read_initial_length (bfd
*, char *,
718 struct comp_unit_head
*, int *bytes_read
);
720 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
723 static char *read_n_bytes (bfd
*, char *, unsigned int);
725 static char *read_string (bfd
*, char *, unsigned int *);
727 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
730 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
732 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
734 static void set_cu_language (unsigned int);
736 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
738 static int die_is_declaration (struct die_info
*);
740 static void free_line_header (struct line_header
*lh
);
742 static struct line_header
*(dwarf_decode_line_header
743 (unsigned int offset
,
745 const struct comp_unit_head
*cu_header
));
747 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
748 const struct comp_unit_head
*);
750 static void dwarf2_start_subfile (char *, char *);
752 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
753 struct objfile
*, const struct comp_unit_head
*);
755 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
756 struct objfile
*, const struct comp_unit_head
*);
758 static void dwarf2_const_value_data (struct attribute
*attr
,
762 static struct type
*die_type (struct die_info
*, struct objfile
*,
763 const struct comp_unit_head
*);
765 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
766 const struct comp_unit_head
*);
769 static struct type
*type_at_offset (unsigned int, struct objfile
*);
772 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
773 const struct comp_unit_head
*);
775 static void read_type_die (struct die_info
*, struct objfile
*,
776 const struct comp_unit_head
*);
778 static void read_typedef (struct die_info
*, struct objfile
*,
779 const struct comp_unit_head
*);
781 static void read_base_type (struct die_info
*, struct objfile
*);
783 static void read_file_scope (struct die_info
*, struct objfile
*,
784 const struct comp_unit_head
*);
786 static void read_func_scope (struct die_info
*, struct objfile
*,
787 const struct comp_unit_head
*);
789 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
790 const struct comp_unit_head
*);
792 static int dwarf2_get_pc_bounds (struct die_info
*,
793 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
795 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
796 struct objfile
*, const struct comp_unit_head
*);
798 static void dwarf2_attach_fields_to_type (struct field_info
*,
799 struct type
*, struct objfile
*);
801 static void dwarf2_add_member_fn (struct field_info
*,
802 struct die_info
*, struct objfile
*objfile
,
803 const struct comp_unit_head
*);
805 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
806 struct type
*, struct objfile
*);
808 static void read_structure_scope (struct die_info
*, struct objfile
*,
809 const struct comp_unit_head
*);
811 static void read_common_block (struct die_info
*, struct objfile
*,
812 const struct comp_unit_head
*);
814 static void read_enumeration (struct die_info
*, struct objfile
*,
815 const struct comp_unit_head
*);
817 static struct type
*dwarf_base_type (int, int, struct objfile
*);
819 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
820 const struct comp_unit_head
*);
822 static void read_array_type (struct die_info
*, struct objfile
*,
823 const struct comp_unit_head
*);
825 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
826 const struct comp_unit_head
*);
828 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
829 const struct comp_unit_head
*);
831 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
832 const struct comp_unit_head
*);
834 static void read_tag_const_type (struct die_info
*, struct objfile
*,
835 const struct comp_unit_head
*);
837 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
838 const struct comp_unit_head
*);
840 static void read_tag_string_type (struct die_info
*, struct objfile
*);
842 static void read_subroutine_type (struct die_info
*, struct objfile
*,
843 const struct comp_unit_head
*);
845 static struct die_info
*read_comp_unit (char *, bfd
*,
846 const struct comp_unit_head
*);
848 static void free_die_list (struct die_info
*);
850 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
852 static void process_die (struct die_info
*, struct objfile
*,
853 const struct comp_unit_head
*);
855 static char *dwarf2_linkage_name (struct die_info
*);
857 static char *dwarf_tag_name (unsigned int);
859 static char *dwarf_attr_name (unsigned int);
861 static char *dwarf_form_name (unsigned int);
863 static char *dwarf_stack_op_name (unsigned int);
865 static char *dwarf_bool_name (unsigned int);
867 static char *dwarf_type_encoding_name (unsigned int);
870 static char *dwarf_cfi_name (unsigned int);
872 struct die_info
*copy_die (struct die_info
*);
875 static struct die_info
*sibling_die (struct die_info
*);
877 static void dump_die (struct die_info
*);
879 static void dump_die_list (struct die_info
*);
881 static void store_in_ref_table (unsigned int, struct die_info
*);
883 static void dwarf2_empty_hash_tables (void);
885 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
887 static struct die_info
*follow_die_ref (unsigned int);
889 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
891 /* memory allocation interface */
893 static void dwarf2_free_tmp_obstack (PTR
);
895 static struct dwarf_block
*dwarf_alloc_block (void);
897 static struct abbrev_info
*dwarf_alloc_abbrev (void);
899 static struct die_info
*dwarf_alloc_die (void);
901 static void initialize_cu_func_list (void);
903 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
905 static void dwarf_decode_macros (struct line_header
*, unsigned int,
906 char *, bfd
*, const struct comp_unit_head
*,
909 /* Try to locate the sections we need for DWARF 2 debugging
910 information and return true if we have enough to do something. */
913 dwarf2_has_info (bfd
*abfd
)
915 dwarf_info_offset
= 0;
916 dwarf_abbrev_offset
= 0;
917 dwarf_line_offset
= 0;
918 dwarf_str_offset
= 0;
919 dwarf_macinfo_offset
= 0;
920 dwarf_frame_offset
= 0;
921 dwarf_eh_frame_offset
= 0;
922 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
923 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
933 /* This function is mapped across the sections and remembers the
934 offset and size of each of the debugging sections we are interested
938 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
940 if (STREQ (sectp
->name
, INFO_SECTION
))
942 dwarf_info_offset
= sectp
->filepos
;
943 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
945 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
947 dwarf_abbrev_offset
= sectp
->filepos
;
948 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
950 else if (STREQ (sectp
->name
, LINE_SECTION
))
952 dwarf_line_offset
= sectp
->filepos
;
953 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
955 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
957 dwarf_pubnames_offset
= sectp
->filepos
;
958 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
960 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
962 dwarf_aranges_offset
= sectp
->filepos
;
963 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
965 else if (STREQ (sectp
->name
, LOC_SECTION
))
967 dwarf_loc_offset
= sectp
->filepos
;
968 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
970 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
972 dwarf_macinfo_offset
= sectp
->filepos
;
973 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
975 else if (STREQ (sectp
->name
, STR_SECTION
))
977 dwarf_str_offset
= sectp
->filepos
;
978 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
980 else if (STREQ (sectp
->name
, FRAME_SECTION
))
982 dwarf_frame_offset
= sectp
->filepos
;
983 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
985 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
987 dwarf_eh_frame_offset
= sectp
->filepos
;
988 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
992 /* Build a partial symbol table. */
995 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
998 /* We definitely need the .debug_info and .debug_abbrev sections */
1000 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1003 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1004 dwarf_abbrev_offset
,
1006 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1010 if (dwarf_str_offset
)
1011 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1015 dwarf_str_buffer
= NULL
;
1017 if (dwarf_macinfo_offset
)
1018 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1019 dwarf_macinfo_offset
,
1020 dwarf_macinfo_size
);
1022 dwarf_macinfo_buffer
= NULL
;
1025 || (objfile
->global_psymbols
.size
== 0
1026 && objfile
->static_psymbols
.size
== 0))
1028 init_psymbol_list (objfile
, 1024);
1032 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1034 /* Things are significantly easier if we have .debug_aranges and
1035 .debug_pubnames sections */
1037 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1041 /* only test this case for now */
1043 /* In this case we have to work a bit harder */
1044 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1049 /* Build the partial symbol table from the information in the
1050 .debug_pubnames and .debug_aranges sections. */
1053 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1055 bfd
*abfd
= objfile
->obfd
;
1056 char *aranges_buffer
, *pubnames_buffer
;
1057 char *aranges_ptr
, *pubnames_ptr
;
1058 unsigned int entry_length
, version
, info_offset
, info_size
;
1060 pubnames_buffer
= dwarf2_read_section (objfile
,
1061 dwarf_pubnames_offset
,
1062 dwarf_pubnames_size
);
1063 pubnames_ptr
= pubnames_buffer
;
1064 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1066 struct comp_unit_head cu_header
;
1069 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1071 pubnames_ptr
+= bytes_read
;
1072 version
= read_1_byte (abfd
, pubnames_ptr
);
1074 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1076 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1080 aranges_buffer
= dwarf2_read_section (objfile
,
1081 dwarf_aranges_offset
,
1082 dwarf_aranges_size
);
1087 /* Read in the comp unit header information from the debug_info at
1091 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1092 char *info_ptr
, bfd
*abfd
)
1096 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1098 info_ptr
+= bytes_read
;
1099 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1101 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1103 info_ptr
+= bytes_read
;
1104 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1106 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1107 if (signed_addr
< 0)
1108 internal_error (__FILE__
, __LINE__
,
1109 "read_comp_unit_head: dwarf from non elf file");
1110 cu_header
->signed_addr_p
= signed_addr
;
1114 /* Build the partial symbol table by doing a quick pass through the
1115 .debug_info and .debug_abbrev sections. */
1118 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1120 /* Instead of reading this into a big buffer, we should probably use
1121 mmap() on architectures that support it. (FIXME) */
1122 bfd
*abfd
= objfile
->obfd
;
1123 char *info_ptr
, *abbrev_ptr
;
1124 char *beg_of_comp_unit
;
1125 struct partial_die_info comp_unit_die
;
1126 struct partial_symtab
*pst
;
1127 struct cleanup
*back_to
;
1128 CORE_ADDR lowpc
, highpc
;
1130 info_ptr
= dwarf_info_buffer
;
1131 abbrev_ptr
= dwarf_abbrev_buffer
;
1133 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1134 the partial symbol scan, like attribute values.
1136 We could reduce our peak memory consumption during partial symbol
1137 table construction by freeing stuff from this obstack more often
1138 --- say, after processing each compilation unit, or each die ---
1139 but it turns out that this saves almost nothing. For an
1140 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1141 on dwarf2_tmp_obstack. Some investigation showed:
1143 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1144 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1145 all fixed-length values not requiring dynamic allocation.
1147 2) 30% of the attributes used the form DW_FORM_string. For
1148 DW_FORM_string, read_attribute simply hands back a pointer to
1149 the null-terminated string in dwarf_info_buffer, so no dynamic
1150 allocation is needed there either.
1152 3) The remaining 1% of the attributes all used DW_FORM_block1.
1153 75% of those were DW_AT_frame_base location lists for
1154 functions; the rest were DW_AT_location attributes, probably
1155 for the global variables.
1157 Anyway, what this all means is that the memory the dwarf2
1158 reader uses as temporary space reading partial symbols is about
1159 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1161 obstack_init (&dwarf2_tmp_obstack
);
1162 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1164 /* Since the objects we're extracting from dwarf_info_buffer vary in
1165 length, only the individual functions to extract them (like
1166 read_comp_unit_head and read_partial_die) can really know whether
1167 the buffer is large enough to hold another complete object.
1169 At the moment, they don't actually check that. If
1170 dwarf_info_buffer holds just one extra byte after the last
1171 compilation unit's dies, then read_comp_unit_head will happily
1172 read off the end of the buffer. read_partial_die is similarly
1173 casual. Those functions should be fixed.
1175 For this loop condition, simply checking whether there's any data
1176 left at all should be sufficient. */
1177 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1179 struct comp_unit_head cu_header
;
1180 beg_of_comp_unit
= info_ptr
;
1181 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1183 if (cu_header
.version
!= 2)
1185 error ("Dwarf Error: wrong version in compilation unit header.");
1188 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1190 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1191 (long) cu_header
.abbrev_offset
,
1192 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1195 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1196 > dwarf_info_buffer
+ dwarf_info_size
)
1198 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1199 (long) cu_header
.length
,
1200 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1203 /* Read the abbrevs for this compilation unit into a table */
1204 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1205 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1207 /* Read the compilation unit die */
1208 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1211 /* Set the language we're debugging */
1212 set_cu_language (comp_unit_die
.language
);
1214 /* Allocate a new partial symbol table structure */
1215 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1216 comp_unit_die
.name
? comp_unit_die
.name
: "",
1217 comp_unit_die
.lowpc
,
1218 objfile
->global_psymbols
.next
,
1219 objfile
->static_psymbols
.next
);
1221 pst
->read_symtab_private
= (char *)
1222 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1223 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1224 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1225 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1226 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1227 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1228 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1229 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1230 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1231 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1232 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1233 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1234 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1236 /* Store the function that reads in the rest of the symbol table */
1237 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1239 /* Check if comp unit has_children.
1240 If so, read the rest of the partial symbols from this comp unit.
1241 If not, there's no more debug_info for this comp unit. */
1242 if (comp_unit_die
.has_children
)
1244 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1247 /* If the compilation unit didn't have an explicit address range,
1248 then use the information extracted from its child dies. */
1249 if (! comp_unit_die
.has_pc_info
)
1251 comp_unit_die
.lowpc
= lowpc
;
1252 comp_unit_die
.highpc
= highpc
;
1255 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1256 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1258 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1259 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1260 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1261 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1262 sort_pst_symbols (pst
);
1264 /* If there is already a psymtab or symtab for a file of this
1265 name, remove it. (If there is a symtab, more drastic things
1266 also happen.) This happens in VxWorks. */
1267 free_named_symtabs (pst
->filename
);
1269 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1270 + cu_header
.initial_length_size
;
1272 do_cleanups (back_to
);
1275 /* Read in all interesting dies to the end of the compilation unit. */
1278 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1279 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1280 const struct comp_unit_head
*cu_header
)
1282 bfd
*abfd
= objfile
->obfd
;
1283 struct partial_die_info pdi
;
1285 /* This function is called after we've read in the comp_unit_die in
1286 order to read its children. We start the nesting level at 1 since
1287 we have pushed 1 level down in order to read the comp unit's children.
1288 The comp unit itself is at level 0, so we stop reading when we pop
1289 back to that level. */
1291 int nesting_level
= 1;
1293 *lowpc
= ((CORE_ADDR
) -1);
1294 *highpc
= ((CORE_ADDR
) 0);
1296 while (nesting_level
)
1298 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1304 case DW_TAG_subprogram
:
1305 if (pdi
.has_pc_info
)
1307 if (pdi
.lowpc
< *lowpc
)
1311 if (pdi
.highpc
> *highpc
)
1313 *highpc
= pdi
.highpc
;
1315 if ((pdi
.is_external
|| nesting_level
== 1)
1316 && !pdi
.is_declaration
)
1318 add_partial_symbol (&pdi
, objfile
, cu_header
);
1322 case DW_TAG_variable
:
1323 case DW_TAG_typedef
:
1324 case DW_TAG_class_type
:
1325 case DW_TAG_structure_type
:
1326 case DW_TAG_union_type
:
1327 case DW_TAG_enumeration_type
:
1328 if ((pdi
.is_external
|| nesting_level
== 1)
1329 && !pdi
.is_declaration
)
1331 add_partial_symbol (&pdi
, objfile
, cu_header
);
1334 case DW_TAG_enumerator
:
1335 /* File scope enumerators are added to the partial symbol
1337 if (nesting_level
== 2)
1338 add_partial_symbol (&pdi
, objfile
, cu_header
);
1340 case DW_TAG_base_type
:
1341 /* File scope base type definitions are added to the partial
1343 if (nesting_level
== 1)
1344 add_partial_symbol (&pdi
, objfile
, cu_header
);
1351 /* If the die has a sibling, skip to the sibling.
1352 Do not skip enumeration types, we want to record their
1354 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1356 info_ptr
= pdi
.sibling
;
1358 else if (pdi
.has_children
)
1360 /* Die has children, but the optional DW_AT_sibling attribute
1371 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1372 from `maint check'. */
1373 if (*lowpc
== ((CORE_ADDR
) -1))
1379 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1380 const struct comp_unit_head
*cu_header
)
1386 case DW_TAG_subprogram
:
1387 if (pdi
->is_external
)
1389 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1390 mst_text, objfile); */
1391 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1392 VAR_NAMESPACE
, LOC_BLOCK
,
1393 &objfile
->global_psymbols
,
1394 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1398 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1399 mst_file_text, objfile); */
1400 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1401 VAR_NAMESPACE
, LOC_BLOCK
,
1402 &objfile
->static_psymbols
,
1403 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1406 case DW_TAG_variable
:
1407 if (pdi
->is_external
)
1410 Don't enter into the minimal symbol tables as there is
1411 a minimal symbol table entry from the ELF symbols already.
1412 Enter into partial symbol table if it has a location
1413 descriptor or a type.
1414 If the location descriptor is missing, new_symbol will create
1415 a LOC_UNRESOLVED symbol, the address of the variable will then
1416 be determined from the minimal symbol table whenever the variable
1418 The address for the partial symbol table entry is not
1419 used by GDB, but it comes in handy for debugging partial symbol
1423 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1424 if (pdi
->locdesc
|| pdi
->has_type
)
1425 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1426 VAR_NAMESPACE
, LOC_STATIC
,
1427 &objfile
->global_psymbols
,
1428 0, addr
+ baseaddr
, cu_language
, objfile
);
1432 /* Static Variable. Skip symbols without location descriptors. */
1433 if (pdi
->locdesc
== NULL
)
1435 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1436 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1437 mst_file_data, objfile); */
1438 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1439 VAR_NAMESPACE
, LOC_STATIC
,
1440 &objfile
->static_psymbols
,
1441 0, addr
+ baseaddr
, cu_language
, objfile
);
1444 case DW_TAG_typedef
:
1445 case DW_TAG_base_type
:
1446 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1447 VAR_NAMESPACE
, LOC_TYPEDEF
,
1448 &objfile
->static_psymbols
,
1449 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1451 case DW_TAG_class_type
:
1452 case DW_TAG_structure_type
:
1453 case DW_TAG_union_type
:
1454 case DW_TAG_enumeration_type
:
1455 /* Skip aggregate types without children, these are external
1457 if (pdi
->has_children
== 0)
1459 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1460 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1461 &objfile
->static_psymbols
,
1462 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1464 if (cu_language
== language_cplus
)
1466 /* For C++, these implicitly act as typedefs as well. */
1467 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1468 VAR_NAMESPACE
, LOC_TYPEDEF
,
1469 &objfile
->static_psymbols
,
1470 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1473 case DW_TAG_enumerator
:
1474 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1475 VAR_NAMESPACE
, LOC_CONST
,
1476 &objfile
->static_psymbols
,
1477 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1484 /* Expand this partial symbol table into a full symbol table. */
1487 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1489 /* FIXME: This is barely more than a stub. */
1494 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1500 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1501 gdb_flush (gdb_stdout
);
1504 psymtab_to_symtab_1 (pst
);
1506 /* Finish up the debug error message. */
1508 printf_filtered ("done.\n");
1514 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1516 struct objfile
*objfile
= pst
->objfile
;
1517 bfd
*abfd
= objfile
->obfd
;
1518 struct comp_unit_head cu_header
;
1519 struct die_info
*dies
;
1520 unsigned long offset
;
1521 CORE_ADDR lowpc
, highpc
;
1522 struct die_info
*child_die
;
1524 struct symtab
*symtab
;
1525 struct cleanup
*back_to
;
1527 /* Set local variables from the partial symbol table info. */
1528 offset
= DWARF_INFO_OFFSET (pst
);
1529 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1530 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1531 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1532 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1533 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1534 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1535 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1536 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1537 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1538 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1539 cu_header_offset
= offset
;
1540 info_ptr
= dwarf_info_buffer
+ offset
;
1542 obstack_init (&dwarf2_tmp_obstack
);
1543 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1546 make_cleanup (really_free_pendings
, NULL
);
1548 /* read in the comp_unit header */
1549 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1551 /* Read the abbrevs for this compilation unit */
1552 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1553 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1555 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1557 make_cleanup_free_die_list (dies
);
1559 /* Do line number decoding in read_file_scope () */
1560 process_die (dies
, objfile
, &cu_header
);
1562 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1564 /* Some compilers don't define a DW_AT_high_pc attribute for
1565 the compilation unit. If the DW_AT_high_pc is missing,
1566 synthesize it, by scanning the DIE's below the compilation unit. */
1568 if (dies
->has_children
)
1570 child_die
= dies
->next
;
1571 while (child_die
&& child_die
->tag
)
1573 if (child_die
->tag
== DW_TAG_subprogram
)
1575 CORE_ADDR low
, high
;
1577 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1579 highpc
= max (highpc
, high
);
1582 child_die
= sibling_die (child_die
);
1586 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1588 /* Set symtab language to language from DW_AT_language.
1589 If the compilation is from a C file generated by language preprocessors,
1590 do not set the language if it was already deduced by start_subfile. */
1592 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1594 symtab
->language
= cu_language
;
1596 pst
->symtab
= symtab
;
1598 sort_symtab_syms (pst
->symtab
);
1600 do_cleanups (back_to
);
1603 /* Process a die and its children. */
1606 process_die (struct die_info
*die
, struct objfile
*objfile
,
1607 const struct comp_unit_head
*cu_header
)
1611 case DW_TAG_padding
:
1613 case DW_TAG_compile_unit
:
1614 read_file_scope (die
, objfile
, cu_header
);
1616 case DW_TAG_subprogram
:
1617 read_subroutine_type (die
, objfile
, cu_header
);
1618 read_func_scope (die
, objfile
, cu_header
);
1620 case DW_TAG_inlined_subroutine
:
1621 /* FIXME: These are ignored for now.
1622 They could be used to set breakpoints on all inlined instances
1623 of a function and make GDB `next' properly over inlined functions. */
1625 case DW_TAG_lexical_block
:
1626 read_lexical_block_scope (die
, objfile
, cu_header
);
1628 case DW_TAG_class_type
:
1629 case DW_TAG_structure_type
:
1630 case DW_TAG_union_type
:
1631 read_structure_scope (die
, objfile
, cu_header
);
1633 case DW_TAG_enumeration_type
:
1634 read_enumeration (die
, objfile
, cu_header
);
1636 case DW_TAG_subroutine_type
:
1637 read_subroutine_type (die
, objfile
, cu_header
);
1639 case DW_TAG_array_type
:
1640 read_array_type (die
, objfile
, cu_header
);
1642 case DW_TAG_pointer_type
:
1643 read_tag_pointer_type (die
, objfile
, cu_header
);
1645 case DW_TAG_ptr_to_member_type
:
1646 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1648 case DW_TAG_reference_type
:
1649 read_tag_reference_type (die
, objfile
, cu_header
);
1651 case DW_TAG_string_type
:
1652 read_tag_string_type (die
, objfile
);
1654 case DW_TAG_base_type
:
1655 read_base_type (die
, objfile
);
1656 if (dwarf_attr (die
, DW_AT_name
))
1658 /* Add a typedef symbol for the base type definition. */
1659 new_symbol (die
, die
->type
, objfile
, cu_header
);
1662 case DW_TAG_common_block
:
1663 read_common_block (die
, objfile
, cu_header
);
1665 case DW_TAG_common_inclusion
:
1668 new_symbol (die
, NULL
, objfile
, cu_header
);
1674 initialize_cu_func_list (void)
1676 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1680 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1681 const struct comp_unit_head
*cu_header
)
1683 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1684 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1685 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1686 struct attribute
*attr
;
1687 char *name
= "<unknown>";
1688 char *comp_dir
= NULL
;
1689 struct die_info
*child_die
;
1690 bfd
*abfd
= objfile
->obfd
;
1691 struct line_header
*line_header
= 0;
1693 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1695 if (die
->has_children
)
1697 child_die
= die
->next
;
1698 while (child_die
&& child_die
->tag
)
1700 if (child_die
->tag
== DW_TAG_subprogram
)
1702 CORE_ADDR low
, high
;
1704 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1706 lowpc
= min (lowpc
, low
);
1707 highpc
= max (highpc
, high
);
1710 child_die
= sibling_die (child_die
);
1715 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1716 from finish_block. */
1717 if (lowpc
== ((CORE_ADDR
) -1))
1722 attr
= dwarf_attr (die
, DW_AT_name
);
1725 name
= DW_STRING (attr
);
1727 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1730 comp_dir
= DW_STRING (attr
);
1733 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1734 directory, get rid of it. */
1735 char *cp
= strchr (comp_dir
, ':');
1737 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1742 if (objfile
->ei
.entry_point
>= lowpc
&&
1743 objfile
->ei
.entry_point
< highpc
)
1745 objfile
->ei
.entry_file_lowpc
= lowpc
;
1746 objfile
->ei
.entry_file_highpc
= highpc
;
1749 attr
= dwarf_attr (die
, DW_AT_language
);
1752 set_cu_language (DW_UNSND (attr
));
1755 /* We assume that we're processing GCC output. */
1756 processing_gcc_compilation
= 2;
1758 /* FIXME:Do something here. */
1759 if (dip
->at_producer
!= NULL
)
1761 handle_producer (dip
->at_producer
);
1765 /* The compilation unit may be in a different language or objfile,
1766 zero out all remembered fundamental types. */
1767 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1769 start_symtab (name
, comp_dir
, lowpc
);
1770 record_debugformat ("DWARF 2");
1772 initialize_cu_func_list ();
1774 /* Process all dies in compilation unit. */
1775 if (die
->has_children
)
1777 child_die
= die
->next
;
1778 while (child_die
&& child_die
->tag
)
1780 process_die (child_die
, objfile
, cu_header
);
1781 child_die
= sibling_die (child_die
);
1785 /* Decode line number information if present. */
1786 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1789 unsigned int line_offset
= DW_UNSND (attr
);
1790 line_header
= dwarf_decode_line_header (line_offset
,
1794 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1795 (void *) line_header
);
1796 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1800 /* Decode macro information, if present. Dwarf 2 macro information
1801 refers to information in the line number info statement program
1802 header, so we can only read it if we've read the header
1804 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1807 unsigned int macro_offset
= DW_UNSND (attr
);
1808 dwarf_decode_macros (line_header
, macro_offset
,
1809 comp_dir
, abfd
, cu_header
, objfile
);
1811 do_cleanups (back_to
);
1815 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1817 struct function_range
*thisfn
;
1819 thisfn
= (struct function_range
*)
1820 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1821 thisfn
->name
= name
;
1822 thisfn
->lowpc
= lowpc
;
1823 thisfn
->highpc
= highpc
;
1824 thisfn
->seen_line
= 0;
1825 thisfn
->next
= NULL
;
1827 if (cu_last_fn
== NULL
)
1828 cu_first_fn
= thisfn
;
1830 cu_last_fn
->next
= thisfn
;
1832 cu_last_fn
= thisfn
;
1836 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1837 const struct comp_unit_head
*cu_header
)
1839 register struct context_stack
*new;
1842 struct die_info
*child_die
;
1843 struct attribute
*attr
;
1846 name
= dwarf2_linkage_name (die
);
1848 /* Ignore functions with missing or empty names and functions with
1849 missing or invalid low and high pc attributes. */
1850 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1856 /* Record the function range for dwarf_decode_lines. */
1857 add_to_cu_func_list (name
, lowpc
, highpc
);
1859 if (objfile
->ei
.entry_point
>= lowpc
&&
1860 objfile
->ei
.entry_point
< highpc
)
1862 objfile
->ei
.entry_func_lowpc
= lowpc
;
1863 objfile
->ei
.entry_func_highpc
= highpc
;
1866 /* Decode DW_AT_frame_base location descriptor if present, keep result
1867 for DW_OP_fbreg operands in decode_locdesc. */
1868 frame_base_reg
= -1;
1869 frame_base_offset
= 0;
1870 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1873 CORE_ADDR addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1875 complain (&dwarf2_unsupported_at_frame_base
, name
);
1877 frame_base_reg
= addr
;
1880 frame_base_reg
= basereg
;
1881 frame_base_offset
= addr
;
1884 complain (&dwarf2_unsupported_at_frame_base
, name
);
1887 new = push_context (0, lowpc
);
1888 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1889 list_in_scope
= &local_symbols
;
1891 if (die
->has_children
)
1893 child_die
= die
->next
;
1894 while (child_die
&& child_die
->tag
)
1896 process_die (child_die
, objfile
, cu_header
);
1897 child_die
= sibling_die (child_die
);
1901 new = pop_context ();
1902 /* Make a block for the local symbols within. */
1903 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1904 lowpc
, highpc
, objfile
);
1905 list_in_scope
= &file_symbols
;
1908 /* Process all the DIES contained within a lexical block scope. Start
1909 a new scope, process the dies, and then close the scope. */
1912 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1913 const struct comp_unit_head
*cu_header
)
1915 register struct context_stack
*new;
1916 CORE_ADDR lowpc
, highpc
;
1917 struct die_info
*child_die
;
1919 /* Ignore blocks with missing or invalid low and high pc attributes. */
1920 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1925 push_context (0, lowpc
);
1926 if (die
->has_children
)
1928 child_die
= die
->next
;
1929 while (child_die
&& child_die
->tag
)
1931 process_die (child_die
, objfile
, cu_header
);
1932 child_die
= sibling_die (child_die
);
1935 new = pop_context ();
1937 if (local_symbols
!= NULL
)
1939 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1942 local_symbols
= new->locals
;
1945 /* Get low and high pc attributes from a die.
1946 Return 1 if the attributes are present and valid, otherwise, return 0. */
1949 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1950 struct objfile
*objfile
)
1952 struct attribute
*attr
;
1956 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1958 low
= DW_ADDR (attr
);
1961 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1963 high
= DW_ADDR (attr
);
1970 /* When using the GNU linker, .gnu.linkonce. sections are used to
1971 eliminate duplicate copies of functions and vtables and such.
1972 The linker will arbitrarily choose one and discard the others.
1973 The AT_*_pc values for such functions refer to local labels in
1974 these sections. If the section from that file was discarded, the
1975 labels are not in the output, so the relocs get a value of 0.
1976 If this is a discarded function, mark the pc bounds as invalid,
1977 so that GDB will ignore it. */
1978 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
1986 /* Add an aggregate field to the field list. */
1989 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
1990 struct objfile
*objfile
,
1991 const struct comp_unit_head
*cu_header
)
1993 struct nextfield
*new_field
;
1994 struct attribute
*attr
;
1996 char *fieldname
= "";
1998 /* Allocate a new field list entry and link it in. */
1999 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2000 make_cleanup (xfree
, new_field
);
2001 memset (new_field
, 0, sizeof (struct nextfield
));
2002 new_field
->next
= fip
->fields
;
2003 fip
->fields
= new_field
;
2006 /* Handle accessibility and virtuality of field.
2007 The default accessibility for members is public, the default
2008 accessibility for inheritance is private. */
2009 if (die
->tag
!= DW_TAG_inheritance
)
2010 new_field
->accessibility
= DW_ACCESS_public
;
2012 new_field
->accessibility
= DW_ACCESS_private
;
2013 new_field
->virtuality
= DW_VIRTUALITY_none
;
2015 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2017 new_field
->accessibility
= DW_UNSND (attr
);
2018 if (new_field
->accessibility
!= DW_ACCESS_public
)
2019 fip
->non_public_fields
= 1;
2020 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2022 new_field
->virtuality
= DW_UNSND (attr
);
2024 fp
= &new_field
->field
;
2025 if (die
->tag
== DW_TAG_member
)
2027 /* Get type of field. */
2028 fp
->type
= die_type (die
, objfile
, cu_header
);
2030 /* Get bit size of field (zero if none). */
2031 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2034 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2038 FIELD_BITSIZE (*fp
) = 0;
2041 /* Get bit offset of field. */
2042 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2045 FIELD_BITPOS (*fp
) =
2046 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2049 FIELD_BITPOS (*fp
) = 0;
2050 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2053 if (BITS_BIG_ENDIAN
)
2055 /* For big endian bits, the DW_AT_bit_offset gives the
2056 additional bit offset from the MSB of the containing
2057 anonymous object to the MSB of the field. We don't
2058 have to do anything special since we don't need to
2059 know the size of the anonymous object. */
2060 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2064 /* For little endian bits, compute the bit offset to the
2065 MSB of the anonymous object, subtract off the number of
2066 bits from the MSB of the field to the MSB of the
2067 object, and then subtract off the number of bits of
2068 the field itself. The result is the bit offset of
2069 the LSB of the field. */
2071 int bit_offset
= DW_UNSND (attr
);
2073 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2076 /* The size of the anonymous object containing
2077 the bit field is explicit, so use the
2078 indicated size (in bytes). */
2079 anonymous_size
= DW_UNSND (attr
);
2083 /* The size of the anonymous object containing
2084 the bit field must be inferred from the type
2085 attribute of the data member containing the
2087 anonymous_size
= TYPE_LENGTH (fp
->type
);
2089 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2090 - bit_offset
- FIELD_BITSIZE (*fp
);
2094 /* Get name of field. */
2095 attr
= dwarf_attr (die
, DW_AT_name
);
2096 if (attr
&& DW_STRING (attr
))
2097 fieldname
= DW_STRING (attr
);
2098 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2099 &objfile
->type_obstack
);
2101 /* Change accessibility for artificial fields (e.g. virtual table
2102 pointer or virtual base class pointer) to private. */
2103 if (dwarf_attr (die
, DW_AT_artificial
))
2105 new_field
->accessibility
= DW_ACCESS_private
;
2106 fip
->non_public_fields
= 1;
2109 else if (die
->tag
== DW_TAG_variable
)
2113 /* C++ static member.
2114 Get name of field. */
2115 attr
= dwarf_attr (die
, DW_AT_name
);
2116 if (attr
&& DW_STRING (attr
))
2117 fieldname
= DW_STRING (attr
);
2121 /* Get physical name. */
2122 physname
= dwarf2_linkage_name (die
);
2124 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2125 &objfile
->type_obstack
));
2126 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2127 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2128 &objfile
->type_obstack
);
2130 else if (die
->tag
== DW_TAG_inheritance
)
2132 /* C++ base class field. */
2133 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2135 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2137 FIELD_BITSIZE (*fp
) = 0;
2138 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2139 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2140 fip
->nbaseclasses
++;
2144 /* Create the vector of fields, and attach it to the type. */
2147 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2148 struct objfile
*objfile
)
2150 int nfields
= fip
->nfields
;
2152 /* Record the field count, allocate space for the array of fields,
2153 and create blank accessibility bitfields if necessary. */
2154 TYPE_NFIELDS (type
) = nfields
;
2155 TYPE_FIELDS (type
) = (struct field
*)
2156 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2157 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2159 if (fip
->non_public_fields
)
2161 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2163 TYPE_FIELD_PRIVATE_BITS (type
) =
2164 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2165 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2167 TYPE_FIELD_PROTECTED_BITS (type
) =
2168 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2169 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2171 TYPE_FIELD_IGNORE_BITS (type
) =
2172 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2173 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2176 /* If the type has baseclasses, allocate and clear a bit vector for
2177 TYPE_FIELD_VIRTUAL_BITS. */
2178 if (fip
->nbaseclasses
)
2180 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2183 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2184 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2185 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2186 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2187 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2190 /* Copy the saved-up fields into the field vector. Start from the head
2191 of the list, adding to the tail of the field array, so that they end
2192 up in the same order in the array in which they were added to the list. */
2193 while (nfields
-- > 0)
2195 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2196 switch (fip
->fields
->accessibility
)
2198 case DW_ACCESS_private
:
2199 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2202 case DW_ACCESS_protected
:
2203 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2206 case DW_ACCESS_public
:
2210 /* Unknown accessibility. Complain and treat it as public. */
2212 complain (&dwarf2_unsupported_accessibility
,
2213 fip
->fields
->accessibility
);
2217 if (nfields
< fip
->nbaseclasses
)
2219 switch (fip
->fields
->virtuality
)
2221 case DW_VIRTUALITY_virtual
:
2222 case DW_VIRTUALITY_pure_virtual
:
2223 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2227 fip
->fields
= fip
->fields
->next
;
2231 /* Add a member function to the proper fieldlist. */
2234 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2235 struct objfile
*objfile
,
2236 const struct comp_unit_head
*cu_header
)
2238 struct attribute
*attr
;
2239 struct fnfieldlist
*flp
;
2241 struct fn_field
*fnp
;
2244 struct nextfnfield
*new_fnfield
;
2246 /* Get name of member function. */
2247 attr
= dwarf_attr (die
, DW_AT_name
);
2248 if (attr
&& DW_STRING (attr
))
2249 fieldname
= DW_STRING (attr
);
2253 /* Get the mangled name. */
2254 physname
= dwarf2_linkage_name (die
);
2256 /* Look up member function name in fieldlist. */
2257 for (i
= 0; i
< fip
->nfnfields
; i
++)
2259 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2263 /* Create new list element if necessary. */
2264 if (i
< fip
->nfnfields
)
2265 flp
= &fip
->fnfieldlists
[i
];
2268 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2270 fip
->fnfieldlists
= (struct fnfieldlist
*)
2271 xrealloc (fip
->fnfieldlists
,
2272 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2273 * sizeof (struct fnfieldlist
));
2274 if (fip
->nfnfields
== 0)
2275 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2277 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2278 flp
->name
= fieldname
;
2284 /* Create a new member function field and chain it to the field list
2286 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2287 make_cleanup (xfree
, new_fnfield
);
2288 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2289 new_fnfield
->next
= flp
->head
;
2290 flp
->head
= new_fnfield
;
2293 /* Fill in the member function field info. */
2294 fnp
= &new_fnfield
->fnfield
;
2295 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2296 &objfile
->type_obstack
);
2297 fnp
->type
= alloc_type (objfile
);
2298 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2300 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2301 int nparams
= TYPE_NFIELDS (die
->type
);
2303 smash_to_method_type (fnp
->type
, die
->type
,
2304 TYPE_TARGET_TYPE (die
->type
),
2305 TYPE_FIELDS (die
->type
),
2306 TYPE_NFIELDS (die
->type
),
2307 TYPE_VARARGS (die
->type
));
2309 /* Handle static member functions.
2310 Dwarf2 has no clean way to discern C++ static and non-static
2311 member functions. G++ helps GDB by marking the first
2312 parameter for non-static member functions (which is the
2313 this pointer) as artificial. We obtain this information
2314 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2315 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2316 fnp
->voffset
= VOFFSET_STATIC
;
2319 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2321 /* Get fcontext from DW_AT_containing_type if present. */
2322 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2323 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2325 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2326 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2328 /* Get accessibility. */
2329 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2332 switch (DW_UNSND (attr
))
2334 case DW_ACCESS_private
:
2335 fnp
->is_private
= 1;
2337 case DW_ACCESS_protected
:
2338 fnp
->is_protected
= 1;
2343 /* Check for artificial methods. */
2344 attr
= dwarf_attr (die
, DW_AT_artificial
);
2345 if (attr
&& DW_UNSND (attr
) != 0)
2346 fnp
->is_artificial
= 1;
2348 /* Get index in virtual function table if it is a virtual member function. */
2349 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2351 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2354 /* Create the vector of member function fields, and attach it to the type. */
2357 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2358 struct objfile
*objfile
)
2360 struct fnfieldlist
*flp
;
2361 int total_length
= 0;
2364 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2365 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2366 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2368 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2370 struct nextfnfield
*nfp
= flp
->head
;
2371 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2374 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2375 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2376 fn_flp
->fn_fields
= (struct fn_field
*)
2377 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2378 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2379 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2381 total_length
+= flp
->length
;
2384 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2385 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2388 /* Called when we find the DIE that starts a structure or union scope
2389 (definition) to process all dies that define the members of the
2392 NOTE: we need to call struct_type regardless of whether or not the
2393 DIE has an at_name attribute, since it might be an anonymous
2394 structure or union. This gets the type entered into our set of
2397 However, if the structure is incomplete (an opaque struct/union)
2398 then suppress creating a symbol table entry for it since gdb only
2399 wants to find the one with the complete definition. Note that if
2400 it is complete, we just call new_symbol, which does it's own
2401 checking about whether the struct/union is anonymous or not (and
2402 suppresses creating a symbol table entry itself). */
2405 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2406 const struct comp_unit_head
*cu_header
)
2409 struct attribute
*attr
;
2411 type
= alloc_type (objfile
);
2413 INIT_CPLUS_SPECIFIC (type
);
2414 attr
= dwarf_attr (die
, DW_AT_name
);
2415 if (attr
&& DW_STRING (attr
))
2417 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2418 strlen (DW_STRING (attr
)),
2419 &objfile
->type_obstack
);
2422 if (die
->tag
== DW_TAG_structure_type
)
2424 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2426 else if (die
->tag
== DW_TAG_union_type
)
2428 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2432 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2434 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2437 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2440 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2444 TYPE_LENGTH (type
) = 0;
2447 /* We need to add the type field to the die immediately so we don't
2448 infinitely recurse when dealing with pointers to the structure
2449 type within the structure itself. */
2452 if (die
->has_children
&& ! die_is_declaration (die
))
2454 struct field_info fi
;
2455 struct die_info
*child_die
;
2456 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2458 memset (&fi
, 0, sizeof (struct field_info
));
2460 child_die
= die
->next
;
2462 while (child_die
&& child_die
->tag
)
2464 if (child_die
->tag
== DW_TAG_member
)
2466 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2468 else if (child_die
->tag
== DW_TAG_variable
)
2470 /* C++ static member. */
2471 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2473 else if (child_die
->tag
== DW_TAG_subprogram
)
2475 /* C++ member function. */
2476 process_die (child_die
, objfile
, cu_header
);
2477 dwarf2_add_member_fn (&fi
, child_die
, objfile
, cu_header
);
2479 else if (child_die
->tag
== DW_TAG_inheritance
)
2481 /* C++ base class field. */
2482 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2486 process_die (child_die
, objfile
, cu_header
);
2488 child_die
= sibling_die (child_die
);
2491 /* Attach fields and member functions to the type. */
2493 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2496 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2498 /* Get the type which refers to the base class (possibly this
2499 class itself) which contains the vtable pointer for the current
2500 class from the DW_AT_containing_type attribute. */
2502 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2504 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2506 TYPE_VPTR_BASETYPE (type
) = t
;
2509 static const char vptr_name
[] =
2510 {'_', 'v', 'p', 't', 'r', '\0'};
2513 /* Our own class provides vtbl ptr. */
2514 for (i
= TYPE_NFIELDS (t
) - 1;
2515 i
>= TYPE_N_BASECLASSES (t
);
2518 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2520 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2521 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2523 TYPE_VPTR_FIELDNO (type
) = i
;
2528 /* Complain if virtual function table field not found. */
2529 if (i
< TYPE_N_BASECLASSES (t
))
2530 complain (&dwarf2_vtbl_not_found_complaint
,
2531 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2535 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2540 new_symbol (die
, type
, objfile
, cu_header
);
2542 do_cleanups (back_to
);
2546 /* No children, must be stub. */
2547 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2551 /* Given a pointer to a die which begins an enumeration, process all
2552 the dies that define the members of the enumeration.
2554 This will be much nicer in draft 6 of the DWARF spec when our
2555 members will be dies instead squished into the DW_AT_element_list
2558 NOTE: We reverse the order of the element list. */
2561 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2562 const struct comp_unit_head
*cu_header
)
2564 struct die_info
*child_die
;
2566 struct field
*fields
;
2567 struct attribute
*attr
;
2570 int unsigned_enum
= 1;
2572 type
= alloc_type (objfile
);
2574 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2575 attr
= dwarf_attr (die
, DW_AT_name
);
2576 if (attr
&& DW_STRING (attr
))
2578 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2579 strlen (DW_STRING (attr
)),
2580 &objfile
->type_obstack
);
2583 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2586 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2590 TYPE_LENGTH (type
) = 0;
2595 if (die
->has_children
)
2597 child_die
= die
->next
;
2598 while (child_die
&& child_die
->tag
)
2600 if (child_die
->tag
!= DW_TAG_enumerator
)
2602 process_die (child_die
, objfile
, cu_header
);
2606 attr
= dwarf_attr (child_die
, DW_AT_name
);
2609 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2610 if (SYMBOL_VALUE (sym
) < 0)
2613 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2615 fields
= (struct field
*)
2617 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2618 * sizeof (struct field
));
2621 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2622 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2623 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2624 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2630 child_die
= sibling_die (child_die
);
2635 TYPE_NFIELDS (type
) = num_fields
;
2636 TYPE_FIELDS (type
) = (struct field
*)
2637 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2638 memcpy (TYPE_FIELDS (type
), fields
,
2639 sizeof (struct field
) * num_fields
);
2643 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2646 new_symbol (die
, type
, objfile
, cu_header
);
2649 /* Extract all information from a DW_TAG_array_type DIE and put it in
2650 the DIE's type field. For now, this only handles one dimensional
2654 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2655 const struct comp_unit_head
*cu_header
)
2657 struct die_info
*child_die
;
2658 struct type
*type
= NULL
;
2659 struct type
*element_type
, *range_type
, *index_type
;
2660 struct type
**range_types
= NULL
;
2661 struct attribute
*attr
;
2663 struct cleanup
*back_to
;
2665 /* Return if we've already decoded this type. */
2671 element_type
= die_type (die
, objfile
, cu_header
);
2673 /* Irix 6.2 native cc creates array types without children for
2674 arrays with unspecified length. */
2675 if (die
->has_children
== 0)
2677 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2678 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2679 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2683 back_to
= make_cleanup (null_cleanup
, NULL
);
2684 child_die
= die
->next
;
2685 while (child_die
&& child_die
->tag
)
2687 if (child_die
->tag
== DW_TAG_subrange_type
)
2689 unsigned int low
, high
;
2691 /* Default bounds to an array with unspecified length. */
2694 if (cu_language
== language_fortran
)
2696 /* FORTRAN implies a lower bound of 1, if not given. */
2700 index_type
= die_type (child_die
, objfile
, cu_header
);
2701 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2704 if (attr
->form
== DW_FORM_sdata
)
2706 low
= DW_SND (attr
);
2708 else if (attr
->form
== DW_FORM_udata
2709 || attr
->form
== DW_FORM_data1
2710 || attr
->form
== DW_FORM_data2
2711 || attr
->form
== DW_FORM_data4
2712 || attr
->form
== DW_FORM_data8
)
2714 low
= DW_UNSND (attr
);
2718 complain (&dwarf2_non_const_array_bound_ignored
,
2719 dwarf_form_name (attr
->form
));
2721 die
->type
= lookup_pointer_type (element_type
);
2728 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2731 if (attr
->form
== DW_FORM_sdata
)
2733 high
= DW_SND (attr
);
2735 else if (attr
->form
== DW_FORM_udata
2736 || attr
->form
== DW_FORM_data1
2737 || attr
->form
== DW_FORM_data2
2738 || attr
->form
== DW_FORM_data4
2739 || attr
->form
== DW_FORM_data8
)
2741 high
= DW_UNSND (attr
);
2743 else if (attr
->form
== DW_FORM_block1
)
2745 /* GCC encodes arrays with unspecified or dynamic length
2746 with a DW_FORM_block1 attribute.
2747 FIXME: GDB does not yet know how to handle dynamic
2748 arrays properly, treat them as arrays with unspecified
2754 complain (&dwarf2_non_const_array_bound_ignored
,
2755 dwarf_form_name (attr
->form
));
2757 die
->type
= lookup_pointer_type (element_type
);
2765 /* Create a range type and save it for array type creation. */
2766 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2768 range_types
= (struct type
**)
2769 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2770 * sizeof (struct type
*));
2772 make_cleanup (free_current_contents
, &range_types
);
2774 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2776 child_die
= sibling_die (child_die
);
2779 /* Dwarf2 dimensions are output from left to right, create the
2780 necessary array types in backwards order. */
2781 type
= element_type
;
2783 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2785 /* Understand Dwarf2 support for vector types (like they occur on
2786 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2787 array type. This is not part of the Dwarf2/3 standard yet, but a
2788 custom vendor extension. The main difference between a regular
2789 array and the vector variant is that vectors are passed by value
2791 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2793 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2795 do_cleanups (back_to
);
2797 /* Install the type in the die. */
2801 /* First cut: install each common block member as a global variable. */
2804 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2805 const struct comp_unit_head
*cu_header
)
2807 struct die_info
*child_die
;
2808 struct attribute
*attr
;
2810 CORE_ADDR base
= (CORE_ADDR
) 0;
2812 attr
= dwarf_attr (die
, DW_AT_location
);
2815 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2817 if (die
->has_children
)
2819 child_die
= die
->next
;
2820 while (child_die
&& child_die
->tag
)
2822 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2823 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2826 SYMBOL_VALUE_ADDRESS (sym
) =
2827 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2828 add_symbol_to_list (sym
, &global_symbols
);
2830 child_die
= sibling_die (child_die
);
2835 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2836 the user defined type vector. */
2839 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
2840 const struct comp_unit_head
*cu_header
)
2843 struct attribute
*attr
;
2850 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
2851 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2854 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2858 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2863 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2864 the user defined type vector. */
2867 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
2868 const struct comp_unit_head
*cu_header
)
2871 struct type
*to_type
;
2872 struct type
*domain
;
2879 type
= alloc_type (objfile
);
2880 to_type
= die_type (die
, objfile
, cu_header
);
2881 domain
= die_containing_type (die
, objfile
, cu_header
);
2882 smash_to_member_type (type
, domain
, to_type
);
2887 /* Extract all information from a DW_TAG_reference_type DIE and add to
2888 the user defined type vector. */
2891 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
2892 const struct comp_unit_head
*cu_header
)
2895 struct attribute
*attr
;
2902 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
2903 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2906 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2910 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2916 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
2917 const struct comp_unit_head
*cu_header
)
2919 struct type
*base_type
;
2926 base_type
= die_type (die
, objfile
, cu_header
);
2927 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
2931 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
2932 const struct comp_unit_head
*cu_header
)
2934 struct type
*base_type
;
2941 base_type
= die_type (die
, objfile
, cu_header
);
2942 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
2945 /* Extract all information from a DW_TAG_string_type DIE and add to
2946 the user defined type vector. It isn't really a user defined type,
2947 but it behaves like one, with other DIE's using an AT_user_def_type
2948 attribute to reference it. */
2951 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
2953 struct type
*type
, *range_type
, *index_type
, *char_type
;
2954 struct attribute
*attr
;
2955 unsigned int length
;
2962 attr
= dwarf_attr (die
, DW_AT_string_length
);
2965 length
= DW_UNSND (attr
);
2969 /* check for the DW_AT_byte_size attribute */
2970 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2973 length
= DW_UNSND (attr
);
2980 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2981 range_type
= create_range_type (NULL
, index_type
, 1, length
);
2982 if (cu_language
== language_fortran
)
2984 /* Need to create a unique string type for bounds
2986 type
= create_string_type (0, range_type
);
2990 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
2991 type
= create_string_type (char_type
, range_type
);
2996 /* Handle DIES due to C code like:
3000 int (*funcp)(int a, long l);
3004 ('funcp' generates a DW_TAG_subroutine_type DIE)
3008 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3009 const struct comp_unit_head
*cu_header
)
3011 struct type
*type
; /* Type that this function returns */
3012 struct type
*ftype
; /* Function that returns above type */
3013 struct attribute
*attr
;
3015 /* Decode the type that this subroutine returns */
3020 type
= die_type (die
, objfile
, cu_header
);
3021 ftype
= lookup_function_type (type
);
3023 /* All functions in C++ have prototypes. */
3024 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3025 if ((attr
&& (DW_UNSND (attr
) != 0))
3026 || cu_language
== language_cplus
)
3027 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3029 if (die
->has_children
)
3031 struct die_info
*child_die
;
3035 /* Count the number of parameters.
3036 FIXME: GDB currently ignores vararg functions, but knows about
3037 vararg member functions. */
3038 child_die
= die
->next
;
3039 while (child_die
&& child_die
->tag
)
3041 if (child_die
->tag
== DW_TAG_formal_parameter
)
3043 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3044 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3045 child_die
= sibling_die (child_die
);
3048 /* Allocate storage for parameters and fill them in. */
3049 TYPE_NFIELDS (ftype
) = nparams
;
3050 TYPE_FIELDS (ftype
) = (struct field
*)
3051 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3053 child_die
= die
->next
;
3054 while (child_die
&& child_die
->tag
)
3056 if (child_die
->tag
== DW_TAG_formal_parameter
)
3058 /* Dwarf2 has no clean way to discern C++ static and non-static
3059 member functions. G++ helps GDB by marking the first
3060 parameter for non-static member functions (which is the
3061 this pointer) as artificial. We pass this information
3062 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3063 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3065 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3067 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3068 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3072 child_die
= sibling_die (child_die
);
3080 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3081 const struct comp_unit_head
*cu_header
)
3083 struct attribute
*attr
;
3088 attr
= dwarf_attr (die
, DW_AT_name
);
3089 if (attr
&& DW_STRING (attr
))
3091 name
= DW_STRING (attr
);
3093 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3094 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3098 /* Find a representation of a given base type and install
3099 it in the TYPE field of the die. */
3102 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3105 struct attribute
*attr
;
3106 int encoding
= 0, size
= 0;
3108 /* If we've already decoded this die, this is a no-op. */
3114 attr
= dwarf_attr (die
, DW_AT_encoding
);
3117 encoding
= DW_UNSND (attr
);
3119 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3122 size
= DW_UNSND (attr
);
3124 attr
= dwarf_attr (die
, DW_AT_name
);
3125 if (attr
&& DW_STRING (attr
))
3127 enum type_code code
= TYPE_CODE_INT
;
3132 case DW_ATE_address
:
3133 /* Turn DW_ATE_address into a void * pointer. */
3134 code
= TYPE_CODE_PTR
;
3135 type_flags
|= TYPE_FLAG_UNSIGNED
;
3137 case DW_ATE_boolean
:
3138 code
= TYPE_CODE_BOOL
;
3139 type_flags
|= TYPE_FLAG_UNSIGNED
;
3141 case DW_ATE_complex_float
:
3142 code
= TYPE_CODE_COMPLEX
;
3145 code
= TYPE_CODE_FLT
;
3148 case DW_ATE_signed_char
:
3150 case DW_ATE_unsigned
:
3151 case DW_ATE_unsigned_char
:
3152 type_flags
|= TYPE_FLAG_UNSIGNED
;
3155 complain (&dwarf2_unsupported_at_encoding
,
3156 dwarf_type_encoding_name (encoding
));
3159 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3160 if (encoding
== DW_ATE_address
)
3161 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3162 else if (encoding
== DW_ATE_complex_float
)
3165 TYPE_TARGET_TYPE (type
)
3166 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3167 else if (size
== 16)
3168 TYPE_TARGET_TYPE (type
)
3169 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3171 TYPE_TARGET_TYPE (type
)
3172 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3177 type
= dwarf_base_type (encoding
, size
, objfile
);
3182 /* Read a whole compilation unit into a linked list of dies. */
3184 static struct die_info
*
3185 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3186 const struct comp_unit_head
*cu_header
)
3188 struct die_info
*first_die
, *last_die
, *die
;
3192 /* Reset die reference table; we are
3193 building new ones now. */
3194 dwarf2_empty_hash_tables ();
3198 first_die
= last_die
= NULL
;
3201 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3202 if (die
->has_children
)
3213 /* Enter die in reference hash table */
3214 store_in_ref_table (die
->offset
, die
);
3218 first_die
= last_die
= die
;
3222 last_die
->next
= die
;
3226 while (nesting_level
> 0);
3230 /* Free a linked list of dies. */
3233 free_die_list (struct die_info
*dies
)
3235 struct die_info
*die
, *next
;
3248 do_free_die_list_cleanup (void *dies
)
3250 free_die_list (dies
);
3253 static struct cleanup
*
3254 make_cleanup_free_die_list (struct die_info
*dies
)
3256 return make_cleanup (do_free_die_list_cleanup
, dies
);
3260 /* Read the contents of the section at OFFSET and of size SIZE from the
3261 object file specified by OBJFILE into the psymbol_obstack and return it. */
3264 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3267 bfd
*abfd
= objfile
->obfd
;
3273 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3274 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3275 (bfd_bread (buf
, size
, abfd
) != size
))
3278 error ("Dwarf Error: Can't read DWARF data from '%s'",
3279 bfd_get_filename (abfd
));
3284 /* In DWARF version 2, the description of the debugging information is
3285 stored in a separate .debug_abbrev section. Before we read any
3286 dies from a section we read in all abbreviations and install them
3290 dwarf2_read_abbrevs (bfd
*abfd
, unsigned int offset
)
3293 struct abbrev_info
*cur_abbrev
;
3294 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3295 unsigned int abbrev_form
, hash_number
;
3297 /* empty the table */
3298 dwarf2_empty_abbrev_table (NULL
);
3300 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3301 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3302 abbrev_ptr
+= bytes_read
;
3304 /* loop until we reach an abbrev number of 0 */
3305 while (abbrev_number
)
3307 cur_abbrev
= dwarf_alloc_abbrev ();
3309 /* read in abbrev header */
3310 cur_abbrev
->number
= abbrev_number
;
3311 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3312 abbrev_ptr
+= bytes_read
;
3313 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3316 /* now read in declarations */
3317 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3318 abbrev_ptr
+= bytes_read
;
3319 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3320 abbrev_ptr
+= bytes_read
;
3323 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3325 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3326 xrealloc (cur_abbrev
->attrs
,
3327 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3328 * sizeof (struct attr_abbrev
));
3330 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3331 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3332 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3333 abbrev_ptr
+= bytes_read
;
3334 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3335 abbrev_ptr
+= bytes_read
;
3338 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3339 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3340 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3342 /* Get next abbreviation.
3343 Under Irix6 the abbreviations for a compilation unit are not
3344 always properly terminated with an abbrev number of 0.
3345 Exit loop if we encounter an abbreviation which we have
3346 already read (which means we are about to read the abbreviations
3347 for the next compile unit) or if the end of the abbreviation
3348 table is reached. */
3349 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3350 >= dwarf_abbrev_size
)
3352 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3353 abbrev_ptr
+= bytes_read
;
3354 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3359 /* Empty the abbrev table for a new compilation unit. */
3363 dwarf2_empty_abbrev_table (PTR ignore
)
3366 struct abbrev_info
*abbrev
, *next
;
3368 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3371 abbrev
= dwarf2_abbrevs
[i
];
3374 next
= abbrev
->next
;
3375 xfree (abbrev
->attrs
);
3379 dwarf2_abbrevs
[i
] = NULL
;
3383 /* Lookup an abbrev_info structure in the abbrev hash table. */
3385 static struct abbrev_info
*
3386 dwarf2_lookup_abbrev (unsigned int number
)
3388 unsigned int hash_number
;
3389 struct abbrev_info
*abbrev
;
3391 hash_number
= number
% ABBREV_HASH_SIZE
;
3392 abbrev
= dwarf2_abbrevs
[hash_number
];
3396 if (abbrev
->number
== number
)
3399 abbrev
= abbrev
->next
;
3404 /* Read a minimal amount of information into the minimal die structure. */
3407 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3408 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3410 unsigned int abbrev_number
, bytes_read
, i
;
3411 struct abbrev_info
*abbrev
;
3412 struct attribute attr
;
3413 struct attribute spec_attr
;
3414 int found_spec_attr
= 0;
3415 int has_low_pc_attr
= 0;
3416 int has_high_pc_attr
= 0;
3418 *part_die
= zeroed_partial_die
;
3419 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3420 info_ptr
+= bytes_read
;
3424 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3427 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3429 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3430 part_die
->tag
= abbrev
->tag
;
3431 part_die
->has_children
= abbrev
->has_children
;
3432 part_die
->abbrev
= abbrev_number
;
3434 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3436 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3437 info_ptr
, cu_header
);
3439 /* Store the data if it is of an attribute we want to keep in a
3440 partial symbol table. */
3445 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3446 if (part_die
->name
== NULL
)
3447 part_die
->name
= DW_STRING (&attr
);
3449 case DW_AT_MIPS_linkage_name
:
3450 part_die
->name
= DW_STRING (&attr
);
3453 has_low_pc_attr
= 1;
3454 part_die
->lowpc
= DW_ADDR (&attr
);
3457 has_high_pc_attr
= 1;
3458 part_die
->highpc
= DW_ADDR (&attr
);
3460 case DW_AT_location
:
3461 part_die
->locdesc
= DW_BLOCK (&attr
);
3463 case DW_AT_language
:
3464 part_die
->language
= DW_UNSND (&attr
);
3466 case DW_AT_external
:
3467 part_die
->is_external
= DW_UNSND (&attr
);
3469 case DW_AT_declaration
:
3470 part_die
->is_declaration
= DW_UNSND (&attr
);
3473 part_die
->has_type
= 1;
3475 case DW_AT_abstract_origin
:
3476 case DW_AT_specification
:
3477 found_spec_attr
= 1;
3481 /* Ignore absolute siblings, they might point outside of
3482 the current compile unit. */
3483 if (attr
.form
== DW_FORM_ref_addr
)
3484 complain (&dwarf2_absolute_sibling_complaint
);
3487 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3494 /* If we found a reference attribute and the die has no name, try
3495 to find a name in the referred to die. */
3497 if (found_spec_attr
&& part_die
->name
== NULL
)
3499 struct partial_die_info spec_die
;
3503 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3504 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3507 part_die
->name
= spec_die
.name
;
3509 /* Copy DW_AT_external attribute if it is set. */
3510 if (spec_die
.is_external
)
3511 part_die
->is_external
= spec_die
.is_external
;
3515 /* When using the GNU linker, .gnu.linkonce. sections are used to
3516 eliminate duplicate copies of functions and vtables and such.
3517 The linker will arbitrarily choose one and discard the others.
3518 The AT_*_pc values for such functions refer to local labels in
3519 these sections. If the section from that file was discarded, the
3520 labels are not in the output, so the relocs get a value of 0.
3521 If this is a discarded function, mark the pc bounds as invalid,
3522 so that GDB will ignore it. */
3523 if (has_low_pc_attr
&& has_high_pc_attr
3524 && part_die
->lowpc
< part_die
->highpc
3525 && (part_die
->lowpc
!= 0
3526 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3527 part_die
->has_pc_info
= 1;
3531 /* Read the die from the .debug_info section buffer. And set diep to
3532 point to a newly allocated die with its information. */
3535 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3536 const struct comp_unit_head
*cu_header
)
3538 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3539 struct abbrev_info
*abbrev
;
3540 struct die_info
*die
;
3542 offset
= info_ptr
- dwarf_info_buffer
;
3543 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3544 info_ptr
+= bytes_read
;
3547 die
= dwarf_alloc_die ();
3549 die
->abbrev
= abbrev_number
;
3555 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3558 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3560 die
= dwarf_alloc_die ();
3561 die
->offset
= offset
;
3562 die
->tag
= abbrev
->tag
;
3563 die
->has_children
= abbrev
->has_children
;
3564 die
->abbrev
= abbrev_number
;
3567 die
->num_attrs
= abbrev
->num_attrs
;
3568 die
->attrs
= (struct attribute
*)
3569 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3571 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3573 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3574 abfd
, info_ptr
, cu_header
);
3581 /* Read an attribute value described by an attribute form. */
3584 read_attribute_value (struct attribute
*attr
, unsigned form
,
3585 bfd
*abfd
, char *info_ptr
,
3586 const struct comp_unit_head
*cu_header
)
3588 unsigned int bytes_read
;
3589 struct dwarf_block
*blk
;
3595 case DW_FORM_ref_addr
:
3596 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3597 info_ptr
+= bytes_read
;
3599 case DW_FORM_block2
:
3600 blk
= dwarf_alloc_block ();
3601 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3603 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3604 info_ptr
+= blk
->size
;
3605 DW_BLOCK (attr
) = blk
;
3607 case DW_FORM_block4
:
3608 blk
= dwarf_alloc_block ();
3609 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3611 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3612 info_ptr
+= blk
->size
;
3613 DW_BLOCK (attr
) = blk
;
3616 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3620 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3624 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3627 case DW_FORM_string
:
3628 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3629 info_ptr
+= bytes_read
;
3632 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3634 info_ptr
+= bytes_read
;
3637 blk
= dwarf_alloc_block ();
3638 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3639 info_ptr
+= bytes_read
;
3640 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3641 info_ptr
+= blk
->size
;
3642 DW_BLOCK (attr
) = blk
;
3644 case DW_FORM_block1
:
3645 blk
= dwarf_alloc_block ();
3646 blk
->size
= read_1_byte (abfd
, info_ptr
);
3648 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3649 info_ptr
+= blk
->size
;
3650 DW_BLOCK (attr
) = blk
;
3653 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3657 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3661 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3662 info_ptr
+= bytes_read
;
3665 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3666 info_ptr
+= bytes_read
;
3669 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3673 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3677 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3681 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3684 case DW_FORM_ref_udata
:
3685 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3686 info_ptr
+= bytes_read
;
3688 case DW_FORM_indirect
:
3689 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3690 info_ptr
+= bytes_read
;
3691 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3694 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3695 dwarf_form_name (form
));
3700 /* Read an attribute described by an abbreviated attribute. */
3703 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3704 bfd
*abfd
, char *info_ptr
,
3705 const struct comp_unit_head
*cu_header
)
3707 attr
->name
= abbrev
->name
;
3708 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3711 /* read dwarf information from a buffer */
3714 read_1_byte (bfd
*abfd
, char *buf
)
3716 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3720 read_1_signed_byte (bfd
*abfd
, char *buf
)
3722 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3726 read_2_bytes (bfd
*abfd
, char *buf
)
3728 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3732 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3734 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3738 read_4_bytes (bfd
*abfd
, char *buf
)
3740 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3744 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3746 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3749 static unsigned long
3750 read_8_bytes (bfd
*abfd
, char *buf
)
3752 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3756 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3759 CORE_ADDR retval
= 0;
3761 if (cu_header
->signed_addr_p
)
3763 switch (cu_header
->addr_size
)
3766 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3769 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3772 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3775 internal_error (__FILE__
, __LINE__
,
3776 "read_address: bad switch, signed");
3781 switch (cu_header
->addr_size
)
3784 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3787 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3790 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3793 internal_error (__FILE__
, __LINE__
,
3794 "read_address: bad switch, unsigned");
3798 *bytes_read
= cu_header
->addr_size
;
3802 /* Reads the initial length from a section. The (draft) DWARF 2.1
3803 specification allows the initial length to take up either 4 bytes
3804 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3805 bytes describe the length and all offsets will be 8 bytes in length
3808 The value returned via bytes_read should be used to increment
3809 the relevant pointer after calling read_initial_length().
3811 As a side effect, this function sets the fields initial_length_size
3812 and offset_size in cu_header to the values appropriate for the
3813 length field. (The format of the initial length field determines
3814 the width of file offsets to be fetched later with fetch_offset().)
3816 [ Note: read_initial_length() and read_offset() are based on the
3817 document entitled "DWARF Debugging Information Format", revision
3818 2.1, draft 4, dated July 20, 2000. This document was obtained
3821 http://reality.sgi.com/dehnert_engr/dwarf/dwarf2p1-draft4-000720.pdf
3823 This document is only a draft and is subject to change. (So beware.)
3825 - Kevin, Aug 4, 2000
3829 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3834 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3836 if (retval
== 0xffffffff)
3838 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3840 if (cu_header
!= NULL
)
3842 cu_header
->initial_length_size
= 12;
3843 cu_header
->offset_size
= 8;
3849 if (cu_header
!= NULL
)
3851 cu_header
->initial_length_size
= 4;
3852 cu_header
->offset_size
= 4;
3859 /* Read an offset from the data stream. The size of the offset is
3860 given by cu_header->offset_size. */
3863 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3868 switch (cu_header
->offset_size
)
3871 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3875 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3879 internal_error (__FILE__
, __LINE__
,
3880 "read_offset: bad switch");
3887 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
3889 /* If the size of a host char is 8 bits, we can return a pointer
3890 to the buffer, otherwise we have to copy the data to a buffer
3891 allocated on the temporary obstack. */
3892 gdb_assert (HOST_CHAR_BIT
== 8);
3897 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3899 /* If the size of a host char is 8 bits, we can return a pointer
3900 to the string, otherwise we have to copy the string to a buffer
3901 allocated on the temporary obstack. */
3902 gdb_assert (HOST_CHAR_BIT
== 8);
3905 *bytes_read_ptr
= 1;
3908 *bytes_read_ptr
= strlen (buf
) + 1;
3913 read_indirect_string (bfd
*abfd
, char *buf
,
3914 const struct comp_unit_head
*cu_header
,
3915 unsigned int *bytes_read_ptr
)
3917 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
3918 (int *) bytes_read_ptr
);
3920 if (dwarf_str_buffer
== NULL
)
3922 error ("DW_FORM_strp used without .debug_str section");
3925 if (str_offset
>= dwarf_str_size
)
3927 error ("DW_FORM_strp pointing outside of .debug_str section");
3930 gdb_assert (HOST_CHAR_BIT
== 8);
3931 if (dwarf_str_buffer
[str_offset
] == '\0')
3933 return dwarf_str_buffer
+ str_offset
;
3936 static unsigned long
3937 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3939 unsigned long result
;
3940 unsigned int num_read
;
3950 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3953 result
|= ((unsigned long)(byte
& 127) << shift
);
3954 if ((byte
& 128) == 0)
3960 *bytes_read_ptr
= num_read
;
3965 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3968 int i
, shift
, size
, num_read
;
3978 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3981 result
|= ((long)(byte
& 127) << shift
);
3983 if ((byte
& 128) == 0)
3988 if ((shift
< size
) && (byte
& 0x40))
3990 result
|= -(1 << shift
);
3992 *bytes_read_ptr
= num_read
;
3997 set_cu_language (unsigned int lang
)
4003 cu_language
= language_c
;
4005 case DW_LANG_C_plus_plus
:
4006 cu_language
= language_cplus
;
4008 case DW_LANG_Fortran77
:
4009 case DW_LANG_Fortran90
:
4010 case DW_LANG_Fortran95
:
4011 cu_language
= language_fortran
;
4013 case DW_LANG_Mips_Assembler
:
4014 cu_language
= language_asm
;
4017 cu_language
= language_java
;
4020 case DW_LANG_Cobol74
:
4021 case DW_LANG_Cobol85
:
4022 case DW_LANG_Pascal83
:
4023 case DW_LANG_Modula2
:
4025 cu_language
= language_unknown
;
4028 cu_language_defn
= language_def (cu_language
);
4031 /* Return the named attribute or NULL if not there. */
4033 static struct attribute
*
4034 dwarf_attr (struct die_info
*die
, unsigned int name
)
4037 struct attribute
*spec
= NULL
;
4039 for (i
= 0; i
< die
->num_attrs
; ++i
)
4041 if (die
->attrs
[i
].name
== name
)
4043 return &die
->attrs
[i
];
4045 if (die
->attrs
[i
].name
== DW_AT_specification
4046 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4047 spec
= &die
->attrs
[i
];
4051 struct die_info
*ref_die
=
4052 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4055 return dwarf_attr (ref_die
, name
);
4062 die_is_declaration (struct die_info
*die
)
4064 return (dwarf_attr (die
, DW_AT_declaration
)
4065 && ! dwarf_attr (die
, DW_AT_specification
));
4069 /* Free the line_header structure *LH, and any arrays and strings it
4072 free_line_header (struct line_header
*lh
)
4074 if (lh
->standard_opcode_lengths
)
4075 xfree (lh
->standard_opcode_lengths
);
4077 /* Remember that all the lh->file_names[i].name pointers are
4078 pointers into debug_line_buffer, and don't need to be freed. */
4080 xfree (lh
->file_names
);
4082 /* Similarly for the include directory names. */
4083 if (lh
->include_dirs
)
4084 xfree (lh
->include_dirs
);
4090 /* Add an entry to LH's include directory table. */
4092 add_include_dir (struct line_header
*lh
, char *include_dir
)
4094 /* Grow the array if necessary. */
4095 if (lh
->include_dirs_size
== 0)
4097 lh
->include_dirs_size
= 1; /* for testing */
4098 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4099 * sizeof (*lh
->include_dirs
));
4101 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4103 lh
->include_dirs_size
*= 2;
4104 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4105 (lh
->include_dirs_size
4106 * sizeof (*lh
->include_dirs
)));
4109 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4113 /* Add an entry to LH's file name table. */
4115 add_file_name (struct line_header
*lh
,
4117 unsigned int dir_index
,
4118 unsigned int mod_time
,
4119 unsigned int length
)
4121 struct file_entry
*fe
;
4123 /* Grow the array if necessary. */
4124 if (lh
->file_names_size
== 0)
4126 lh
->file_names_size
= 1; /* for testing */
4127 lh
->file_names
= xmalloc (lh
->file_names_size
4128 * sizeof (*lh
->file_names
));
4130 else if (lh
->num_file_names
>= lh
->file_names_size
)
4132 lh
->file_names_size
*= 2;
4133 lh
->file_names
= xrealloc (lh
->file_names
,
4134 (lh
->file_names_size
4135 * sizeof (*lh
->file_names
)));
4138 fe
= &lh
->file_names
[lh
->num_file_names
++];
4140 fe
->dir_index
= dir_index
;
4141 fe
->mod_time
= mod_time
;
4142 fe
->length
= length
;
4146 /* Read the statement program header starting at OFFSET in
4147 dwarf_line_buffer, according to the endianness of ABFD. Return a
4148 pointer to a struct line_header, allocated using xmalloc.
4150 NOTE: the strings in the include directory and file name tables of
4151 the returned object point into debug_line_buffer, and must not be
4153 static struct line_header
*
4154 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4155 const struct comp_unit_head
*cu_header
)
4157 struct cleanup
*back_to
;
4158 struct line_header
*lh
;
4162 char *cur_dir
, *cur_file
;
4164 if (dwarf_line_buffer
== NULL
)
4166 complain (&dwarf2_missing_line_number_section
);
4170 /* Make sure that at least there's room for the total_length field. That
4171 could be 12 bytes long, but we're just going to fudge that. */
4172 if (offset
+ 4 >= dwarf_line_size
)
4174 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4178 lh
= xmalloc (sizeof (*lh
));
4179 memset (lh
, 0, sizeof (*lh
));
4180 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4183 line_ptr
= dwarf_line_buffer
+ offset
;
4185 /* read in the header */
4186 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4187 line_ptr
+= bytes_read
;
4188 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4190 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4193 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4194 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4196 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4197 line_ptr
+= bytes_read
;
4198 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4200 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4202 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4204 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4206 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4208 lh
->standard_opcode_lengths
4209 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4211 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4212 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4214 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4218 /* Read directory table */
4219 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4221 line_ptr
+= bytes_read
;
4222 add_include_dir (lh
, cur_dir
);
4224 line_ptr
+= bytes_read
;
4226 /* Read file name table */
4227 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4229 unsigned int dir_index
, mod_time
, length
;
4231 line_ptr
+= bytes_read
;
4232 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4233 line_ptr
+= bytes_read
;
4234 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4235 line_ptr
+= bytes_read
;
4236 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4237 line_ptr
+= bytes_read
;
4239 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4241 line_ptr
+= bytes_read
;
4242 lh
->statement_program_start
= line_ptr
;
4244 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4245 complain (&dwarf2_line_header_too_long
);
4247 discard_cleanups (back_to
);
4251 /* This function exists to work around a bug in certain compilers
4252 (particularly GCC 2.95), in which the first line number marker of a
4253 function does not show up until after the prologue, right before
4254 the second line number marker. This function shifts ADDRESS down
4255 to the beginning of the function if necessary, and is called on
4256 addresses passed to record_line. */
4259 check_cu_functions (CORE_ADDR address
)
4261 struct function_range
*fn
;
4263 /* Find the function_range containing address. */
4268 cu_cached_fn
= cu_first_fn
;
4272 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4278 while (fn
&& fn
!= cu_cached_fn
)
4279 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4289 if (address
!= fn
->lowpc
)
4290 complain (&dwarf2_misplaced_line_number
,
4291 (unsigned long) address
, fn
->name
);
4296 /* Decode the line number information for the compilation unit whose
4297 line number info is at OFFSET in the .debug_line section.
4298 The compilation directory of the file is passed in COMP_DIR. */
4301 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4302 const struct comp_unit_head
*cu_header
)
4306 unsigned int i
, bytes_read
;
4308 unsigned char op_code
, extended_op
, adj_opcode
;
4310 line_ptr
= lh
->statement_program_start
;
4311 line_end
= lh
->statement_program_end
;
4313 /* Read the statement sequences until there's nothing left. */
4314 while (line_ptr
< line_end
)
4316 /* state machine registers */
4317 CORE_ADDR address
= 0;
4318 unsigned int file
= 1;
4319 unsigned int line
= 1;
4320 unsigned int column
= 0;
4321 int is_stmt
= lh
->default_is_stmt
;
4322 int basic_block
= 0;
4323 int end_sequence
= 0;
4325 /* Start a subfile for the current file of the state machine. */
4326 if (lh
->num_file_names
>= file
)
4328 /* lh->include_dirs and lh->file_names are 0-based, but the
4329 directory and file name numbers in the statement program
4331 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4334 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4337 dwarf2_start_subfile (fe
->name
, dir
);
4340 /* Decode the table. */
4341 while (!end_sequence
)
4343 op_code
= read_1_byte (abfd
, line_ptr
);
4346 if (op_code
>= lh
->opcode_base
)
4347 { /* Special operand. */
4348 adj_opcode
= op_code
- lh
->opcode_base
;
4349 address
+= (adj_opcode
/ lh
->line_range
)
4350 * lh
->minimum_instruction_length
;
4351 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4352 /* append row to matrix using current values */
4353 address
= check_cu_functions (address
);
4354 record_line (current_subfile
, line
, address
);
4357 else switch (op_code
)
4359 case DW_LNS_extended_op
:
4360 line_ptr
+= 1; /* ignore length */
4361 extended_op
= read_1_byte (abfd
, line_ptr
);
4363 switch (extended_op
)
4365 case DW_LNE_end_sequence
:
4367 record_line (current_subfile
, 0, address
);
4369 case DW_LNE_set_address
:
4370 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4371 line_ptr
+= bytes_read
;
4372 address
+= baseaddr
;
4374 case DW_LNE_define_file
:
4377 unsigned int dir_index
, mod_time
, length
;
4379 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4380 line_ptr
+= bytes_read
;
4382 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4383 line_ptr
+= bytes_read
;
4385 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4386 line_ptr
+= bytes_read
;
4388 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4389 line_ptr
+= bytes_read
;
4390 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4394 complain (&dwarf2_mangled_line_number_section
);
4399 address
= check_cu_functions (address
);
4400 record_line (current_subfile
, line
, address
);
4403 case DW_LNS_advance_pc
:
4404 address
+= lh
->minimum_instruction_length
4405 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4406 line_ptr
+= bytes_read
;
4408 case DW_LNS_advance_line
:
4409 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4410 line_ptr
+= bytes_read
;
4412 case DW_LNS_set_file
:
4414 /* lh->include_dirs and lh->file_names are 0-based,
4415 but the directory and file name numbers in the
4416 statement program are 1-based. */
4417 struct file_entry
*fe
;
4419 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4420 line_ptr
+= bytes_read
;
4421 fe
= &lh
->file_names
[file
- 1];
4423 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4426 dwarf2_start_subfile (fe
->name
, dir
);
4429 case DW_LNS_set_column
:
4430 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4431 line_ptr
+= bytes_read
;
4433 case DW_LNS_negate_stmt
:
4434 is_stmt
= (!is_stmt
);
4436 case DW_LNS_set_basic_block
:
4439 /* Add to the address register of the state machine the
4440 address increment value corresponding to special opcode
4441 255. Ie, this value is scaled by the minimum instruction
4442 length since special opcode 255 would have scaled the
4444 case DW_LNS_const_add_pc
:
4445 address
+= (lh
->minimum_instruction_length
4446 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4448 case DW_LNS_fixed_advance_pc
:
4449 address
+= read_2_bytes (abfd
, line_ptr
);
4453 { /* Unknown standard opcode, ignore it. */
4455 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4457 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4458 line_ptr
+= bytes_read
;
4466 /* Start a subfile for DWARF. FILENAME is the name of the file and
4467 DIRNAME the name of the source directory which contains FILENAME
4468 or NULL if not known.
4469 This routine tries to keep line numbers from identical absolute and
4470 relative file names in a common subfile.
4472 Using the `list' example from the GDB testsuite, which resides in
4473 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4474 of /srcdir/list0.c yields the following debugging information for list0.c:
4476 DW_AT_name: /srcdir/list0.c
4477 DW_AT_comp_dir: /compdir
4478 files.files[0].name: list0.h
4479 files.files[0].dir: /srcdir
4480 files.files[1].name: list0.c
4481 files.files[1].dir: /srcdir
4483 The line number information for list0.c has to end up in a single
4484 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4487 dwarf2_start_subfile (char *filename
, char *dirname
)
4489 /* If the filename isn't absolute, try to match an existing subfile
4490 with the full pathname. */
4492 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4494 struct subfile
*subfile
;
4495 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4497 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4499 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4501 current_subfile
= subfile
;
4508 start_subfile (filename
, dirname
);
4511 /* Given a pointer to a DWARF information entry, figure out if we need
4512 to make a symbol table entry for it, and if so, create a new entry
4513 and return a pointer to it.
4514 If TYPE is NULL, determine symbol type from the die, otherwise
4515 used the passed type. */
4517 static struct symbol
*
4518 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4519 const struct comp_unit_head
*cu_header
)
4521 struct symbol
*sym
= NULL
;
4523 struct attribute
*attr
= NULL
;
4524 struct attribute
*attr2
= NULL
;
4527 name
= dwarf2_linkage_name (die
);
4530 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4531 sizeof (struct symbol
));
4532 OBJSTAT (objfile
, n_syms
++);
4533 memset (sym
, 0, sizeof (struct symbol
));
4534 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4535 &objfile
->symbol_obstack
);
4537 /* Default assumptions.
4538 Use the passed type or decode it from the die. */
4539 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4540 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4542 SYMBOL_TYPE (sym
) = type
;
4544 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4545 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4548 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4551 /* If this symbol is from a C++ compilation, then attempt to
4552 cache the demangled form for future reference. This is a
4553 typical time versus space tradeoff, that was decided in favor
4554 of time because it sped up C++ symbol lookups by a factor of
4557 SYMBOL_LANGUAGE (sym
) = cu_language
;
4558 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4562 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4565 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4567 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4569 case DW_TAG_subprogram
:
4570 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4572 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4573 attr2
= dwarf_attr (die
, DW_AT_external
);
4574 if (attr2
&& (DW_UNSND (attr2
) != 0))
4576 add_symbol_to_list (sym
, &global_symbols
);
4580 add_symbol_to_list (sym
, list_in_scope
);
4583 case DW_TAG_variable
:
4584 /* Compilation with minimal debug info may result in variables
4585 with missing type entries. Change the misleading `void' type
4586 to something sensible. */
4587 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4588 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4589 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4590 "<variable, no debug info>",
4592 attr
= dwarf_attr (die
, DW_AT_const_value
);
4595 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4596 attr2
= dwarf_attr (die
, DW_AT_external
);
4597 if (attr2
&& (DW_UNSND (attr2
) != 0))
4598 add_symbol_to_list (sym
, &global_symbols
);
4600 add_symbol_to_list (sym
, list_in_scope
);
4603 attr
= dwarf_attr (die
, DW_AT_location
);
4606 attr2
= dwarf_attr (die
, DW_AT_external
);
4607 if (attr2
&& (DW_UNSND (attr2
) != 0))
4609 SYMBOL_VALUE_ADDRESS (sym
) =
4610 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4611 add_symbol_to_list (sym
, &global_symbols
);
4613 /* In shared libraries the address of the variable
4614 in the location descriptor might still be relocatable,
4615 so its value could be zero.
4616 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4617 value is zero, the address of the variable will then
4618 be determined from the minimal symbol table whenever
4619 the variable is referenced. */
4620 if (SYMBOL_VALUE_ADDRESS (sym
))
4622 fixup_symbol_section (sym
, objfile
);
4623 SYMBOL_VALUE_ADDRESS (sym
) +=
4624 ANOFFSET (objfile
->section_offsets
,
4625 SYMBOL_SECTION (sym
));
4626 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4629 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4633 SYMBOL_VALUE (sym
) = addr
=
4634 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4635 add_symbol_to_list (sym
, list_in_scope
);
4638 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4642 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4643 SYMBOL_VALUE (sym
) =
4644 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4648 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4649 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4653 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4657 fixup_symbol_section (sym
, objfile
);
4658 SYMBOL_VALUE_ADDRESS (sym
) =
4659 addr
+ ANOFFSET (objfile
->section_offsets
,
4660 SYMBOL_SECTION (sym
));
4661 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4667 /* We do not know the address of this symbol.
4668 If it is an external symbol and we have type information
4669 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4670 The address of the variable will then be determined from
4671 the minimal symbol table whenever the variable is
4673 attr2
= dwarf_attr (die
, DW_AT_external
);
4674 if (attr2
&& (DW_UNSND (attr2
) != 0)
4675 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4677 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4678 add_symbol_to_list (sym
, &global_symbols
);
4682 case DW_TAG_formal_parameter
:
4683 attr
= dwarf_attr (die
, DW_AT_location
);
4686 SYMBOL_VALUE (sym
) =
4687 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4690 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4691 SYMBOL_VALUE (sym
) =
4692 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4698 if (basereg
!= frame_base_reg
)
4699 complain (&dwarf2_complex_location_expr
);
4700 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4704 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4705 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4710 SYMBOL_CLASS (sym
) = LOC_ARG
;
4713 attr
= dwarf_attr (die
, DW_AT_const_value
);
4716 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4718 add_symbol_to_list (sym
, list_in_scope
);
4720 case DW_TAG_unspecified_parameters
:
4721 /* From varargs functions; gdb doesn't seem to have any
4722 interest in this information, so just ignore it for now.
4725 case DW_TAG_class_type
:
4726 case DW_TAG_structure_type
:
4727 case DW_TAG_union_type
:
4728 case DW_TAG_enumeration_type
:
4729 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4730 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4731 add_symbol_to_list (sym
, list_in_scope
);
4733 /* The semantics of C++ state that "struct foo { ... }" also
4734 defines a typedef for "foo". Synthesize a typedef symbol so
4735 that "ptype foo" works as expected. */
4736 if (cu_language
== language_cplus
)
4738 struct symbol
*typedef_sym
= (struct symbol
*)
4739 obstack_alloc (&objfile
->symbol_obstack
,
4740 sizeof (struct symbol
));
4741 *typedef_sym
= *sym
;
4742 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4743 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4744 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4745 obsavestring (SYMBOL_NAME (sym
),
4746 strlen (SYMBOL_NAME (sym
)),
4747 &objfile
->type_obstack
);
4748 add_symbol_to_list (typedef_sym
, list_in_scope
);
4751 case DW_TAG_typedef
:
4752 case DW_TAG_base_type
:
4753 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4754 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4755 add_symbol_to_list (sym
, list_in_scope
);
4757 case DW_TAG_enumerator
:
4758 attr
= dwarf_attr (die
, DW_AT_const_value
);
4761 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4763 add_symbol_to_list (sym
, list_in_scope
);
4766 /* Not a tag we recognize. Hopefully we aren't processing
4767 trash data, but since we must specifically ignore things
4768 we don't recognize, there is nothing else we should do at
4770 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4777 /* Copy constant value from an attribute to a symbol. */
4780 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4781 struct objfile
*objfile
,
4782 const struct comp_unit_head
*cu_header
)
4784 struct dwarf_block
*blk
;
4789 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
4790 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4791 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4792 SYMBOL_VALUE_BYTES (sym
) = (char *)
4793 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
4794 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
4796 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4798 case DW_FORM_block1
:
4799 case DW_FORM_block2
:
4800 case DW_FORM_block4
:
4802 blk
= DW_BLOCK (attr
);
4803 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4804 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4805 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4806 SYMBOL_VALUE_BYTES (sym
) = (char *)
4807 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4808 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4809 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4812 /* The DW_AT_const_value attributes are supposed to carry the
4813 symbol's value "represented as it would be on the target
4814 architecture." By the time we get here, it's already been
4815 converted to host endianness, so we just need to sign- or
4816 zero-extend it as appropriate. */
4818 dwarf2_const_value_data (attr
, sym
, 8);
4821 dwarf2_const_value_data (attr
, sym
, 16);
4824 dwarf2_const_value_data (attr
, sym
, 32);
4827 dwarf2_const_value_data (attr
, sym
, 64);
4831 SYMBOL_VALUE (sym
) = DW_SND (attr
);
4832 SYMBOL_CLASS (sym
) = LOC_CONST
;
4836 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4837 SYMBOL_CLASS (sym
) = LOC_CONST
;
4841 complain (&dwarf2_unsupported_const_value_attr
,
4842 dwarf_form_name (attr
->form
));
4843 SYMBOL_VALUE (sym
) = 0;
4844 SYMBOL_CLASS (sym
) = LOC_CONST
;
4850 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
4851 or zero-extend it as appropriate for the symbol's type. */
4853 dwarf2_const_value_data (struct attribute
*attr
,
4857 LONGEST l
= DW_UNSND (attr
);
4859 if (bits
< sizeof (l
) * 8)
4861 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
4862 l
&= ((LONGEST
) 1 << bits
) - 1;
4864 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
4867 SYMBOL_VALUE (sym
) = l
;
4868 SYMBOL_CLASS (sym
) = LOC_CONST
;
4872 /* Return the type of the die in question using its DW_AT_type attribute. */
4874 static struct type
*
4875 die_type (struct die_info
*die
, struct objfile
*objfile
,
4876 const struct comp_unit_head
*cu_header
)
4879 struct attribute
*type_attr
;
4880 struct die_info
*type_die
;
4883 type_attr
= dwarf_attr (die
, DW_AT_type
);
4886 /* A missing DW_AT_type represents a void type. */
4887 return dwarf2_fundamental_type (objfile
, FT_VOID
);
4891 ref
= dwarf2_get_ref_die_offset (type_attr
);
4892 type_die
= follow_die_ref (ref
);
4895 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4899 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4902 dump_die (type_die
);
4903 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4908 /* Return the containing type of the die in question using its
4909 DW_AT_containing_type attribute. */
4911 static struct type
*
4912 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
4913 const struct comp_unit_head
*cu_header
)
4915 struct type
*type
= NULL
;
4916 struct attribute
*type_attr
;
4917 struct die_info
*type_die
= NULL
;
4920 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
4923 ref
= dwarf2_get_ref_die_offset (type_attr
);
4924 type_die
= follow_die_ref (ref
);
4927 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4930 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4935 dump_die (type_die
);
4936 error ("Dwarf Error: Problem turning containing type into gdb type.");
4942 static struct type
*
4943 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
4945 struct die_info
*die
;
4948 die
= follow_die_ref (offset
);
4951 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
4954 type
= tag_type_to_type (die
, objfile
);
4959 static struct type
*
4960 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
4961 const struct comp_unit_head
*cu_header
)
4969 read_type_die (die
, objfile
, cu_header
);
4973 error ("Dwarf Error: Cannot find type of die.");
4980 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
4981 const struct comp_unit_head
*cu_header
)
4985 case DW_TAG_class_type
:
4986 case DW_TAG_structure_type
:
4987 case DW_TAG_union_type
:
4988 read_structure_scope (die
, objfile
, cu_header
);
4990 case DW_TAG_enumeration_type
:
4991 read_enumeration (die
, objfile
, cu_header
);
4993 case DW_TAG_subprogram
:
4994 case DW_TAG_subroutine_type
:
4995 read_subroutine_type (die
, objfile
, cu_header
);
4997 case DW_TAG_array_type
:
4998 read_array_type (die
, objfile
, cu_header
);
5000 case DW_TAG_pointer_type
:
5001 read_tag_pointer_type (die
, objfile
, cu_header
);
5003 case DW_TAG_ptr_to_member_type
:
5004 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5006 case DW_TAG_reference_type
:
5007 read_tag_reference_type (die
, objfile
, cu_header
);
5009 case DW_TAG_const_type
:
5010 read_tag_const_type (die
, objfile
, cu_header
);
5012 case DW_TAG_volatile_type
:
5013 read_tag_volatile_type (die
, objfile
, cu_header
);
5015 case DW_TAG_string_type
:
5016 read_tag_string_type (die
, objfile
);
5018 case DW_TAG_typedef
:
5019 read_typedef (die
, objfile
, cu_header
);
5021 case DW_TAG_base_type
:
5022 read_base_type (die
, objfile
);
5025 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5030 static struct type
*
5031 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5033 /* FIXME - this should not produce a new (struct type *)
5034 every time. It should cache base types. */
5038 case DW_ATE_address
:
5039 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5041 case DW_ATE_boolean
:
5042 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5044 case DW_ATE_complex_float
:
5047 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5051 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5057 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5061 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5068 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5071 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5075 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5079 case DW_ATE_signed_char
:
5080 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5082 case DW_ATE_unsigned
:
5086 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5089 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5093 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5097 case DW_ATE_unsigned_char
:
5098 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5101 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5108 copy_die (struct die_info
*old_die
)
5110 struct die_info
*new_die
;
5113 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5114 memset (new_die
, 0, sizeof (struct die_info
));
5116 new_die
->tag
= old_die
->tag
;
5117 new_die
->has_children
= old_die
->has_children
;
5118 new_die
->abbrev
= old_die
->abbrev
;
5119 new_die
->offset
= old_die
->offset
;
5120 new_die
->type
= NULL
;
5122 num_attrs
= old_die
->num_attrs
;
5123 new_die
->num_attrs
= num_attrs
;
5124 new_die
->attrs
= (struct attribute
*)
5125 xmalloc (num_attrs
* sizeof (struct attribute
));
5127 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5129 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5130 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5131 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5134 new_die
->next
= NULL
;
5139 /* Return sibling of die, NULL if no sibling. */
5141 static struct die_info
*
5142 sibling_die (struct die_info
*die
)
5144 int nesting_level
= 0;
5146 if (!die
->has_children
)
5148 if (die
->next
&& (die
->next
->tag
== 0))
5161 if (die
->has_children
)
5171 while (nesting_level
);
5172 if (die
&& (die
->tag
== 0))
5183 /* Get linkage name of a die, return NULL if not found. */
5186 dwarf2_linkage_name (struct die_info
*die
)
5188 struct attribute
*attr
;
5190 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5191 if (attr
&& DW_STRING (attr
))
5192 return DW_STRING (attr
);
5193 attr
= dwarf_attr (die
, DW_AT_name
);
5194 if (attr
&& DW_STRING (attr
))
5195 return DW_STRING (attr
);
5199 /* Convert a DIE tag into its string name. */
5202 dwarf_tag_name (register unsigned tag
)
5206 case DW_TAG_padding
:
5207 return "DW_TAG_padding";
5208 case DW_TAG_array_type
:
5209 return "DW_TAG_array_type";
5210 case DW_TAG_class_type
:
5211 return "DW_TAG_class_type";
5212 case DW_TAG_entry_point
:
5213 return "DW_TAG_entry_point";
5214 case DW_TAG_enumeration_type
:
5215 return "DW_TAG_enumeration_type";
5216 case DW_TAG_formal_parameter
:
5217 return "DW_TAG_formal_parameter";
5218 case DW_TAG_imported_declaration
:
5219 return "DW_TAG_imported_declaration";
5221 return "DW_TAG_label";
5222 case DW_TAG_lexical_block
:
5223 return "DW_TAG_lexical_block";
5225 return "DW_TAG_member";
5226 case DW_TAG_pointer_type
:
5227 return "DW_TAG_pointer_type";
5228 case DW_TAG_reference_type
:
5229 return "DW_TAG_reference_type";
5230 case DW_TAG_compile_unit
:
5231 return "DW_TAG_compile_unit";
5232 case DW_TAG_string_type
:
5233 return "DW_TAG_string_type";
5234 case DW_TAG_structure_type
:
5235 return "DW_TAG_structure_type";
5236 case DW_TAG_subroutine_type
:
5237 return "DW_TAG_subroutine_type";
5238 case DW_TAG_typedef
:
5239 return "DW_TAG_typedef";
5240 case DW_TAG_union_type
:
5241 return "DW_TAG_union_type";
5242 case DW_TAG_unspecified_parameters
:
5243 return "DW_TAG_unspecified_parameters";
5244 case DW_TAG_variant
:
5245 return "DW_TAG_variant";
5246 case DW_TAG_common_block
:
5247 return "DW_TAG_common_block";
5248 case DW_TAG_common_inclusion
:
5249 return "DW_TAG_common_inclusion";
5250 case DW_TAG_inheritance
:
5251 return "DW_TAG_inheritance";
5252 case DW_TAG_inlined_subroutine
:
5253 return "DW_TAG_inlined_subroutine";
5255 return "DW_TAG_module";
5256 case DW_TAG_ptr_to_member_type
:
5257 return "DW_TAG_ptr_to_member_type";
5258 case DW_TAG_set_type
:
5259 return "DW_TAG_set_type";
5260 case DW_TAG_subrange_type
:
5261 return "DW_TAG_subrange_type";
5262 case DW_TAG_with_stmt
:
5263 return "DW_TAG_with_stmt";
5264 case DW_TAG_access_declaration
:
5265 return "DW_TAG_access_declaration";
5266 case DW_TAG_base_type
:
5267 return "DW_TAG_base_type";
5268 case DW_TAG_catch_block
:
5269 return "DW_TAG_catch_block";
5270 case DW_TAG_const_type
:
5271 return "DW_TAG_const_type";
5272 case DW_TAG_constant
:
5273 return "DW_TAG_constant";
5274 case DW_TAG_enumerator
:
5275 return "DW_TAG_enumerator";
5276 case DW_TAG_file_type
:
5277 return "DW_TAG_file_type";
5279 return "DW_TAG_friend";
5280 case DW_TAG_namelist
:
5281 return "DW_TAG_namelist";
5282 case DW_TAG_namelist_item
:
5283 return "DW_TAG_namelist_item";
5284 case DW_TAG_packed_type
:
5285 return "DW_TAG_packed_type";
5286 case DW_TAG_subprogram
:
5287 return "DW_TAG_subprogram";
5288 case DW_TAG_template_type_param
:
5289 return "DW_TAG_template_type_param";
5290 case DW_TAG_template_value_param
:
5291 return "DW_TAG_template_value_param";
5292 case DW_TAG_thrown_type
:
5293 return "DW_TAG_thrown_type";
5294 case DW_TAG_try_block
:
5295 return "DW_TAG_try_block";
5296 case DW_TAG_variant_part
:
5297 return "DW_TAG_variant_part";
5298 case DW_TAG_variable
:
5299 return "DW_TAG_variable";
5300 case DW_TAG_volatile_type
:
5301 return "DW_TAG_volatile_type";
5302 case DW_TAG_MIPS_loop
:
5303 return "DW_TAG_MIPS_loop";
5304 case DW_TAG_format_label
:
5305 return "DW_TAG_format_label";
5306 case DW_TAG_function_template
:
5307 return "DW_TAG_function_template";
5308 case DW_TAG_class_template
:
5309 return "DW_TAG_class_template";
5311 return "DW_TAG_<unknown>";
5315 /* Convert a DWARF attribute code into its string name. */
5318 dwarf_attr_name (register unsigned attr
)
5323 return "DW_AT_sibling";
5324 case DW_AT_location
:
5325 return "DW_AT_location";
5327 return "DW_AT_name";
5328 case DW_AT_ordering
:
5329 return "DW_AT_ordering";
5330 case DW_AT_subscr_data
:
5331 return "DW_AT_subscr_data";
5332 case DW_AT_byte_size
:
5333 return "DW_AT_byte_size";
5334 case DW_AT_bit_offset
:
5335 return "DW_AT_bit_offset";
5336 case DW_AT_bit_size
:
5337 return "DW_AT_bit_size";
5338 case DW_AT_element_list
:
5339 return "DW_AT_element_list";
5340 case DW_AT_stmt_list
:
5341 return "DW_AT_stmt_list";
5343 return "DW_AT_low_pc";
5345 return "DW_AT_high_pc";
5346 case DW_AT_language
:
5347 return "DW_AT_language";
5349 return "DW_AT_member";
5351 return "DW_AT_discr";
5352 case DW_AT_discr_value
:
5353 return "DW_AT_discr_value";
5354 case DW_AT_visibility
:
5355 return "DW_AT_visibility";
5357 return "DW_AT_import";
5358 case DW_AT_string_length
:
5359 return "DW_AT_string_length";
5360 case DW_AT_common_reference
:
5361 return "DW_AT_common_reference";
5362 case DW_AT_comp_dir
:
5363 return "DW_AT_comp_dir";
5364 case DW_AT_const_value
:
5365 return "DW_AT_const_value";
5366 case DW_AT_containing_type
:
5367 return "DW_AT_containing_type";
5368 case DW_AT_default_value
:
5369 return "DW_AT_default_value";
5371 return "DW_AT_inline";
5372 case DW_AT_is_optional
:
5373 return "DW_AT_is_optional";
5374 case DW_AT_lower_bound
:
5375 return "DW_AT_lower_bound";
5376 case DW_AT_producer
:
5377 return "DW_AT_producer";
5378 case DW_AT_prototyped
:
5379 return "DW_AT_prototyped";
5380 case DW_AT_return_addr
:
5381 return "DW_AT_return_addr";
5382 case DW_AT_start_scope
:
5383 return "DW_AT_start_scope";
5384 case DW_AT_stride_size
:
5385 return "DW_AT_stride_size";
5386 case DW_AT_upper_bound
:
5387 return "DW_AT_upper_bound";
5388 case DW_AT_abstract_origin
:
5389 return "DW_AT_abstract_origin";
5390 case DW_AT_accessibility
:
5391 return "DW_AT_accessibility";
5392 case DW_AT_address_class
:
5393 return "DW_AT_address_class";
5394 case DW_AT_artificial
:
5395 return "DW_AT_artificial";
5396 case DW_AT_base_types
:
5397 return "DW_AT_base_types";
5398 case DW_AT_calling_convention
:
5399 return "DW_AT_calling_convention";
5401 return "DW_AT_count";
5402 case DW_AT_data_member_location
:
5403 return "DW_AT_data_member_location";
5404 case DW_AT_decl_column
:
5405 return "DW_AT_decl_column";
5406 case DW_AT_decl_file
:
5407 return "DW_AT_decl_file";
5408 case DW_AT_decl_line
:
5409 return "DW_AT_decl_line";
5410 case DW_AT_declaration
:
5411 return "DW_AT_declaration";
5412 case DW_AT_discr_list
:
5413 return "DW_AT_discr_list";
5414 case DW_AT_encoding
:
5415 return "DW_AT_encoding";
5416 case DW_AT_external
:
5417 return "DW_AT_external";
5418 case DW_AT_frame_base
:
5419 return "DW_AT_frame_base";
5421 return "DW_AT_friend";
5422 case DW_AT_identifier_case
:
5423 return "DW_AT_identifier_case";
5424 case DW_AT_macro_info
:
5425 return "DW_AT_macro_info";
5426 case DW_AT_namelist_items
:
5427 return "DW_AT_namelist_items";
5428 case DW_AT_priority
:
5429 return "DW_AT_priority";
5431 return "DW_AT_segment";
5432 case DW_AT_specification
:
5433 return "DW_AT_specification";
5434 case DW_AT_static_link
:
5435 return "DW_AT_static_link";
5437 return "DW_AT_type";
5438 case DW_AT_use_location
:
5439 return "DW_AT_use_location";
5440 case DW_AT_variable_parameter
:
5441 return "DW_AT_variable_parameter";
5442 case DW_AT_virtuality
:
5443 return "DW_AT_virtuality";
5444 case DW_AT_vtable_elem_location
:
5445 return "DW_AT_vtable_elem_location";
5448 case DW_AT_MIPS_fde
:
5449 return "DW_AT_MIPS_fde";
5450 case DW_AT_MIPS_loop_begin
:
5451 return "DW_AT_MIPS_loop_begin";
5452 case DW_AT_MIPS_tail_loop_begin
:
5453 return "DW_AT_MIPS_tail_loop_begin";
5454 case DW_AT_MIPS_epilog_begin
:
5455 return "DW_AT_MIPS_epilog_begin";
5456 case DW_AT_MIPS_loop_unroll_factor
:
5457 return "DW_AT_MIPS_loop_unroll_factor";
5458 case DW_AT_MIPS_software_pipeline_depth
:
5459 return "DW_AT_MIPS_software_pipeline_depth";
5460 case DW_AT_MIPS_linkage_name
:
5461 return "DW_AT_MIPS_linkage_name";
5464 case DW_AT_sf_names
:
5465 return "DW_AT_sf_names";
5466 case DW_AT_src_info
:
5467 return "DW_AT_src_info";
5468 case DW_AT_mac_info
:
5469 return "DW_AT_mac_info";
5470 case DW_AT_src_coords
:
5471 return "DW_AT_src_coords";
5472 case DW_AT_body_begin
:
5473 return "DW_AT_body_begin";
5474 case DW_AT_body_end
:
5475 return "DW_AT_body_end";
5476 case DW_AT_GNU_vector
:
5477 return "DW_AT_GNU_vector";
5479 return "DW_AT_<unknown>";
5483 /* Convert a DWARF value form code into its string name. */
5486 dwarf_form_name (register unsigned form
)
5491 return "DW_FORM_addr";
5492 case DW_FORM_block2
:
5493 return "DW_FORM_block2";
5494 case DW_FORM_block4
:
5495 return "DW_FORM_block4";
5497 return "DW_FORM_data2";
5499 return "DW_FORM_data4";
5501 return "DW_FORM_data8";
5502 case DW_FORM_string
:
5503 return "DW_FORM_string";
5505 return "DW_FORM_block";
5506 case DW_FORM_block1
:
5507 return "DW_FORM_block1";
5509 return "DW_FORM_data1";
5511 return "DW_FORM_flag";
5513 return "DW_FORM_sdata";
5515 return "DW_FORM_strp";
5517 return "DW_FORM_udata";
5518 case DW_FORM_ref_addr
:
5519 return "DW_FORM_ref_addr";
5521 return "DW_FORM_ref1";
5523 return "DW_FORM_ref2";
5525 return "DW_FORM_ref4";
5527 return "DW_FORM_ref8";
5528 case DW_FORM_ref_udata
:
5529 return "DW_FORM_ref_udata";
5530 case DW_FORM_indirect
:
5531 return "DW_FORM_indirect";
5533 return "DW_FORM_<unknown>";
5537 /* Convert a DWARF stack opcode into its string name. */
5540 dwarf_stack_op_name (register unsigned op
)
5545 return "DW_OP_addr";
5547 return "DW_OP_deref";
5549 return "DW_OP_const1u";
5551 return "DW_OP_const1s";
5553 return "DW_OP_const2u";
5555 return "DW_OP_const2s";
5557 return "DW_OP_const4u";
5559 return "DW_OP_const4s";
5561 return "DW_OP_const8u";
5563 return "DW_OP_const8s";
5565 return "DW_OP_constu";
5567 return "DW_OP_consts";
5571 return "DW_OP_drop";
5573 return "DW_OP_over";
5575 return "DW_OP_pick";
5577 return "DW_OP_swap";
5581 return "DW_OP_xderef";
5589 return "DW_OP_minus";
5601 return "DW_OP_plus";
5602 case DW_OP_plus_uconst
:
5603 return "DW_OP_plus_uconst";
5609 return "DW_OP_shra";
5627 return "DW_OP_skip";
5629 return "DW_OP_lit0";
5631 return "DW_OP_lit1";
5633 return "DW_OP_lit2";
5635 return "DW_OP_lit3";
5637 return "DW_OP_lit4";
5639 return "DW_OP_lit5";
5641 return "DW_OP_lit6";
5643 return "DW_OP_lit7";
5645 return "DW_OP_lit8";
5647 return "DW_OP_lit9";
5649 return "DW_OP_lit10";
5651 return "DW_OP_lit11";
5653 return "DW_OP_lit12";
5655 return "DW_OP_lit13";
5657 return "DW_OP_lit14";
5659 return "DW_OP_lit15";
5661 return "DW_OP_lit16";
5663 return "DW_OP_lit17";
5665 return "DW_OP_lit18";
5667 return "DW_OP_lit19";
5669 return "DW_OP_lit20";
5671 return "DW_OP_lit21";
5673 return "DW_OP_lit22";
5675 return "DW_OP_lit23";
5677 return "DW_OP_lit24";
5679 return "DW_OP_lit25";
5681 return "DW_OP_lit26";
5683 return "DW_OP_lit27";
5685 return "DW_OP_lit28";
5687 return "DW_OP_lit29";
5689 return "DW_OP_lit30";
5691 return "DW_OP_lit31";
5693 return "DW_OP_reg0";
5695 return "DW_OP_reg1";
5697 return "DW_OP_reg2";
5699 return "DW_OP_reg3";
5701 return "DW_OP_reg4";
5703 return "DW_OP_reg5";
5705 return "DW_OP_reg6";
5707 return "DW_OP_reg7";
5709 return "DW_OP_reg8";
5711 return "DW_OP_reg9";
5713 return "DW_OP_reg10";
5715 return "DW_OP_reg11";
5717 return "DW_OP_reg12";
5719 return "DW_OP_reg13";
5721 return "DW_OP_reg14";
5723 return "DW_OP_reg15";
5725 return "DW_OP_reg16";
5727 return "DW_OP_reg17";
5729 return "DW_OP_reg18";
5731 return "DW_OP_reg19";
5733 return "DW_OP_reg20";
5735 return "DW_OP_reg21";
5737 return "DW_OP_reg22";
5739 return "DW_OP_reg23";
5741 return "DW_OP_reg24";
5743 return "DW_OP_reg25";
5745 return "DW_OP_reg26";
5747 return "DW_OP_reg27";
5749 return "DW_OP_reg28";
5751 return "DW_OP_reg29";
5753 return "DW_OP_reg30";
5755 return "DW_OP_reg31";
5757 return "DW_OP_breg0";
5759 return "DW_OP_breg1";
5761 return "DW_OP_breg2";
5763 return "DW_OP_breg3";
5765 return "DW_OP_breg4";
5767 return "DW_OP_breg5";
5769 return "DW_OP_breg6";
5771 return "DW_OP_breg7";
5773 return "DW_OP_breg8";
5775 return "DW_OP_breg9";
5777 return "DW_OP_breg10";
5779 return "DW_OP_breg11";
5781 return "DW_OP_breg12";
5783 return "DW_OP_breg13";
5785 return "DW_OP_breg14";
5787 return "DW_OP_breg15";
5789 return "DW_OP_breg16";
5791 return "DW_OP_breg17";
5793 return "DW_OP_breg18";
5795 return "DW_OP_breg19";
5797 return "DW_OP_breg20";
5799 return "DW_OP_breg21";
5801 return "DW_OP_breg22";
5803 return "DW_OP_breg23";
5805 return "DW_OP_breg24";
5807 return "DW_OP_breg25";
5809 return "DW_OP_breg26";
5811 return "DW_OP_breg27";
5813 return "DW_OP_breg28";
5815 return "DW_OP_breg29";
5817 return "DW_OP_breg30";
5819 return "DW_OP_breg31";
5821 return "DW_OP_regx";
5823 return "DW_OP_fbreg";
5825 return "DW_OP_bregx";
5827 return "DW_OP_piece";
5828 case DW_OP_deref_size
:
5829 return "DW_OP_deref_size";
5830 case DW_OP_xderef_size
:
5831 return "DW_OP_xderef_size";
5835 return "OP_<unknown>";
5840 dwarf_bool_name (unsigned mybool
)
5848 /* Convert a DWARF type code into its string name. */
5851 dwarf_type_encoding_name (register unsigned enc
)
5855 case DW_ATE_address
:
5856 return "DW_ATE_address";
5857 case DW_ATE_boolean
:
5858 return "DW_ATE_boolean";
5859 case DW_ATE_complex_float
:
5860 return "DW_ATE_complex_float";
5862 return "DW_ATE_float";
5864 return "DW_ATE_signed";
5865 case DW_ATE_signed_char
:
5866 return "DW_ATE_signed_char";
5867 case DW_ATE_unsigned
:
5868 return "DW_ATE_unsigned";
5869 case DW_ATE_unsigned_char
:
5870 return "DW_ATE_unsigned_char";
5872 return "DW_ATE_<unknown>";
5876 /* Convert a DWARF call frame info operation to its string name. */
5880 dwarf_cfi_name (register unsigned cfi_opc
)
5884 case DW_CFA_advance_loc
:
5885 return "DW_CFA_advance_loc";
5887 return "DW_CFA_offset";
5888 case DW_CFA_restore
:
5889 return "DW_CFA_restore";
5891 return "DW_CFA_nop";
5892 case DW_CFA_set_loc
:
5893 return "DW_CFA_set_loc";
5894 case DW_CFA_advance_loc1
:
5895 return "DW_CFA_advance_loc1";
5896 case DW_CFA_advance_loc2
:
5897 return "DW_CFA_advance_loc2";
5898 case DW_CFA_advance_loc4
:
5899 return "DW_CFA_advance_loc4";
5900 case DW_CFA_offset_extended
:
5901 return "DW_CFA_offset_extended";
5902 case DW_CFA_restore_extended
:
5903 return "DW_CFA_restore_extended";
5904 case DW_CFA_undefined
:
5905 return "DW_CFA_undefined";
5906 case DW_CFA_same_value
:
5907 return "DW_CFA_same_value";
5908 case DW_CFA_register
:
5909 return "DW_CFA_register";
5910 case DW_CFA_remember_state
:
5911 return "DW_CFA_remember_state";
5912 case DW_CFA_restore_state
:
5913 return "DW_CFA_restore_state";
5914 case DW_CFA_def_cfa
:
5915 return "DW_CFA_def_cfa";
5916 case DW_CFA_def_cfa_register
:
5917 return "DW_CFA_def_cfa_register";
5918 case DW_CFA_def_cfa_offset
:
5919 return "DW_CFA_def_cfa_offset";
5922 case DW_CFA_def_cfa_expression
:
5923 return "DW_CFA_def_cfa_expression";
5924 case DW_CFA_expression
:
5925 return "DW_CFA_expression";
5926 case DW_CFA_offset_extended_sf
:
5927 return "DW_CFA_offset_extended_sf";
5928 case DW_CFA_def_cfa_sf
:
5929 return "DW_CFA_def_cfa_sf";
5930 case DW_CFA_def_cfa_offset_sf
:
5931 return "DW_CFA_def_cfa_offset_sf";
5933 /* SGI/MIPS specific */
5934 case DW_CFA_MIPS_advance_loc8
:
5935 return "DW_CFA_MIPS_advance_loc8";
5937 /* GNU extensions */
5938 case DW_CFA_GNU_window_save
:
5939 return "DW_CFA_GNU_window_save";
5940 case DW_CFA_GNU_args_size
:
5941 return "DW_CFA_GNU_args_size";
5942 case DW_CFA_GNU_negative_offset_extended
:
5943 return "DW_CFA_GNU_negative_offset_extended";
5946 return "DW_CFA_<unknown>";
5952 dump_die (struct die_info
*die
)
5956 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
5957 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
5958 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
5959 dwarf_bool_name (die
->has_children
));
5961 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
5962 for (i
= 0; i
< die
->num_attrs
; ++i
)
5964 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
5965 dwarf_attr_name (die
->attrs
[i
].name
),
5966 dwarf_form_name (die
->attrs
[i
].form
));
5967 switch (die
->attrs
[i
].form
)
5969 case DW_FORM_ref_addr
:
5971 fprintf_unfiltered (gdb_stderr
, "address: ");
5972 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
5974 case DW_FORM_block2
:
5975 case DW_FORM_block4
:
5977 case DW_FORM_block1
:
5978 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
5989 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
5991 case DW_FORM_string
:
5993 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
5994 DW_STRING (&die
->attrs
[i
])
5995 ? DW_STRING (&die
->attrs
[i
]) : "");
5998 if (DW_UNSND (&die
->attrs
[i
]))
5999 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6001 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6003 case DW_FORM_indirect
:
6004 /* the reader will have reduced the indirect form to
6005 the "base form" so this form should not occur */
6006 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6009 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6010 die
->attrs
[i
].form
);
6012 fprintf_unfiltered (gdb_stderr
, "\n");
6017 dump_die_list (struct die_info
*die
)
6027 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6030 struct die_info
*old
;
6032 h
= (offset
% REF_HASH_SIZE
);
6033 old
= die_ref_table
[h
];
6034 die
->next_ref
= old
;
6035 die_ref_table
[h
] = die
;
6040 dwarf2_empty_hash_tables (void)
6042 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6046 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6048 unsigned int result
= 0;
6052 case DW_FORM_ref_addr
:
6053 result
= DW_ADDR (attr
);
6059 case DW_FORM_ref_udata
:
6060 result
= cu_header_offset
+ DW_UNSND (attr
);
6063 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6068 static struct die_info
*
6069 follow_die_ref (unsigned int offset
)
6071 struct die_info
*die
;
6074 h
= (offset
% REF_HASH_SIZE
);
6075 die
= die_ref_table
[h
];
6078 if (die
->offset
== offset
)
6082 die
= die
->next_ref
;
6087 static struct type
*
6088 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6090 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6092 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6096 /* Look for this particular type in the fundamental type vector. If
6097 one is not found, create and install one appropriate for the
6098 current language and the current target machine. */
6100 if (ftypes
[typeid] == NULL
)
6102 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6105 return (ftypes
[typeid]);
6108 /* Decode simple location descriptions.
6109 Given a pointer to a dwarf block that defines a location, compute
6110 the location and return the value.
6112 FIXME: This is a kludge until we figure out a better
6113 way to handle the location descriptions.
6114 Gdb's design does not mesh well with the DWARF2 notion of a location
6115 computing interpreter, which is a shame because the flexibility goes unused.
6116 FIXME: Implement more operations as necessary.
6118 A location description containing no operations indicates that the
6119 object is optimized out. The global optimized_out flag is set for
6120 those, the return value is meaningless.
6122 When the result is a register number, the global isreg flag is set,
6123 otherwise it is cleared.
6125 When the result is a base register offset, the global offreg flag is set
6126 and the register number is returned in basereg, otherwise it is cleared.
6128 When the DW_OP_fbreg operation is encountered without a corresponding
6129 DW_AT_frame_base attribute, the global islocal flag is set.
6130 Hopefully the machine dependent code knows how to set up a virtual
6131 frame pointer for the local references.
6133 Note that stack[0] is unused except as a default error return.
6134 Note that stack overflow is not yet handled. */
6137 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6138 const struct comp_unit_head
*cu_header
)
6141 int size
= blk
->size
;
6142 char *data
= blk
->data
;
6143 CORE_ADDR stack
[64];
6145 unsigned int bytes_read
, unsnd
;
6195 stack
[++stacki
] = op
- DW_OP_lit0
;
6231 stack
[++stacki
] = op
- DW_OP_reg0
;
6236 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6238 stack
[++stacki
] = unsnd
;
6274 basereg
= op
- DW_OP_breg0
;
6275 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6281 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6283 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6288 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6290 if (frame_base_reg
>= 0)
6293 basereg
= frame_base_reg
;
6294 stack
[stacki
] += frame_base_offset
;
6298 complain (&dwarf2_missing_at_frame_base
);
6304 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6305 cu_header
, &bytes_read
);
6310 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6315 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6320 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6325 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6330 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6335 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6340 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6346 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6351 stack
[stacki
+ 1] = stack
[stacki
];
6356 stack
[stacki
- 1] += stack
[stacki
];
6360 case DW_OP_plus_uconst
:
6361 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6366 stack
[stacki
- 1] -= stack
[stacki
];
6372 /* If we're not the last op, then we definitely can't encode
6373 this using GDB's address_class enum. */
6375 complain (&dwarf2_complex_location_expr
);
6379 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6380 return (stack
[stacki
]);
6383 return (stack
[stacki
]);
6386 /* memory allocation interface */
6390 dwarf2_free_tmp_obstack (PTR ignore
)
6392 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6395 static struct dwarf_block
*
6396 dwarf_alloc_block (void)
6398 struct dwarf_block
*blk
;
6400 blk
= (struct dwarf_block
*)
6401 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6405 static struct abbrev_info
*
6406 dwarf_alloc_abbrev (void)
6408 struct abbrev_info
*abbrev
;
6410 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6411 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6415 static struct die_info
*
6416 dwarf_alloc_die (void)
6418 struct die_info
*die
;
6420 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6421 memset (die
, 0, sizeof (struct die_info
));
6426 /* Macro support. */
6429 /* Return the full name of file number I in *LH's file name table.
6430 Use COMP_DIR as the name of the current directory of the
6431 compilation. The result is allocated using xmalloc; the caller is
6432 responsible for freeing it. */
6434 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6436 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6438 if (IS_ABSOLUTE_PATH (fe
->name
))
6439 return xstrdup (fe
->name
);
6447 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6453 dir_len
= strlen (dir
);
6454 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6455 strcpy (full_name
, dir
);
6456 full_name
[dir_len
] = '/';
6457 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6461 return xstrdup (fe
->name
);
6466 static struct macro_source_file
*
6467 macro_start_file (int file
, int line
,
6468 struct macro_source_file
*current_file
,
6469 const char *comp_dir
,
6470 struct line_header
*lh
, struct objfile
*objfile
)
6472 /* The full name of this source file. */
6473 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6475 /* We don't create a macro table for this compilation unit
6476 at all until we actually get a filename. */
6477 if (! pending_macros
)
6478 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6479 &objfile
->macro_cache
);
6482 /* If we have no current file, then this must be the start_file
6483 directive for the compilation unit's main source file. */
6484 current_file
= macro_set_main (pending_macros
, full_name
);
6486 current_file
= macro_include (current_file
, line
, full_name
);
6490 return current_file
;
6494 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6495 followed by a null byte. */
6497 copy_string (const char *buf
, int len
)
6499 char *s
= xmalloc (len
+ 1);
6500 memcpy (s
, buf
, len
);
6508 consume_improper_spaces (const char *p
, const char *body
)
6512 complain (&dwarf2_macro_spaces_in_definition
, body
);
6523 parse_macro_definition (struct macro_source_file
*file
, int line
,
6528 /* The body string takes one of two forms. For object-like macro
6529 definitions, it should be:
6531 <macro name> " " <definition>
6533 For function-like macro definitions, it should be:
6535 <macro name> "() " <definition>
6537 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6539 Spaces may appear only where explicitly indicated, and in the
6542 The Dwarf 2 spec says that an object-like macro's name is always
6543 followed by a space, but versions of GCC around March 2002 omit
6544 the space when the macro's definition is the empty string.
6546 The Dwarf 2 spec says that there should be no spaces between the
6547 formal arguments in a function-like macro's formal argument list,
6548 but versions of GCC around March 2002 include spaces after the
6552 /* Find the extent of the macro name. The macro name is terminated
6553 by either a space or null character (for an object-like macro) or
6554 an opening paren (for a function-like macro). */
6555 for (p
= body
; *p
; p
++)
6556 if (*p
== ' ' || *p
== '(')
6559 if (*p
== ' ' || *p
== '\0')
6561 /* It's an object-like macro. */
6562 int name_len
= p
- body
;
6563 char *name
= copy_string (body
, name_len
);
6564 const char *replacement
;
6567 replacement
= body
+ name_len
+ 1;
6570 complain (&dwarf2_macro_malformed_definition
, body
);
6571 replacement
= body
+ name_len
;
6574 macro_define_object (file
, line
, name
, replacement
);
6580 /* It's a function-like macro. */
6581 char *name
= copy_string (body
, p
- body
);
6584 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6588 p
= consume_improper_spaces (p
, body
);
6590 /* Parse the formal argument list. */
6591 while (*p
&& *p
!= ')')
6593 /* Find the extent of the current argument name. */
6594 const char *arg_start
= p
;
6596 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6599 if (! *p
|| p
== arg_start
)
6600 complain (&dwarf2_macro_malformed_definition
,
6604 /* Make sure argv has room for the new argument. */
6605 if (argc
>= argv_size
)
6608 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6611 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6614 p
= consume_improper_spaces (p
, body
);
6616 /* Consume the comma, if present. */
6621 p
= consume_improper_spaces (p
, body
);
6630 /* Perfectly formed definition, no complaints. */
6631 macro_define_function (file
, line
, name
,
6632 argc
, (const char **) argv
,
6634 else if (*p
== '\0')
6636 /* Complain, but do define it. */
6637 complain (&dwarf2_macro_malformed_definition
, body
);
6638 macro_define_function (file
, line
, name
,
6639 argc
, (const char **) argv
,
6643 /* Just complain. */
6644 complain (&dwarf2_macro_malformed_definition
, body
);
6647 /* Just complain. */
6648 complain (&dwarf2_macro_malformed_definition
, body
);
6654 for (i
= 0; i
< argc
; i
++)
6660 complain (&dwarf2_macro_malformed_definition
, body
);
6665 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
6666 char *comp_dir
, bfd
*abfd
,
6667 const struct comp_unit_head
*cu_header
,
6668 struct objfile
*objfile
)
6670 char *mac_ptr
, *mac_end
;
6671 struct macro_source_file
*current_file
= 0;
6673 if (dwarf_macinfo_buffer
== NULL
)
6675 complain (&dwarf2_missing_macinfo_section
);
6679 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
6680 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
6684 enum dwarf_macinfo_record_type macinfo_type
;
6686 /* Do we at least have room for a macinfo type byte? */
6687 if (mac_ptr
>= mac_end
)
6689 complain (&dwarf2_macros_too_long
);
6693 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
6696 switch (macinfo_type
)
6698 /* A zero macinfo type indicates the end of the macro
6703 case DW_MACINFO_define
:
6704 case DW_MACINFO_undef
:
6710 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6711 mac_ptr
+= bytes_read
;
6712 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
6713 mac_ptr
+= bytes_read
;
6716 complain (&dwarf2_macro_outside_file
,
6717 macinfo_type
== DW_MACINFO_define
? "definition" :
6718 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
6719 "something-or-other",
6723 if (macinfo_type
== DW_MACINFO_define
)
6724 parse_macro_definition (current_file
, line
, body
);
6725 else if (macinfo_type
== DW_MACINFO_undef
)
6726 macro_undef (current_file
, line
, body
);
6731 case DW_MACINFO_start_file
:
6736 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6737 mac_ptr
+= bytes_read
;
6738 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6739 mac_ptr
+= bytes_read
;
6741 current_file
= macro_start_file (file
, line
,
6742 current_file
, comp_dir
,
6747 case DW_MACINFO_end_file
:
6749 complain (&dwarf2_macro_unmatched_end_file
);
6752 current_file
= current_file
->included_by
;
6755 enum dwarf_macinfo_record_type next_type
;
6757 /* GCC circa March 2002 doesn't produce the zero
6758 type byte marking the end of the compilation
6759 unit. Complain if it's not there, but exit no
6762 /* Do we at least have room for a macinfo type byte? */
6763 if (mac_ptr
>= mac_end
)
6765 complain (&dwarf2_macros_too_long
);
6769 /* We don't increment mac_ptr here, so this is just
6771 next_type
= read_1_byte (abfd
, mac_ptr
);
6773 complain (&dwarf2_macros_not_terminated
);
6780 case DW_MACINFO_vendor_ext
:
6786 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6787 mac_ptr
+= bytes_read
;
6788 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
6789 mac_ptr
+= bytes_read
;
6791 /* We don't recognize any vendor extensions. */