1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
11 support in dwarfread.c
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or (at
18 your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330,
28 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
51 #include <sys/types.h>
53 #ifndef DWARF2_REG_TO_REGNUM
54 #define DWARF2_REG_TO_REGNUM(REG) (REG)
58 /* .debug_info header for a compilation unit
59 Because of alignment constraints, this structure has padding and cannot
60 be mapped directly onto the beginning of the .debug_info section. */
61 typedef struct comp_unit_header
63 unsigned int length; /* length of the .debug_info
65 unsigned short version; /* version number -- 2 for DWARF
67 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
68 unsigned char addr_size; /* byte size of an address -- 4 */
71 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
74 /* .debug_pubnames header
75 Because of alignment constraints, this structure has padding and cannot
76 be mapped directly onto the beginning of the .debug_info section. */
77 typedef struct pubnames_header
79 unsigned int length; /* length of the .debug_pubnames
81 unsigned char version; /* version number -- 2 for DWARF
83 unsigned int info_offset; /* offset into .debug_info section */
84 unsigned int info_size; /* byte size of .debug_info section
88 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
90 /* .debug_pubnames header
91 Because of alignment constraints, this structure has padding and cannot
92 be mapped directly onto the beginning of the .debug_info section. */
93 typedef struct aranges_header
95 unsigned int length; /* byte len of the .debug_aranges
97 unsigned short version; /* version number -- 2 for DWARF
99 unsigned int info_offset; /* offset into .debug_info section */
100 unsigned char addr_size; /* byte size of an address */
101 unsigned char seg_size; /* byte size of segment descriptor */
104 #define _ACTUAL_ARANGES_HEADER_SIZE 12
106 /* .debug_line statement program prologue
107 Because of alignment constraints, this structure has padding and cannot
108 be mapped directly onto the beginning of the .debug_info section. */
109 typedef struct statement_prologue
111 unsigned int total_length; /* byte length of the statement
113 unsigned short version; /* version number -- 2 for DWARF
115 unsigned int prologue_length; /* # bytes between prologue &
117 unsigned char minimum_instruction_length; /* byte size of
119 unsigned char default_is_stmt; /* initial value of is_stmt
122 unsigned char line_range;
123 unsigned char opcode_base; /* number assigned to first special
125 unsigned char *standard_opcode_lengths;
129 /* offsets and sizes of debugging sections */
131 static unsigned int dwarf_info_size;
132 static unsigned int dwarf_abbrev_size;
133 static unsigned int dwarf_line_size;
134 static unsigned int dwarf_pubnames_size;
135 static unsigned int dwarf_aranges_size;
136 static unsigned int dwarf_loc_size;
137 static unsigned int dwarf_macinfo_size;
138 static unsigned int dwarf_str_size;
139 static unsigned int dwarf_ranges_size;
140 unsigned int dwarf_frame_size;
141 unsigned int dwarf_eh_frame_size;
143 static asection *dwarf_info_section;
144 static asection *dwarf_abbrev_section;
145 static asection *dwarf_line_section;
146 static asection *dwarf_pubnames_section;
147 static asection *dwarf_aranges_section;
148 static asection *dwarf_loc_section;
149 static asection *dwarf_macinfo_section;
150 static asection *dwarf_str_section;
151 static asection *dwarf_ranges_section;
152 asection *dwarf_frame_section;
153 asection *dwarf_eh_frame_section;
155 /* names of the debugging sections */
157 #define INFO_SECTION ".debug_info"
158 #define ABBREV_SECTION ".debug_abbrev"
159 #define LINE_SECTION ".debug_line"
160 #define PUBNAMES_SECTION ".debug_pubnames"
161 #define ARANGES_SECTION ".debug_aranges"
162 #define LOC_SECTION ".debug_loc"
163 #define MACINFO_SECTION ".debug_macinfo"
164 #define STR_SECTION ".debug_str"
165 #define RANGES_SECTION ".debug_ranges"
166 #define FRAME_SECTION ".debug_frame"
167 #define EH_FRAME_SECTION ".eh_frame"
169 /* local data types */
171 /* We hold several abbreviation tables in memory at the same time. */
172 #ifndef ABBREV_HASH_SIZE
173 #define ABBREV_HASH_SIZE 121
176 /* The data in a compilation unit header, after target2host
177 translation, looks like this. */
178 struct comp_unit_head
180 unsigned long length;
182 unsigned int abbrev_offset;
183 unsigned char addr_size;
184 unsigned char signed_addr_p;
185 unsigned int offset_size; /* size of file offsets; either 4 or 8 */
186 unsigned int initial_length_size; /* size of the length field; either
189 /* Offset to the first byte of this compilation unit header in the
190 * .debug_info section, for resolving relative reference dies. */
194 /* Pointer to this compilation unit header in the .debug_info
199 /* Pointer to the first die of this compilatio unit. This will
200 * be the first byte following the compilation unit header. */
204 /* Pointer to the next compilation unit header in the program. */
206 struct comp_unit_head *next;
208 /* DWARF abbreviation table associated with this compilation unit */
210 struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
212 /* Base address of this compilation unit. */
214 CORE_ADDR base_address;
216 /* Non-zero if base_address has been set. */
221 /* Internal state when decoding a particular compilation unit. */
224 /* The objfile containing this compilation unit. */
225 struct objfile *objfile;
227 /* The header of the compilation unit.
229 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
230 should be moved to the dwarf2_cu structure; for instance the abbrevs
232 struct comp_unit_head header;
234 struct function_range *first_fn, *last_fn, *cached_fn;
236 /* The language we are debugging. */
237 enum language language;
238 const struct language_defn *language_defn;
240 /* The generic symbol table building routines have separate lists for
241 file scope symbols and all all other scopes (local scopes). So
242 we need to select the right one to pass to add_symbol_to_list().
243 We do it by keeping a pointer to the correct list in list_in_scope.
245 FIXME: The original dwarf code just treated the file scope as the
246 first local scope, and all other local scopes as nested local
247 scopes, and worked fine. Check to see if we really need to
248 distinguish these in buildsym.c. */
249 struct pending **list_in_scope;
251 /* Maintain an array of referenced fundamental types for the current
252 compilation unit being read. For DWARF version 1, we have to construct
253 the fundamental types on the fly, since no information about the
254 fundamental types is supplied. Each such fundamental type is created by
255 calling a language dependent routine to create the type, and then a
256 pointer to that type is then placed in the array at the index specified
257 by it's FT_<TYPENAME> value. The array has a fixed size set by the
258 FT_NUM_MEMBERS compile time constant, which is the number of predefined
259 fundamental types gdb knows how to construct. */
260 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
263 /* The line number information for a compilation unit (found in the
264 .debug_line section) begins with a "statement program header",
265 which contains the following information. */
268 unsigned int total_length;
269 unsigned short version;
270 unsigned int header_length;
271 unsigned char minimum_instruction_length;
272 unsigned char default_is_stmt;
274 unsigned char line_range;
275 unsigned char opcode_base;
277 /* standard_opcode_lengths[i] is the number of operands for the
278 standard opcode whose value is i. This means that
279 standard_opcode_lengths[0] is unused, and the last meaningful
280 element is standard_opcode_lengths[opcode_base - 1]. */
281 unsigned char *standard_opcode_lengths;
283 /* The include_directories table. NOTE! These strings are not
284 allocated with xmalloc; instead, they are pointers into
285 debug_line_buffer. If you try to free them, `free' will get
287 unsigned int num_include_dirs, include_dirs_size;
290 /* The file_names table. NOTE! These strings are not allocated
291 with xmalloc; instead, they are pointers into debug_line_buffer.
292 Don't try to free them directly. */
293 unsigned int num_file_names, file_names_size;
297 unsigned int dir_index;
298 unsigned int mod_time;
302 /* The start and end of the statement program following this
303 header. These point into dwarf_line_buffer. */
304 char *statement_program_start, *statement_program_end;
307 /* When we construct a partial symbol table entry we only
308 need this much information. */
309 struct partial_die_info
312 unsigned char has_children;
313 unsigned char is_external;
314 unsigned char is_declaration;
315 unsigned char has_type;
322 struct dwarf_block *locdesc;
323 unsigned int language;
327 /* This data structure holds the information of an abbrev. */
330 unsigned int number; /* number identifying abbrev */
331 enum dwarf_tag tag; /* dwarf tag */
332 int has_children; /* boolean */
333 unsigned int num_attrs; /* number of attributes */
334 struct attr_abbrev *attrs; /* an array of attribute descriptions */
335 struct abbrev_info *next; /* next in chain */
340 enum dwarf_attribute name;
341 enum dwarf_form form;
344 /* This data structure holds a complete die structure. */
347 enum dwarf_tag tag; /* Tag indicating type of die */
348 unsigned int abbrev; /* Abbrev number */
349 unsigned int offset; /* Offset in .debug_info section */
350 unsigned int num_attrs; /* Number of attributes */
351 struct attribute *attrs; /* An array of attributes */
352 struct die_info *next_ref; /* Next die in ref hash table */
354 /* The dies in a compilation unit form an n-ary tree. PARENT
355 points to this die's parent; CHILD points to the first child of
356 this node; and all the children of a given node are chained
357 together via their SIBLING fields, terminated by a die whose
359 struct die_info *child; /* Its first child, if any. */
360 struct die_info *sibling; /* Its next sibling, if any. */
361 struct die_info *parent; /* Its parent, if any. */
363 struct type *type; /* Cached type information */
366 /* Attributes have a name and a value */
369 enum dwarf_attribute name;
370 enum dwarf_form form;
374 struct dwarf_block *blk;
382 struct function_range
385 CORE_ADDR lowpc, highpc;
387 struct function_range *next;
390 /* Get at parts of an attribute structure */
392 #define DW_STRING(attr) ((attr)->u.str)
393 #define DW_UNSND(attr) ((attr)->u.unsnd)
394 #define DW_BLOCK(attr) ((attr)->u.blk)
395 #define DW_SND(attr) ((attr)->u.snd)
396 #define DW_ADDR(attr) ((attr)->u.addr)
398 /* Blocks are a bunch of untyped bytes. */
405 #ifndef ATTR_ALLOC_CHUNK
406 #define ATTR_ALLOC_CHUNK 4
409 /* A hash table of die offsets for following references. */
410 #ifndef REF_HASH_SIZE
411 #define REF_HASH_SIZE 1021
414 static struct die_info *die_ref_table[REF_HASH_SIZE];
416 /* Obstack for allocating temporary storage used during symbol reading. */
417 static struct obstack dwarf2_tmp_obstack;
419 /* Allocate fields for structs, unions and enums in this size. */
420 #ifndef DW_FIELD_ALLOC_CHUNK
421 #define DW_FIELD_ALLOC_CHUNK 4
424 /* Actually data from the sections. */
425 static char *dwarf_info_buffer;
426 static char *dwarf_abbrev_buffer;
427 static char *dwarf_line_buffer;
428 static char *dwarf_str_buffer;
429 static char *dwarf_macinfo_buffer;
430 static char *dwarf_ranges_buffer;
431 static char *dwarf_loc_buffer;
433 /* A zeroed version of a partial die for initialization purposes. */
434 static struct partial_die_info zeroed_partial_die;
436 /* FIXME: decode_locdesc sets these variables to describe the location
437 to the caller. These ought to be a structure or something. If
438 none of the flags are set, the object lives at the address returned
439 by decode_locdesc. */
441 static int isreg; /* Object lives in register.
442 decode_locdesc's return value is
443 the register number. */
445 /* We put a pointer to this structure in the read_symtab_private field
447 The complete dwarf information for an objfile is kept in the
448 objfile_obstack, so that absolute die references can be handled.
449 Most of the information in this structure is related to an entire
450 object file and could be passed via the sym_private field of the objfile.
451 It is however conceivable that dwarf2 might not be the only type
452 of symbols read from an object file. */
456 /* Pointer to start of dwarf info buffer for the objfile. */
458 char *dwarf_info_buffer;
460 /* Offset in dwarf_info_buffer for this compilation unit. */
462 unsigned long dwarf_info_offset;
464 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
466 char *dwarf_abbrev_buffer;
468 /* Size of dwarf abbreviation section for the objfile. */
470 unsigned int dwarf_abbrev_size;
472 /* Pointer to start of dwarf line buffer for the objfile. */
474 char *dwarf_line_buffer;
476 /* Size of dwarf_line_buffer, in bytes. */
478 unsigned int dwarf_line_size;
480 /* Pointer to start of dwarf string buffer for the objfile. */
482 char *dwarf_str_buffer;
484 /* Size of dwarf string section for the objfile. */
486 unsigned int dwarf_str_size;
488 /* Pointer to start of dwarf macro buffer for the objfile. */
490 char *dwarf_macinfo_buffer;
492 /* Size of dwarf macinfo section for the objfile. */
494 unsigned int dwarf_macinfo_size;
496 /* Pointer to start of dwarf ranges buffer for the objfile. */
498 char *dwarf_ranges_buffer;
500 /* Size of dwarf ranges buffer for the objfile. */
502 unsigned int dwarf_ranges_size;
504 /* Pointer to start of dwarf locations buffer for the objfile. */
506 char *dwarf_loc_buffer;
508 /* Size of dwarf locations buffer for the objfile. */
510 unsigned int dwarf_loc_size;
513 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
514 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
515 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
516 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
517 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
518 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
519 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
520 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
521 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
522 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
523 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
524 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
525 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
526 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
527 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
529 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
530 but this would require a corresponding change in unpack_field_as_long
532 static int bits_per_byte = 8;
534 /* The routines that read and process dies for a C struct or C++ class
535 pass lists of data member fields and lists of member function fields
536 in an instance of a field_info structure, as defined below. */
539 /* List of data member and baseclasses fields. */
542 struct nextfield *next;
549 /* Number of fields. */
552 /* Number of baseclasses. */
555 /* Set if the accesibility of one of the fields is not public. */
556 int non_public_fields;
558 /* Member function fields array, entries are allocated in the order they
559 are encountered in the object file. */
562 struct nextfnfield *next;
563 struct fn_field fnfield;
567 /* Member function fieldlist array, contains name of possibly overloaded
568 member function, number of overloaded member functions and a pointer
569 to the head of the member function field chain. */
574 struct nextfnfield *head;
578 /* Number of entries in the fnfieldlists array. */
582 /* Various complaints about symbol reading that don't abort the process */
585 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
587 complaint (&symfile_complaints,
588 "statement list doesn't fit in .debug_line section");
592 dwarf2_complex_location_expr_complaint (void)
594 complaint (&symfile_complaints, "location expression too complex");
598 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
601 complaint (&symfile_complaints,
602 "const value length mismatch for '%s', got %d, expected %d", arg1,
607 dwarf2_macros_too_long_complaint (void)
609 complaint (&symfile_complaints,
610 "macro info runs off end of `.debug_macinfo' section");
614 dwarf2_macro_malformed_definition_complaint (const char *arg1)
616 complaint (&symfile_complaints,
617 "macro debug info contains a malformed macro definition:\n`%s'",
622 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
624 complaint (&symfile_complaints,
625 "invalid attribute class or form for '%s' in '%s'", arg1, arg2);
628 /* local function prototypes */
630 static void dwarf2_locate_sections (bfd *, asection *, void *);
633 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
636 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
638 static char *scan_partial_symbols (char *, CORE_ADDR *, CORE_ADDR *,
640 const char *namespace);
642 static void add_partial_symbol (struct partial_die_info *, struct dwarf2_cu *,
643 const char *namespace);
645 static int pdi_needs_namespace (enum dwarf_tag tag, const char *namespace);
647 static char *add_partial_namespace (struct partial_die_info *pdi,
649 CORE_ADDR *lowpc, CORE_ADDR *highpc,
650 struct dwarf2_cu *cu,
651 const char *namespace);
653 static char *add_partial_structure (struct partial_die_info *struct_pdi,
655 struct dwarf2_cu *cu,
656 const char *namespace);
658 static char *add_partial_enumeration (struct partial_die_info *enum_pdi,
660 struct dwarf2_cu *cu,
661 const char *namespace);
663 static char *locate_pdi_sibling (struct partial_die_info *orig_pdi,
666 struct dwarf2_cu *cu);
668 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
670 static void psymtab_to_symtab_1 (struct partial_symtab *);
672 char *dwarf2_read_section (struct objfile *, asection *);
674 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
676 static void dwarf2_empty_abbrev_table (void *);
678 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
681 static char *read_partial_die (struct partial_die_info *,
682 bfd *, char *, struct dwarf2_cu *);
684 static char *read_full_die (struct die_info **, bfd *, char *,
685 struct dwarf2_cu *, int *);
687 static char *read_attribute (struct attribute *, struct attr_abbrev *,
688 bfd *, char *, struct dwarf2_cu *);
690 static char *read_attribute_value (struct attribute *, unsigned,
691 bfd *, char *, struct dwarf2_cu *);
693 static unsigned int read_1_byte (bfd *, char *);
695 static int read_1_signed_byte (bfd *, char *);
697 static unsigned int read_2_bytes (bfd *, char *);
699 static unsigned int read_4_bytes (bfd *, char *);
701 static unsigned long read_8_bytes (bfd *, char *);
703 static CORE_ADDR read_address (bfd *, char *ptr, struct dwarf2_cu *,
706 static LONGEST read_initial_length (bfd *, char *,
707 struct comp_unit_head *, int *bytes_read);
709 static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *,
712 static char *read_n_bytes (bfd *, char *, unsigned int);
714 static char *read_string (bfd *, char *, unsigned int *);
716 static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
719 static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
721 static long read_signed_leb128 (bfd *, char *, unsigned int *);
723 static void set_cu_language (unsigned int, struct dwarf2_cu *);
725 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
728 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
730 static struct die_info *die_specification (struct die_info *die,
733 static void free_line_header (struct line_header *lh);
735 static struct line_header *(dwarf_decode_line_header
736 (unsigned int offset,
737 bfd *abfd, struct dwarf2_cu *cu));
739 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
742 static void dwarf2_start_subfile (char *, char *);
744 static struct symbol *new_symbol (struct die_info *, struct type *,
747 static void dwarf2_const_value (struct attribute *, struct symbol *,
750 static void dwarf2_const_value_data (struct attribute *attr,
754 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
756 static struct type *die_containing_type (struct die_info *,
760 static struct type *type_at_offset (unsigned int, struct objfile *);
763 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
765 static void read_type_die (struct die_info *, struct dwarf2_cu *);
767 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
769 static char *typename_concat (const char *prefix, const char *suffix);
771 static void read_typedef (struct die_info *, struct dwarf2_cu *);
773 static void read_base_type (struct die_info *, struct dwarf2_cu *);
775 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
777 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
779 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
781 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
783 static int dwarf2_get_pc_bounds (struct die_info *,
784 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
786 static void get_scope_pc_bounds (struct die_info *,
787 CORE_ADDR *, CORE_ADDR *,
790 static void dwarf2_add_field (struct field_info *, struct die_info *,
793 static void dwarf2_attach_fields_to_type (struct field_info *,
794 struct type *, struct dwarf2_cu *);
796 static void dwarf2_add_member_fn (struct field_info *,
797 struct die_info *, struct type *,
800 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
801 struct type *, struct dwarf2_cu *);
803 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
805 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
807 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
809 static void read_common_block (struct die_info *, struct dwarf2_cu *);
811 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
813 static const char *namespace_name (struct die_info *die,
814 int *is_anonymous, struct dwarf2_cu *);
816 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
818 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
820 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
822 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
824 static void read_array_type (struct die_info *, struct dwarf2_cu *);
826 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
828 static void read_tag_ptr_to_member_type (struct die_info *,
831 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
833 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
835 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
837 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
839 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
841 static struct die_info *read_comp_unit (char *, bfd *, struct dwarf2_cu *);
843 static struct die_info *read_die_and_children (char *info_ptr, bfd *abfd,
846 struct die_info *parent);
848 static struct die_info *read_die_and_siblings (char *info_ptr, bfd *abfd,
851 struct die_info *parent);
853 static void free_die_list (struct die_info *);
855 static struct cleanup *make_cleanup_free_die_list (struct die_info *);
857 static void process_die (struct die_info *, struct dwarf2_cu *);
859 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
861 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
863 static struct die_info *dwarf2_extension (struct die_info *die,
866 static char *dwarf_tag_name (unsigned int);
868 static char *dwarf_attr_name (unsigned int);
870 static char *dwarf_form_name (unsigned int);
872 static char *dwarf_stack_op_name (unsigned int);
874 static char *dwarf_bool_name (unsigned int);
876 static char *dwarf_type_encoding_name (unsigned int);
879 static char *dwarf_cfi_name (unsigned int);
881 struct die_info *copy_die (struct die_info *);
884 static struct die_info *sibling_die (struct die_info *);
886 static void dump_die (struct die_info *);
888 static void dump_die_list (struct die_info *);
890 static void store_in_ref_table (unsigned int, struct die_info *);
892 static void dwarf2_empty_hash_tables (void);
894 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
897 static int dwarf2_get_attr_constant_value (struct attribute *, int);
899 static struct die_info *follow_die_ref (unsigned int);
901 static struct type *dwarf2_fundamental_type (struct objfile *, int,
904 /* memory allocation interface */
906 static void dwarf2_free_tmp_obstack (void *);
908 static struct dwarf_block *dwarf_alloc_block (void);
910 static struct abbrev_info *dwarf_alloc_abbrev (void);
912 static struct die_info *dwarf_alloc_die (void);
914 static void initialize_cu_func_list (struct dwarf2_cu *);
916 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
919 static void dwarf_decode_macros (struct line_header *, unsigned int,
920 char *, bfd *, struct dwarf2_cu *);
922 static int attr_form_is_block (struct attribute *);
925 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
926 struct dwarf2_cu *cu);
928 /* Try to locate the sections we need for DWARF 2 debugging
929 information and return true if we have enough to do something. */
932 dwarf2_has_info (bfd *abfd)
934 dwarf_info_section = 0;
935 dwarf_abbrev_section = 0;
936 dwarf_line_section = 0;
937 dwarf_str_section = 0;
938 dwarf_macinfo_section = 0;
939 dwarf_frame_section = 0;
940 dwarf_eh_frame_section = 0;
941 dwarf_ranges_section = 0;
942 dwarf_loc_section = 0;
944 bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
945 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
948 /* This function is mapped across the sections and remembers the
949 offset and size of each of the debugging sections we are interested
953 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
955 if (strcmp (sectp->name, INFO_SECTION) == 0)
957 dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
958 dwarf_info_section = sectp;
960 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
962 dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
963 dwarf_abbrev_section = sectp;
965 else if (strcmp (sectp->name, LINE_SECTION) == 0)
967 dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
968 dwarf_line_section = sectp;
970 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
972 dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
973 dwarf_pubnames_section = sectp;
975 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
977 dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
978 dwarf_aranges_section = sectp;
980 else if (strcmp (sectp->name, LOC_SECTION) == 0)
982 dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
983 dwarf_loc_section = sectp;
985 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
987 dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
988 dwarf_macinfo_section = sectp;
990 else if (strcmp (sectp->name, STR_SECTION) == 0)
992 dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
993 dwarf_str_section = sectp;
995 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
997 dwarf_frame_size = bfd_get_section_size_before_reloc (sectp);
998 dwarf_frame_section = sectp;
1000 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1002 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1003 if (aflag & SEC_HAS_CONTENTS)
1005 dwarf_eh_frame_size = bfd_get_section_size_before_reloc (sectp);
1006 dwarf_eh_frame_section = sectp;
1009 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1011 dwarf_ranges_size = bfd_get_section_size_before_reloc (sectp);
1012 dwarf_ranges_section = sectp;
1016 /* Build a partial symbol table. */
1019 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1022 /* We definitely need the .debug_info and .debug_abbrev sections */
1024 dwarf_info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1025 dwarf_abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1027 if (dwarf_line_section)
1028 dwarf_line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1030 dwarf_line_buffer = NULL;
1032 if (dwarf_str_section)
1033 dwarf_str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1035 dwarf_str_buffer = NULL;
1037 if (dwarf_macinfo_section)
1038 dwarf_macinfo_buffer = dwarf2_read_section (objfile,
1039 dwarf_macinfo_section);
1041 dwarf_macinfo_buffer = NULL;
1043 if (dwarf_ranges_section)
1044 dwarf_ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1046 dwarf_ranges_buffer = NULL;
1048 if (dwarf_loc_section)
1049 dwarf_loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1051 dwarf_loc_buffer = NULL;
1054 || (objfile->global_psymbols.size == 0
1055 && objfile->static_psymbols.size == 0))
1057 init_psymbol_list (objfile, 1024);
1061 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1063 /* Things are significantly easier if we have .debug_aranges and
1064 .debug_pubnames sections */
1066 dwarf2_build_psymtabs_easy (objfile, mainline);
1070 /* only test this case for now */
1072 /* In this case we have to work a bit harder */
1073 dwarf2_build_psymtabs_hard (objfile, mainline);
1078 /* Build the partial symbol table from the information in the
1079 .debug_pubnames and .debug_aranges sections. */
1082 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1084 bfd *abfd = objfile->obfd;
1085 char *aranges_buffer, *pubnames_buffer;
1086 char *aranges_ptr, *pubnames_ptr;
1087 unsigned int entry_length, version, info_offset, info_size;
1089 pubnames_buffer = dwarf2_read_section (objfile,
1090 dwarf_pubnames_section);
1091 pubnames_ptr = pubnames_buffer;
1092 while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
1094 struct comp_unit_head cu_header;
1097 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1099 pubnames_ptr += bytes_read;
1100 version = read_1_byte (abfd, pubnames_ptr);
1102 info_offset = read_4_bytes (abfd, pubnames_ptr);
1104 info_size = read_4_bytes (abfd, pubnames_ptr);
1108 aranges_buffer = dwarf2_read_section (objfile,
1109 dwarf_aranges_section);
1114 /* Read in the comp unit header information from the debug_info at
1118 read_comp_unit_head (struct comp_unit_head *cu_header,
1119 char *info_ptr, bfd *abfd)
1123 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1125 info_ptr += bytes_read;
1126 cu_header->version = read_2_bytes (abfd, info_ptr);
1128 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1130 info_ptr += bytes_read;
1131 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1133 signed_addr = bfd_get_sign_extend_vma (abfd);
1134 if (signed_addr < 0)
1135 internal_error (__FILE__, __LINE__,
1136 "read_comp_unit_head: dwarf from non elf file");
1137 cu_header->signed_addr_p = signed_addr;
1141 /* Build the partial symbol table by doing a quick pass through the
1142 .debug_info and .debug_abbrev sections. */
1145 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1147 /* Instead of reading this into a big buffer, we should probably use
1148 mmap() on architectures that support it. (FIXME) */
1149 bfd *abfd = objfile->obfd;
1150 char *info_ptr, *abbrev_ptr;
1151 char *beg_of_comp_unit;
1152 struct partial_die_info comp_unit_die;
1153 struct partial_symtab *pst;
1154 struct cleanup *back_to;
1155 CORE_ADDR lowpc, highpc, baseaddr;
1157 info_ptr = dwarf_info_buffer;
1158 abbrev_ptr = dwarf_abbrev_buffer;
1160 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1161 the partial symbol scan, like attribute values.
1163 We could reduce our peak memory consumption during partial symbol
1164 table construction by freeing stuff from this obstack more often
1165 --- say, after processing each compilation unit, or each die ---
1166 but it turns out that this saves almost nothing. For an
1167 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1168 on dwarf2_tmp_obstack. Some investigation showed:
1170 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1171 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1172 all fixed-length values not requiring dynamic allocation.
1174 2) 30% of the attributes used the form DW_FORM_string. For
1175 DW_FORM_string, read_attribute simply hands back a pointer to
1176 the null-terminated string in dwarf_info_buffer, so no dynamic
1177 allocation is needed there either.
1179 3) The remaining 1% of the attributes all used DW_FORM_block1.
1180 75% of those were DW_AT_frame_base location lists for
1181 functions; the rest were DW_AT_location attributes, probably
1182 for the global variables.
1184 Anyway, what this all means is that the memory the dwarf2
1185 reader uses as temporary space reading partial symbols is about
1186 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1188 obstack_init (&dwarf2_tmp_obstack);
1189 back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1191 /* Since the objects we're extracting from dwarf_info_buffer vary in
1192 length, only the individual functions to extract them (like
1193 read_comp_unit_head and read_partial_die) can really know whether
1194 the buffer is large enough to hold another complete object.
1196 At the moment, they don't actually check that. If
1197 dwarf_info_buffer holds just one extra byte after the last
1198 compilation unit's dies, then read_comp_unit_head will happily
1199 read off the end of the buffer. read_partial_die is similarly
1200 casual. Those functions should be fixed.
1202 For this loop condition, simply checking whether there's any data
1203 left at all should be sufficient. */
1204 while (info_ptr < dwarf_info_buffer + dwarf_info_size)
1206 struct dwarf2_cu cu;
1207 beg_of_comp_unit = info_ptr;
1209 cu.objfile = objfile;
1210 info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
1212 if (cu.header.version != 2)
1214 error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu.header.version, 2, bfd_get_filename (abfd));
1217 if (cu.header.abbrev_offset >= dwarf_abbrev_size)
1219 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1220 (long) cu.header.abbrev_offset,
1221 (long) (beg_of_comp_unit - dwarf_info_buffer),
1222 bfd_get_filename (abfd));
1225 if (beg_of_comp_unit + cu.header.length + cu.header.initial_length_size
1226 > dwarf_info_buffer + dwarf_info_size)
1228 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1229 (long) cu.header.length,
1230 (long) (beg_of_comp_unit - dwarf_info_buffer),
1231 bfd_get_filename (abfd));
1234 /* Complete the cu_header */
1235 cu.header.offset = beg_of_comp_unit - dwarf_info_buffer;
1236 cu.header.first_die_ptr = info_ptr;
1237 cu.header.cu_head_ptr = beg_of_comp_unit;
1239 cu.list_in_scope = &file_symbols;
1241 /* Read the abbrevs for this compilation unit into a table */
1242 dwarf2_read_abbrevs (abfd, &cu);
1243 make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
1245 /* Read the compilation unit die */
1246 info_ptr = read_partial_die (&comp_unit_die, abfd, info_ptr,
1249 /* Set the language we're debugging */
1250 set_cu_language (comp_unit_die.language, &cu);
1252 /* Allocate a new partial symbol table structure */
1253 pst = start_psymtab_common (objfile, objfile->section_offsets,
1254 comp_unit_die.name ? comp_unit_die.name : "",
1255 comp_unit_die.lowpc,
1256 objfile->global_psymbols.next,
1257 objfile->static_psymbols.next);
1259 pst->read_symtab_private = (char *)
1260 obstack_alloc (&objfile->objfile_obstack, sizeof (struct dwarf2_pinfo));
1261 DWARF_INFO_BUFFER (pst) = dwarf_info_buffer;
1262 DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf_info_buffer;
1263 DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer;
1264 DWARF_ABBREV_SIZE (pst) = dwarf_abbrev_size;
1265 DWARF_LINE_BUFFER (pst) = dwarf_line_buffer;
1266 DWARF_LINE_SIZE (pst) = dwarf_line_size;
1267 DWARF_STR_BUFFER (pst) = dwarf_str_buffer;
1268 DWARF_STR_SIZE (pst) = dwarf_str_size;
1269 DWARF_MACINFO_BUFFER (pst) = dwarf_macinfo_buffer;
1270 DWARF_MACINFO_SIZE (pst) = dwarf_macinfo_size;
1271 DWARF_RANGES_BUFFER (pst) = dwarf_ranges_buffer;
1272 DWARF_RANGES_SIZE (pst) = dwarf_ranges_size;
1273 DWARF_LOC_BUFFER (pst) = dwarf_loc_buffer;
1274 DWARF_LOC_SIZE (pst) = dwarf_loc_size;
1275 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1277 /* Store the function that reads in the rest of the symbol table */
1278 pst->read_symtab = dwarf2_psymtab_to_symtab;
1280 /* Check if comp unit has_children.
1281 If so, read the rest of the partial symbols from this comp unit.
1282 If not, there's no more debug_info for this comp unit. */
1283 if (comp_unit_die.has_children)
1285 lowpc = ((CORE_ADDR) -1);
1286 highpc = ((CORE_ADDR) 0);
1288 info_ptr = scan_partial_symbols (info_ptr, &lowpc, &highpc,
1291 /* If we didn't find a lowpc, set it to highpc to avoid
1292 complaints from `maint check'. */
1293 if (lowpc == ((CORE_ADDR) -1))
1296 /* If the compilation unit didn't have an explicit address range,
1297 then use the information extracted from its child dies. */
1298 if (! comp_unit_die.has_pc_info)
1300 comp_unit_die.lowpc = lowpc;
1301 comp_unit_die.highpc = highpc;
1304 pst->textlow = comp_unit_die.lowpc + baseaddr;
1305 pst->texthigh = comp_unit_die.highpc + baseaddr;
1307 pst->n_global_syms = objfile->global_psymbols.next -
1308 (objfile->global_psymbols.list + pst->globals_offset);
1309 pst->n_static_syms = objfile->static_psymbols.next -
1310 (objfile->static_psymbols.list + pst->statics_offset);
1311 sort_pst_symbols (pst);
1313 /* If there is already a psymtab or symtab for a file of this
1314 name, remove it. (If there is a symtab, more drastic things
1315 also happen.) This happens in VxWorks. */
1316 free_named_symtabs (pst->filename);
1318 info_ptr = beg_of_comp_unit + cu.header.length
1319 + cu.header.initial_length_size;
1321 do_cleanups (back_to);
1324 /* Read in all interesting dies to the end of the compilation unit or
1325 to the end of the current namespace. NAMESPACE is NULL if we
1326 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1327 it's the name of the current namespace. In particular, it's the
1328 empty string if we're currently in the global namespace but have
1329 previously encountered a DW_TAG_namespace. */
1332 scan_partial_symbols (char *info_ptr, CORE_ADDR *lowpc,
1333 CORE_ADDR *highpc, struct dwarf2_cu *cu,
1334 const char *namespace)
1336 struct objfile *objfile = cu->objfile;
1337 bfd *abfd = objfile->obfd;
1338 struct partial_die_info pdi;
1340 /* Now, march along the PDI's, descending into ones which have
1341 interesting children but skipping the children of the other ones,
1342 until we reach the end of the compilation unit. */
1346 /* This flag tells whether or not info_ptr has gotten updated
1348 int info_ptr_updated = 0;
1350 info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1352 /* Anonymous namespaces have no name but have interesting
1353 children, so we need to look at them. Ditto for anonymous
1356 if (pdi.name != NULL || pdi.tag == DW_TAG_namespace
1357 || pdi.tag == DW_TAG_enumeration_type)
1361 case DW_TAG_subprogram:
1362 if (pdi.has_pc_info)
1364 if (pdi.lowpc < *lowpc)
1368 if (pdi.highpc > *highpc)
1370 *highpc = pdi.highpc;
1372 if (!pdi.is_declaration)
1374 add_partial_symbol (&pdi, cu, namespace);
1378 case DW_TAG_variable:
1379 case DW_TAG_typedef:
1380 case DW_TAG_union_type:
1381 if (!pdi.is_declaration)
1383 add_partial_symbol (&pdi, cu, namespace);
1386 case DW_TAG_class_type:
1387 case DW_TAG_structure_type:
1388 if (!pdi.is_declaration)
1390 info_ptr = add_partial_structure (&pdi, info_ptr, cu,
1392 info_ptr_updated = 1;
1395 case DW_TAG_enumeration_type:
1396 if (!pdi.is_declaration)
1398 info_ptr = add_partial_enumeration (&pdi, info_ptr, cu,
1400 info_ptr_updated = 1;
1403 case DW_TAG_base_type:
1404 case DW_TAG_subrange_type:
1405 /* File scope base type definitions are added to the partial
1407 add_partial_symbol (&pdi, cu, namespace);
1409 case DW_TAG_namespace:
1410 /* We've hit a DW_TAG_namespace entry, so we know this
1411 file has been compiled using a compiler that
1412 generates them; update NAMESPACE to reflect that. */
1413 if (namespace == NULL)
1415 info_ptr = add_partial_namespace (&pdi, info_ptr, lowpc, highpc,
1417 info_ptr_updated = 1;
1427 /* If the die has a sibling, skip to the sibling, unless another
1428 function has already updated info_ptr for us. */
1430 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1431 or not we want to update this depends on enough stuff (not
1432 only pdi.tag but also whether or not pdi.name is NULL) that
1433 this seems like the easiest way to handle the issue. */
1435 if (!info_ptr_updated)
1436 info_ptr = locate_pdi_sibling (&pdi, info_ptr, abfd, cu);
1443 add_partial_symbol (struct partial_die_info *pdi,
1444 struct dwarf2_cu *cu, const char *namespace)
1446 struct objfile *objfile = cu->objfile;
1448 char *actual_name = pdi->name;
1449 const struct partial_symbol *psym = NULL;
1452 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1454 /* If we're not in the global namespace and if the namespace name
1455 isn't encoded in a mangled actual_name, add it. */
1457 if (pdi_needs_namespace (pdi->tag, namespace))
1459 actual_name = alloca (strlen (pdi->name) + 2 + strlen (namespace) + 1);
1460 strcpy (actual_name, namespace);
1461 strcat (actual_name, "::");
1462 strcat (actual_name, pdi->name);
1467 case DW_TAG_subprogram:
1468 if (pdi->is_external)
1470 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1471 mst_text, objfile); */
1472 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1473 VAR_DOMAIN, LOC_BLOCK,
1474 &objfile->global_psymbols,
1475 0, pdi->lowpc + baseaddr,
1476 cu->language, objfile);
1480 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1481 mst_file_text, objfile); */
1482 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1483 VAR_DOMAIN, LOC_BLOCK,
1484 &objfile->static_psymbols,
1485 0, pdi->lowpc + baseaddr,
1486 cu->language, objfile);
1489 case DW_TAG_variable:
1490 if (pdi->is_external)
1493 Don't enter into the minimal symbol tables as there is
1494 a minimal symbol table entry from the ELF symbols already.
1495 Enter into partial symbol table if it has a location
1496 descriptor or a type.
1497 If the location descriptor is missing, new_symbol will create
1498 a LOC_UNRESOLVED symbol, the address of the variable will then
1499 be determined from the minimal symbol table whenever the variable
1501 The address for the partial symbol table entry is not
1502 used by GDB, but it comes in handy for debugging partial symbol
1506 addr = decode_locdesc (pdi->locdesc, cu);
1507 if (pdi->locdesc || pdi->has_type)
1508 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1509 VAR_DOMAIN, LOC_STATIC,
1510 &objfile->global_psymbols,
1512 cu->language, objfile);
1516 /* Static Variable. Skip symbols without location descriptors. */
1517 if (pdi->locdesc == NULL)
1519 addr = decode_locdesc (pdi->locdesc, cu);
1520 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1521 mst_file_data, objfile); */
1522 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1523 VAR_DOMAIN, LOC_STATIC,
1524 &objfile->static_psymbols,
1526 cu->language, objfile);
1529 case DW_TAG_typedef:
1530 case DW_TAG_base_type:
1531 case DW_TAG_subrange_type:
1532 add_psymbol_to_list (actual_name, strlen (actual_name),
1533 VAR_DOMAIN, LOC_TYPEDEF,
1534 &objfile->static_psymbols,
1535 0, (CORE_ADDR) 0, cu->language, objfile);
1537 case DW_TAG_class_type:
1538 case DW_TAG_structure_type:
1539 case DW_TAG_union_type:
1540 case DW_TAG_enumeration_type:
1541 /* Skip aggregate types without children, these are external
1543 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1544 static vs. global. */
1545 if (pdi->has_children == 0)
1547 add_psymbol_to_list (actual_name, strlen (actual_name),
1548 STRUCT_DOMAIN, LOC_TYPEDEF,
1549 cu->language == language_cplus
1550 ? &objfile->global_psymbols
1551 : &objfile->static_psymbols,
1552 0, (CORE_ADDR) 0, cu->language, objfile);
1554 if (cu->language == language_cplus)
1556 /* For C++, these implicitly act as typedefs as well. */
1557 add_psymbol_to_list (actual_name, strlen (actual_name),
1558 VAR_DOMAIN, LOC_TYPEDEF,
1559 &objfile->global_psymbols,
1560 0, (CORE_ADDR) 0, cu->language, objfile);
1563 case DW_TAG_enumerator:
1564 add_psymbol_to_list (actual_name, strlen (actual_name),
1565 VAR_DOMAIN, LOC_CONST,
1566 cu->language == language_cplus
1567 ? &objfile->global_psymbols
1568 : &objfile->static_psymbols,
1569 0, (CORE_ADDR) 0, cu->language, objfile);
1575 /* Check to see if we should scan the name for possible namespace
1576 info. Only do this if this is C++, if we don't have namespace
1577 debugging info in the file, if the psym is of an appropriate type
1578 (otherwise we'll have psym == NULL), and if we actually had a
1579 mangled name to begin with. */
1581 if (cu->language == language_cplus
1582 && namespace == NULL
1584 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
1585 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
1589 /* Determine whether a die of type TAG living in the C++ namespace
1590 NAMESPACE needs to have the name of the namespace prepended to the
1591 name listed in the die. */
1594 pdi_needs_namespace (enum dwarf_tag tag, const char *namespace)
1596 if (namespace == NULL || namespace[0] == '\0')
1601 case DW_TAG_typedef:
1602 case DW_TAG_class_type:
1603 case DW_TAG_structure_type:
1604 case DW_TAG_union_type:
1605 case DW_TAG_enumeration_type:
1606 case DW_TAG_enumerator:
1613 /* Read a partial die corresponding to a namespace; also, add a symbol
1614 corresponding to that namespace to the symbol table. NAMESPACE is
1615 the name of the enclosing namespace. */
1618 add_partial_namespace (struct partial_die_info *pdi, char *info_ptr,
1619 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1620 struct dwarf2_cu *cu, const char *namespace)
1622 struct objfile *objfile = cu->objfile;
1623 const char *new_name = pdi->name;
1626 /* Calculate the full name of the namespace that we just entered. */
1628 if (new_name == NULL)
1629 new_name = "(anonymous namespace)";
1630 full_name = alloca (strlen (namespace) + 2 + strlen (new_name) + 1);
1631 strcpy (full_name, namespace);
1632 if (*namespace != '\0')
1633 strcat (full_name, "::");
1634 strcat (full_name, new_name);
1636 /* FIXME: carlton/2003-10-07: We can't just replace this by a call
1637 to add_partial_symbol, because we don't have a way to pass in the
1638 full name to that function; that might be a flaw in
1639 add_partial_symbol's interface. */
1641 add_psymbol_to_list (full_name, strlen (full_name),
1642 VAR_DOMAIN, LOC_TYPEDEF,
1643 &objfile->global_psymbols,
1644 0, 0, cu->language, objfile);
1646 /* Now scan partial symbols in that namespace. */
1648 if (pdi->has_children)
1649 info_ptr = scan_partial_symbols (info_ptr, lowpc, highpc, cu, full_name);
1654 /* Read a partial die corresponding to a class or structure. */
1657 add_partial_structure (struct partial_die_info *struct_pdi, char *info_ptr,
1658 struct dwarf2_cu *cu,
1659 const char *namespace)
1661 bfd *abfd = cu->objfile->obfd;
1662 char *actual_class_name = NULL;
1664 if (cu->language == language_cplus
1665 && (namespace == NULL || namespace[0] == '\0')
1666 && struct_pdi->name != NULL
1667 && struct_pdi->has_children)
1669 /* See if we can figure out if the class lives in a namespace
1670 (or is nested within another class.) We do this by looking
1671 for a member function; its demangled name will contain
1672 namespace info, if there is any. */
1674 /* NOTE: carlton/2003-10-07: Getting the info this way changes
1675 what template types look like, because the demangler
1676 frequently doesn't give the same name as the debug info. We
1677 could fix this by only using the demangled name to get the
1678 prefix (but see comment in read_structure_type). */
1680 /* FIXME: carlton/2004-01-23: If NAMESPACE equals "", we have
1681 the appropriate debug information, so it would be nice to be
1682 able to avoid this hack. But NAMESPACE may not be the
1683 namespace where this class was defined: NAMESPACE reflects
1684 where STRUCT_PDI occurs in the tree of dies, but because of
1685 DW_AT_specification, that may not actually tell us where the
1686 class is defined. (See the comment in read_func_scope for an
1687 example of how this could occur.)
1689 Unfortunately, our current partial symtab data structures are
1690 completely unable to deal with DW_AT_specification. So, for
1691 now, the best thing to do is to get nesting information from
1692 places other than the tree structure of dies if there's any
1693 chance that a DW_AT_specification is involved. :-( */
1695 char *next_child = info_ptr;
1699 struct partial_die_info child_pdi;
1701 next_child = read_partial_die (&child_pdi, abfd, next_child,
1705 if (child_pdi.tag == DW_TAG_subprogram)
1707 actual_class_name = class_name_from_physname (child_pdi.name);
1708 if (actual_class_name != NULL)
1709 struct_pdi->name = actual_class_name;
1714 next_child = locate_pdi_sibling (&child_pdi, next_child,
1720 add_partial_symbol (struct_pdi, cu, namespace);
1721 xfree (actual_class_name);
1723 return locate_pdi_sibling (struct_pdi, info_ptr, abfd, cu);
1726 /* Read a partial die corresponding to an enumeration type. */
1729 add_partial_enumeration (struct partial_die_info *enum_pdi, char *info_ptr,
1730 struct dwarf2_cu *cu, const char *namespace)
1732 struct objfile *objfile = cu->objfile;
1733 bfd *abfd = objfile->obfd;
1734 struct partial_die_info pdi;
1736 if (enum_pdi->name != NULL)
1737 add_partial_symbol (enum_pdi, cu, namespace);
1741 info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1744 if (pdi.tag != DW_TAG_enumerator || pdi.name == NULL)
1745 complaint (&symfile_complaints, "malformed enumerator DIE ignored");
1747 add_partial_symbol (&pdi, cu, namespace);
1753 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1757 locate_pdi_sibling (struct partial_die_info *orig_pdi, char *info_ptr,
1758 bfd *abfd, struct dwarf2_cu *cu)
1760 /* Do we know the sibling already? */
1762 if (orig_pdi->sibling)
1763 return orig_pdi->sibling;
1765 /* Are there any children to deal with? */
1767 if (!orig_pdi->has_children)
1770 /* Okay, we don't know the sibling, but we have children that we
1771 want to skip. So read children until we run into one without a
1772 tag; return whatever follows it. */
1776 struct partial_die_info pdi;
1778 info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1783 info_ptr = locate_pdi_sibling (&pdi, info_ptr, abfd, cu);
1787 /* Expand this partial symbol table into a full symbol table. */
1790 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
1792 /* FIXME: This is barely more than a stub. */
1797 warning ("bug: psymtab for %s is already read in.", pst->filename);
1803 printf_filtered ("Reading in symbols for %s...", pst->filename);
1804 gdb_flush (gdb_stdout);
1807 psymtab_to_symtab_1 (pst);
1809 /* Finish up the debug error message. */
1811 printf_filtered ("done.\n");
1817 psymtab_to_symtab_1 (struct partial_symtab *pst)
1819 struct objfile *objfile = pst->objfile;
1820 bfd *abfd = objfile->obfd;
1821 struct dwarf2_cu cu;
1822 struct die_info *dies;
1823 unsigned long offset;
1824 CORE_ADDR lowpc, highpc;
1825 struct die_info *child_die;
1827 struct symtab *symtab;
1828 struct cleanup *back_to;
1829 struct attribute *attr;
1832 /* Set local variables from the partial symbol table info. */
1833 offset = DWARF_INFO_OFFSET (pst);
1834 dwarf_info_buffer = DWARF_INFO_BUFFER (pst);
1835 dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER (pst);
1836 dwarf_abbrev_size = DWARF_ABBREV_SIZE (pst);
1837 dwarf_line_buffer = DWARF_LINE_BUFFER (pst);
1838 dwarf_line_size = DWARF_LINE_SIZE (pst);
1839 dwarf_str_buffer = DWARF_STR_BUFFER (pst);
1840 dwarf_str_size = DWARF_STR_SIZE (pst);
1841 dwarf_macinfo_buffer = DWARF_MACINFO_BUFFER (pst);
1842 dwarf_macinfo_size = DWARF_MACINFO_SIZE (pst);
1843 dwarf_ranges_buffer = DWARF_RANGES_BUFFER (pst);
1844 dwarf_ranges_size = DWARF_RANGES_SIZE (pst);
1845 dwarf_loc_buffer = DWARF_LOC_BUFFER (pst);
1846 dwarf_loc_size = DWARF_LOC_SIZE (pst);
1847 info_ptr = dwarf_info_buffer + offset;
1848 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1850 /* We're in the global namespace. */
1851 processing_current_prefix = "";
1853 obstack_init (&dwarf2_tmp_obstack);
1854 back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1857 make_cleanup (really_free_pendings, NULL);
1859 cu.objfile = objfile;
1861 /* read in the comp_unit header */
1862 info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
1864 /* Read the abbrevs for this compilation unit */
1865 dwarf2_read_abbrevs (abfd, &cu);
1866 make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
1868 cu.header.offset = offset;
1870 cu.list_in_scope = &file_symbols;
1872 dies = read_comp_unit (info_ptr, abfd, &cu);
1874 make_cleanup_free_die_list (dies);
1876 /* Find the base address of the compilation unit for range lists and
1877 location lists. It will normally be specified by DW_AT_low_pc.
1878 In DWARF-3 draft 4, the base address could be overridden by
1879 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1880 compilation units with discontinuous ranges. */
1882 cu.header.base_known = 0;
1883 cu.header.base_address = 0;
1885 attr = dwarf2_attr (dies, DW_AT_entry_pc, &cu);
1888 cu.header.base_address = DW_ADDR (attr);
1889 cu.header.base_known = 1;
1893 attr = dwarf2_attr (dies, DW_AT_low_pc, &cu);
1896 cu.header.base_address = DW_ADDR (attr);
1897 cu.header.base_known = 1;
1901 /* Do line number decoding in read_file_scope () */
1902 process_die (dies, &cu);
1904 /* Some compilers don't define a DW_AT_high_pc attribute for the
1905 compilation unit. If the DW_AT_high_pc is missing, synthesize
1906 it, by scanning the DIE's below the compilation unit. */
1907 get_scope_pc_bounds (dies, &lowpc, &highpc, &cu);
1909 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
1911 /* Set symtab language to language from DW_AT_language.
1912 If the compilation is from a C file generated by language preprocessors,
1913 do not set the language if it was already deduced by start_subfile. */
1915 && !(cu.language == language_c && symtab->language != language_c))
1917 symtab->language = cu.language;
1919 pst->symtab = symtab;
1922 do_cleanups (back_to);
1925 /* Process a die and its children. */
1928 process_die (struct die_info *die, struct dwarf2_cu *cu)
1932 case DW_TAG_padding:
1934 case DW_TAG_compile_unit:
1935 read_file_scope (die, cu);
1937 case DW_TAG_subprogram:
1938 read_subroutine_type (die, cu);
1939 read_func_scope (die, cu);
1941 case DW_TAG_inlined_subroutine:
1942 /* FIXME: These are ignored for now.
1943 They could be used to set breakpoints on all inlined instances
1944 of a function and make GDB `next' properly over inlined functions. */
1946 case DW_TAG_lexical_block:
1947 case DW_TAG_try_block:
1948 case DW_TAG_catch_block:
1949 read_lexical_block_scope (die, cu);
1951 case DW_TAG_class_type:
1952 case DW_TAG_structure_type:
1953 case DW_TAG_union_type:
1954 read_structure_type (die, cu);
1955 process_structure_scope (die, cu);
1957 case DW_TAG_enumeration_type:
1958 read_enumeration_type (die, cu);
1959 process_enumeration_scope (die, cu);
1962 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
1963 a symbol or process any children. Therefore it doesn't do anything
1964 that won't be done on-demand by read_type_die. */
1965 case DW_TAG_subroutine_type:
1966 read_subroutine_type (die, cu);
1968 case DW_TAG_array_type:
1969 read_array_type (die, cu);
1971 case DW_TAG_pointer_type:
1972 read_tag_pointer_type (die, cu);
1974 case DW_TAG_ptr_to_member_type:
1975 read_tag_ptr_to_member_type (die, cu);
1977 case DW_TAG_reference_type:
1978 read_tag_reference_type (die, cu);
1980 case DW_TAG_string_type:
1981 read_tag_string_type (die, cu);
1985 case DW_TAG_base_type:
1986 read_base_type (die, cu);
1987 /* Add a typedef symbol for the type definition, if it has a
1989 new_symbol (die, die->type, cu);
1991 case DW_TAG_subrange_type:
1992 read_subrange_type (die, cu);
1993 /* Add a typedef symbol for the type definition, if it has a
1995 new_symbol (die, die->type, cu);
1997 case DW_TAG_common_block:
1998 read_common_block (die, cu);
2000 case DW_TAG_common_inclusion:
2002 case DW_TAG_namespace:
2003 processing_has_namespace_info = 1;
2004 read_namespace (die, cu);
2006 case DW_TAG_imported_declaration:
2007 case DW_TAG_imported_module:
2008 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2009 information contained in these. DW_TAG_imported_declaration
2010 dies shouldn't have children; DW_TAG_imported_module dies
2011 shouldn't in the C++ case, but conceivably could in the
2012 Fortran case, so we'll have to replace this gdb_assert if
2013 Fortran compilers start generating that info. */
2014 processing_has_namespace_info = 1;
2015 gdb_assert (die->child == NULL);
2018 new_symbol (die, NULL, cu);
2024 initialize_cu_func_list (struct dwarf2_cu *cu)
2026 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2030 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2032 struct objfile *objfile = cu->objfile;
2033 struct comp_unit_head *cu_header = &cu->header;
2034 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2035 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2036 CORE_ADDR highpc = ((CORE_ADDR) 0);
2037 struct attribute *attr;
2038 char *name = "<unknown>";
2039 char *comp_dir = NULL;
2040 struct die_info *child_die;
2041 bfd *abfd = objfile->obfd;
2042 struct line_header *line_header = 0;
2045 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2047 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2049 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2050 from finish_block. */
2051 if (lowpc == ((CORE_ADDR) -1))
2056 attr = dwarf2_attr (die, DW_AT_name, cu);
2059 name = DW_STRING (attr);
2061 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2064 comp_dir = DW_STRING (attr);
2067 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2068 directory, get rid of it. */
2069 char *cp = strchr (comp_dir, ':');
2071 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2076 if (objfile->ei.entry_point >= lowpc &&
2077 objfile->ei.entry_point < highpc)
2079 objfile->ei.deprecated_entry_file_lowpc = lowpc;
2080 objfile->ei.deprecated_entry_file_highpc = highpc;
2083 attr = dwarf2_attr (die, DW_AT_language, cu);
2086 set_cu_language (DW_UNSND (attr), cu);
2089 /* We assume that we're processing GCC output. */
2090 processing_gcc_compilation = 2;
2092 /* FIXME:Do something here. */
2093 if (dip->at_producer != NULL)
2095 handle_producer (dip->at_producer);
2099 /* The compilation unit may be in a different language or objfile,
2100 zero out all remembered fundamental types. */
2101 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2103 start_symtab (name, comp_dir, lowpc);
2104 record_debugformat ("DWARF 2");
2106 initialize_cu_func_list (cu);
2108 /* Process all dies in compilation unit. */
2109 if (die->child != NULL)
2111 child_die = die->child;
2112 while (child_die && child_die->tag)
2114 process_die (child_die, cu);
2115 child_die = sibling_die (child_die);
2119 /* Decode line number information if present. */
2120 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2123 unsigned int line_offset = DW_UNSND (attr);
2124 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2127 make_cleanup ((make_cleanup_ftype *) free_line_header,
2128 (void *) line_header);
2129 dwarf_decode_lines (line_header, comp_dir, abfd, cu);
2133 /* Decode macro information, if present. Dwarf 2 macro information
2134 refers to information in the line number info statement program
2135 header, so we can only read it if we've read the header
2137 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2138 if (attr && line_header)
2140 unsigned int macro_offset = DW_UNSND (attr);
2141 dwarf_decode_macros (line_header, macro_offset,
2142 comp_dir, abfd, cu);
2144 do_cleanups (back_to);
2148 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2149 struct dwarf2_cu *cu)
2151 struct function_range *thisfn;
2153 thisfn = (struct function_range *)
2154 obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct function_range));
2155 thisfn->name = name;
2156 thisfn->lowpc = lowpc;
2157 thisfn->highpc = highpc;
2158 thisfn->seen_line = 0;
2159 thisfn->next = NULL;
2161 if (cu->last_fn == NULL)
2162 cu->first_fn = thisfn;
2164 cu->last_fn->next = thisfn;
2166 cu->last_fn = thisfn;
2170 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2172 struct objfile *objfile = cu->objfile;
2173 struct context_stack *new;
2176 struct die_info *child_die;
2177 struct attribute *attr;
2179 const char *previous_prefix = processing_current_prefix;
2180 struct cleanup *back_to = NULL;
2183 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2185 name = dwarf2_linkage_name (die, cu);
2187 /* Ignore functions with missing or empty names and functions with
2188 missing or invalid low and high pc attributes. */
2189 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2192 if (cu->language == language_cplus)
2194 struct die_info *spec_die = die_specification (die, cu);
2196 /* NOTE: carlton/2004-01-23: We have to be careful in the
2197 presence of DW_AT_specification. For example, with GCC 3.4,
2202 // Definition of N::foo.
2206 then we'll have a tree of DIEs like this:
2208 1: DW_TAG_compile_unit
2209 2: DW_TAG_namespace // N
2210 3: DW_TAG_subprogram // declaration of N::foo
2211 4: DW_TAG_subprogram // definition of N::foo
2212 DW_AT_specification // refers to die #3
2214 Thus, when processing die #4, we have to pretend that we're
2215 in the context of its DW_AT_specification, namely the contex
2218 if (spec_die != NULL)
2220 char *specification_prefix = determine_prefix (spec_die, cu);
2221 processing_current_prefix = specification_prefix;
2222 back_to = make_cleanup (xfree, specification_prefix);
2229 /* Record the function range for dwarf_decode_lines. */
2230 add_to_cu_func_list (name, lowpc, highpc, cu);
2232 if (objfile->ei.entry_point >= lowpc &&
2233 objfile->ei.entry_point < highpc)
2235 objfile->ei.entry_func_lowpc = lowpc;
2236 objfile->ei.entry_func_highpc = highpc;
2239 new = push_context (0, lowpc);
2240 new->name = new_symbol (die, die->type, cu);
2242 /* If there is a location expression for DW_AT_frame_base, record
2244 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2246 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2247 expression is being recorded directly in the function's symbol
2248 and not in a separate frame-base object. I guess this hack is
2249 to avoid adding some sort of frame-base adjunct/annex to the
2250 function's symbol :-(. The problem with doing this is that it
2251 results in a function symbol with a location expression that
2252 has nothing to do with the location of the function, ouch! The
2253 relationship should be: a function's symbol has-a frame base; a
2254 frame-base has-a location expression. */
2255 dwarf2_symbol_mark_computed (attr, new->name, cu);
2257 cu->list_in_scope = &local_symbols;
2259 if (die->child != NULL)
2261 child_die = die->child;
2262 while (child_die && child_die->tag)
2264 process_die (child_die, cu);
2265 child_die = sibling_die (child_die);
2269 new = pop_context ();
2270 /* Make a block for the local symbols within. */
2271 finish_block (new->name, &local_symbols, new->old_blocks,
2272 lowpc, highpc, objfile);
2274 /* In C++, we can have functions nested inside functions (e.g., when
2275 a function declares a class that has methods). This means that
2276 when we finish processing a function scope, we may need to go
2277 back to building a containing block's symbol lists. */
2278 local_symbols = new->locals;
2279 param_symbols = new->params;
2281 /* If we've finished processing a top-level function, subsequent
2282 symbols go in the file symbol list. */
2283 if (outermost_context_p ())
2284 cu->list_in_scope = &file_symbols;
2286 processing_current_prefix = previous_prefix;
2287 if (back_to != NULL)
2288 do_cleanups (back_to);
2291 /* Process all the DIES contained within a lexical block scope. Start
2292 a new scope, process the dies, and then close the scope. */
2295 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2297 struct objfile *objfile = cu->objfile;
2298 struct context_stack *new;
2299 CORE_ADDR lowpc, highpc;
2300 struct die_info *child_die;
2303 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2305 /* Ignore blocks with missing or invalid low and high pc attributes. */
2306 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2307 as multiple lexical blocks? Handling children in a sane way would
2308 be nasty. Might be easier to properly extend generic blocks to
2310 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2315 push_context (0, lowpc);
2316 if (die->child != NULL)
2318 child_die = die->child;
2319 while (child_die && child_die->tag)
2321 process_die (child_die, cu);
2322 child_die = sibling_die (child_die);
2325 new = pop_context ();
2327 if (local_symbols != NULL)
2329 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
2332 local_symbols = new->locals;
2335 /* Get low and high pc attributes from a die. Return 1 if the attributes
2336 are present and valid, otherwise, return 0. Return -1 if the range is
2337 discontinuous, i.e. derived from DW_AT_ranges information. */
2339 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
2340 CORE_ADDR *highpc, struct dwarf2_cu *cu)
2342 struct objfile *objfile = cu->objfile;
2343 struct comp_unit_head *cu_header = &cu->header;
2344 struct attribute *attr;
2345 bfd *obfd = objfile->obfd;
2350 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
2353 high = DW_ADDR (attr);
2354 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
2356 low = DW_ADDR (attr);
2358 /* Found high w/o low attribute. */
2361 /* Found consecutive range of addresses. */
2366 attr = dwarf2_attr (die, DW_AT_ranges, cu);
2369 unsigned int addr_size = cu_header->addr_size;
2370 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2371 /* Value of the DW_AT_ranges attribute is the offset in the
2372 .debug_ranges section. */
2373 unsigned int offset = DW_UNSND (attr);
2374 /* Base address selection entry. */
2382 found_base = cu_header->base_known;
2383 base = cu_header->base_address;
2385 if (offset >= dwarf_ranges_size)
2387 complaint (&symfile_complaints,
2388 "Offset %d out of bounds for DW_AT_ranges attribute",
2392 buffer = dwarf_ranges_buffer + offset;
2394 /* Read in the largest possible address. */
2395 marker = read_address (obfd, buffer, cu, &dummy);
2396 if ((marker & mask) == mask)
2398 /* If we found the largest possible address, then
2399 read the base address. */
2400 base = read_address (obfd, buffer + addr_size, cu, &dummy);
2401 buffer += 2 * addr_size;
2402 offset += 2 * addr_size;
2410 CORE_ADDR range_beginning, range_end;
2412 range_beginning = read_address (obfd, buffer, cu, &dummy);
2413 buffer += addr_size;
2414 range_end = read_address (obfd, buffer, cu, &dummy);
2415 buffer += addr_size;
2416 offset += 2 * addr_size;
2418 /* An end of list marker is a pair of zero addresses. */
2419 if (range_beginning == 0 && range_end == 0)
2420 /* Found the end of list entry. */
2423 /* Each base address selection entry is a pair of 2 values.
2424 The first is the largest possible address, the second is
2425 the base address. Check for a base address here. */
2426 if ((range_beginning & mask) == mask)
2428 /* If we found the largest possible address, then
2429 read the base address. */
2430 base = read_address (obfd, buffer + addr_size, cu, &dummy);
2437 /* We have no valid base address for the ranges
2439 complaint (&symfile_complaints,
2440 "Invalid .debug_ranges data (no base address)");
2444 range_beginning += base;
2447 /* FIXME: This is recording everything as a low-high
2448 segment of consecutive addresses. We should have a
2449 data structure for discontiguous block ranges
2453 low = range_beginning;
2459 if (range_beginning < low)
2460 low = range_beginning;
2461 if (range_end > high)
2467 /* If the first entry is an end-of-list marker, the range
2468 describes an empty scope, i.e. no instructions. */
2478 /* When using the GNU linker, .gnu.linkonce. sections are used to
2479 eliminate duplicate copies of functions and vtables and such.
2480 The linker will arbitrarily choose one and discard the others.
2481 The AT_*_pc values for such functions refer to local labels in
2482 these sections. If the section from that file was discarded, the
2483 labels are not in the output, so the relocs get a value of 0.
2484 If this is a discarded function, mark the pc bounds as invalid,
2485 so that GDB will ignore it. */
2486 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
2494 /* Get the low and high pc's represented by the scope DIE, and store
2495 them in *LOWPC and *HIGHPC. If the correct values can't be
2496 determined, set *LOWPC to -1 and *HIGHPC to 0. */
2499 get_scope_pc_bounds (struct die_info *die,
2500 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2501 struct dwarf2_cu *cu)
2503 CORE_ADDR best_low = (CORE_ADDR) -1;
2504 CORE_ADDR best_high = (CORE_ADDR) 0;
2505 CORE_ADDR current_low, current_high;
2507 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
2509 best_low = current_low;
2510 best_high = current_high;
2514 struct die_info *child = die->child;
2516 while (child && child->tag)
2518 switch (child->tag) {
2519 case DW_TAG_subprogram:
2520 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
2522 best_low = min (best_low, current_low);
2523 best_high = max (best_high, current_high);
2526 case DW_TAG_namespace:
2527 /* FIXME: carlton/2004-01-16: Should we do this for
2528 DW_TAG_class_type/DW_TAG_structure_type, too? I think
2529 that current GCC's always emit the DIEs corresponding
2530 to definitions of methods of classes as children of a
2531 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2532 the DIEs giving the declarations, which could be
2533 anywhere). But I don't see any reason why the
2534 standards says that they have to be there. */
2535 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
2537 if (current_low != ((CORE_ADDR) -1))
2539 best_low = min (best_low, current_low);
2540 best_high = max (best_high, current_high);
2548 child = sibling_die (child);
2553 *highpc = best_high;
2556 /* Add an aggregate field to the field list. */
2559 dwarf2_add_field (struct field_info *fip, struct die_info *die,
2560 struct dwarf2_cu *cu)
2562 struct objfile *objfile = cu->objfile;
2563 struct nextfield *new_field;
2564 struct attribute *attr;
2566 char *fieldname = "";
2568 /* Allocate a new field list entry and link it in. */
2569 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2570 make_cleanup (xfree, new_field);
2571 memset (new_field, 0, sizeof (struct nextfield));
2572 new_field->next = fip->fields;
2573 fip->fields = new_field;
2576 /* Handle accessibility and virtuality of field.
2577 The default accessibility for members is public, the default
2578 accessibility for inheritance is private. */
2579 if (die->tag != DW_TAG_inheritance)
2580 new_field->accessibility = DW_ACCESS_public;
2582 new_field->accessibility = DW_ACCESS_private;
2583 new_field->virtuality = DW_VIRTUALITY_none;
2585 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
2587 new_field->accessibility = DW_UNSND (attr);
2588 if (new_field->accessibility != DW_ACCESS_public)
2589 fip->non_public_fields = 1;
2590 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
2592 new_field->virtuality = DW_UNSND (attr);
2594 fp = &new_field->field;
2596 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
2598 /* Data member other than a C++ static data member. */
2600 /* Get type of field. */
2601 fp->type = die_type (die, cu);
2603 FIELD_STATIC_KIND (*fp) = 0;
2605 /* Get bit size of field (zero if none). */
2606 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
2609 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
2613 FIELD_BITSIZE (*fp) = 0;
2616 /* Get bit offset of field. */
2617 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2620 FIELD_BITPOS (*fp) =
2621 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
2624 FIELD_BITPOS (*fp) = 0;
2625 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
2628 if (BITS_BIG_ENDIAN)
2630 /* For big endian bits, the DW_AT_bit_offset gives the
2631 additional bit offset from the MSB of the containing
2632 anonymous object to the MSB of the field. We don't
2633 have to do anything special since we don't need to
2634 know the size of the anonymous object. */
2635 FIELD_BITPOS (*fp) += DW_UNSND (attr);
2639 /* For little endian bits, compute the bit offset to the
2640 MSB of the anonymous object, subtract off the number of
2641 bits from the MSB of the field to the MSB of the
2642 object, and then subtract off the number of bits of
2643 the field itself. The result is the bit offset of
2644 the LSB of the field. */
2646 int bit_offset = DW_UNSND (attr);
2648 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
2651 /* The size of the anonymous object containing
2652 the bit field is explicit, so use the
2653 indicated size (in bytes). */
2654 anonymous_size = DW_UNSND (attr);
2658 /* The size of the anonymous object containing
2659 the bit field must be inferred from the type
2660 attribute of the data member containing the
2662 anonymous_size = TYPE_LENGTH (fp->type);
2664 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
2665 - bit_offset - FIELD_BITSIZE (*fp);
2669 /* Get name of field. */
2670 attr = dwarf2_attr (die, DW_AT_name, cu);
2671 if (attr && DW_STRING (attr))
2672 fieldname = DW_STRING (attr);
2673 fp->name = obsavestring (fieldname, strlen (fieldname),
2674 &objfile->objfile_obstack);
2676 /* Change accessibility for artificial fields (e.g. virtual table
2677 pointer or virtual base class pointer) to private. */
2678 if (dwarf2_attr (die, DW_AT_artificial, cu))
2680 new_field->accessibility = DW_ACCESS_private;
2681 fip->non_public_fields = 1;
2684 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
2686 /* C++ static member. */
2688 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2689 is a declaration, but all versions of G++ as of this writing
2690 (so through at least 3.2.1) incorrectly generate
2691 DW_TAG_variable tags. */
2695 /* Get name of field. */
2696 attr = dwarf2_attr (die, DW_AT_name, cu);
2697 if (attr && DW_STRING (attr))
2698 fieldname = DW_STRING (attr);
2702 /* Get physical name. */
2703 physname = dwarf2_linkage_name (die, cu);
2705 SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname),
2706 &objfile->objfile_obstack));
2707 FIELD_TYPE (*fp) = die_type (die, cu);
2708 FIELD_NAME (*fp) = obsavestring (fieldname, strlen (fieldname),
2709 &objfile->objfile_obstack);
2711 else if (die->tag == DW_TAG_inheritance)
2713 /* C++ base class field. */
2714 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2716 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
2718 FIELD_BITSIZE (*fp) = 0;
2719 FIELD_STATIC_KIND (*fp) = 0;
2720 FIELD_TYPE (*fp) = die_type (die, cu);
2721 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
2722 fip->nbaseclasses++;
2726 /* Create the vector of fields, and attach it to the type. */
2729 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
2730 struct dwarf2_cu *cu)
2732 int nfields = fip->nfields;
2734 /* Record the field count, allocate space for the array of fields,
2735 and create blank accessibility bitfields if necessary. */
2736 TYPE_NFIELDS (type) = nfields;
2737 TYPE_FIELDS (type) = (struct field *)
2738 TYPE_ALLOC (type, sizeof (struct field) * nfields);
2739 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
2741 if (fip->non_public_fields)
2743 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2745 TYPE_FIELD_PRIVATE_BITS (type) =
2746 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2747 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2749 TYPE_FIELD_PROTECTED_BITS (type) =
2750 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2751 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2753 TYPE_FIELD_IGNORE_BITS (type) =
2754 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2755 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
2758 /* If the type has baseclasses, allocate and clear a bit vector for
2759 TYPE_FIELD_VIRTUAL_BITS. */
2760 if (fip->nbaseclasses)
2762 int num_bytes = B_BYTES (fip->nbaseclasses);
2765 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2766 pointer = (char *) TYPE_ALLOC (type, num_bytes);
2767 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
2768 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
2769 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
2772 /* Copy the saved-up fields into the field vector. Start from the head
2773 of the list, adding to the tail of the field array, so that they end
2774 up in the same order in the array in which they were added to the list. */
2775 while (nfields-- > 0)
2777 TYPE_FIELD (type, nfields) = fip->fields->field;
2778 switch (fip->fields->accessibility)
2780 case DW_ACCESS_private:
2781 SET_TYPE_FIELD_PRIVATE (type, nfields);
2784 case DW_ACCESS_protected:
2785 SET_TYPE_FIELD_PROTECTED (type, nfields);
2788 case DW_ACCESS_public:
2792 /* Unknown accessibility. Complain and treat it as public. */
2794 complaint (&symfile_complaints, "unsupported accessibility %d",
2795 fip->fields->accessibility);
2799 if (nfields < fip->nbaseclasses)
2801 switch (fip->fields->virtuality)
2803 case DW_VIRTUALITY_virtual:
2804 case DW_VIRTUALITY_pure_virtual:
2805 SET_TYPE_FIELD_VIRTUAL (type, nfields);
2809 fip->fields = fip->fields->next;
2813 /* Add a member function to the proper fieldlist. */
2816 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
2817 struct type *type, struct dwarf2_cu *cu)
2819 struct objfile *objfile = cu->objfile;
2820 struct attribute *attr;
2821 struct fnfieldlist *flp;
2823 struct fn_field *fnp;
2826 struct nextfnfield *new_fnfield;
2828 /* Get name of member function. */
2829 attr = dwarf2_attr (die, DW_AT_name, cu);
2830 if (attr && DW_STRING (attr))
2831 fieldname = DW_STRING (attr);
2835 /* Get the mangled name. */
2836 physname = dwarf2_linkage_name (die, cu);
2838 /* Look up member function name in fieldlist. */
2839 for (i = 0; i < fip->nfnfields; i++)
2841 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
2845 /* Create new list element if necessary. */
2846 if (i < fip->nfnfields)
2847 flp = &fip->fnfieldlists[i];
2850 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
2852 fip->fnfieldlists = (struct fnfieldlist *)
2853 xrealloc (fip->fnfieldlists,
2854 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
2855 * sizeof (struct fnfieldlist));
2856 if (fip->nfnfields == 0)
2857 make_cleanup (free_current_contents, &fip->fnfieldlists);
2859 flp = &fip->fnfieldlists[fip->nfnfields];
2860 flp->name = fieldname;
2866 /* Create a new member function field and chain it to the field list
2868 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
2869 make_cleanup (xfree, new_fnfield);
2870 memset (new_fnfield, 0, sizeof (struct nextfnfield));
2871 new_fnfield->next = flp->head;
2872 flp->head = new_fnfield;
2875 /* Fill in the member function field info. */
2876 fnp = &new_fnfield->fnfield;
2877 fnp->physname = obsavestring (physname, strlen (physname),
2878 &objfile->objfile_obstack);
2879 fnp->type = alloc_type (objfile);
2880 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
2882 int nparams = TYPE_NFIELDS (die->type);
2884 /* TYPE is the domain of this method, and DIE->TYPE is the type
2885 of the method itself (TYPE_CODE_METHOD). */
2886 smash_to_method_type (fnp->type, type,
2887 TYPE_TARGET_TYPE (die->type),
2888 TYPE_FIELDS (die->type),
2889 TYPE_NFIELDS (die->type),
2890 TYPE_VARARGS (die->type));
2892 /* Handle static member functions.
2893 Dwarf2 has no clean way to discern C++ static and non-static
2894 member functions. G++ helps GDB by marking the first
2895 parameter for non-static member functions (which is the
2896 this pointer) as artificial. We obtain this information
2897 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2898 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
2899 fnp->voffset = VOFFSET_STATIC;
2902 complaint (&symfile_complaints, "member function type missing for '%s'",
2905 /* Get fcontext from DW_AT_containing_type if present. */
2906 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
2907 fnp->fcontext = die_containing_type (die, cu);
2909 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2910 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2912 /* Get accessibility. */
2913 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
2916 switch (DW_UNSND (attr))
2918 case DW_ACCESS_private:
2919 fnp->is_private = 1;
2921 case DW_ACCESS_protected:
2922 fnp->is_protected = 1;
2927 /* Check for artificial methods. */
2928 attr = dwarf2_attr (die, DW_AT_artificial, cu);
2929 if (attr && DW_UNSND (attr) != 0)
2930 fnp->is_artificial = 1;
2932 /* Get index in virtual function table if it is a virtual member function. */
2933 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
2936 /* Support the .debug_loc offsets */
2937 if (attr_form_is_block (attr))
2939 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
2941 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
2943 dwarf2_complex_location_expr_complaint ();
2947 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2953 /* Create the vector of member function fields, and attach it to the type. */
2956 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
2957 struct dwarf2_cu *cu)
2959 struct fnfieldlist *flp;
2960 int total_length = 0;
2963 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2964 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2965 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
2967 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
2969 struct nextfnfield *nfp = flp->head;
2970 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
2973 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
2974 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
2975 fn_flp->fn_fields = (struct fn_field *)
2976 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
2977 for (k = flp->length; (k--, nfp); nfp = nfp->next)
2978 fn_flp->fn_fields[k] = nfp->fnfield;
2980 total_length += flp->length;
2983 TYPE_NFN_FIELDS (type) = fip->nfnfields;
2984 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2987 /* Called when we find the DIE that starts a structure or union scope
2988 (definition) to process all dies that define the members of the
2991 NOTE: we need to call struct_type regardless of whether or not the
2992 DIE has an at_name attribute, since it might be an anonymous
2993 structure or union. This gets the type entered into our set of
2996 However, if the structure is incomplete (an opaque struct/union)
2997 then suppress creating a symbol table entry for it since gdb only
2998 wants to find the one with the complete definition. Note that if
2999 it is complete, we just call new_symbol, which does it's own
3000 checking about whether the struct/union is anonymous or not (and
3001 suppresses creating a symbol table entry itself). */
3004 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3006 struct objfile *objfile = cu->objfile;
3008 struct attribute *attr;
3009 const char *previous_prefix = processing_current_prefix;
3010 struct cleanup *back_to = NULL;
3015 type = alloc_type (objfile);
3017 INIT_CPLUS_SPECIFIC (type);
3018 attr = dwarf2_attr (die, DW_AT_name, cu);
3019 if (attr && DW_STRING (attr))
3021 if (cu->language == language_cplus)
3023 char *new_prefix = determine_class_name (die, cu);
3024 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3025 strlen (new_prefix),
3026 &objfile->objfile_obstack);
3027 back_to = make_cleanup (xfree, new_prefix);
3028 processing_current_prefix = new_prefix;
3032 TYPE_TAG_NAME (type) = DW_STRING (attr);
3036 if (die->tag == DW_TAG_structure_type)
3038 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3040 else if (die->tag == DW_TAG_union_type)
3042 TYPE_CODE (type) = TYPE_CODE_UNION;
3046 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3048 TYPE_CODE (type) = TYPE_CODE_CLASS;
3051 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3054 TYPE_LENGTH (type) = DW_UNSND (attr);
3058 TYPE_LENGTH (type) = 0;
3061 /* We need to add the type field to the die immediately so we don't
3062 infinitely recurse when dealing with pointers to the structure
3063 type within the structure itself. */
3066 if (die->child != NULL && ! die_is_declaration (die, cu))
3068 struct field_info fi;
3069 struct die_info *child_die;
3070 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3072 memset (&fi, 0, sizeof (struct field_info));
3074 child_die = die->child;
3076 while (child_die && child_die->tag)
3078 if (child_die->tag == DW_TAG_member
3079 || child_die->tag == DW_TAG_variable)
3081 /* NOTE: carlton/2002-11-05: A C++ static data member
3082 should be a DW_TAG_member that is a declaration, but
3083 all versions of G++ as of this writing (so through at
3084 least 3.2.1) incorrectly generate DW_TAG_variable
3085 tags for them instead. */
3086 dwarf2_add_field (&fi, child_die, cu);
3088 else if (child_die->tag == DW_TAG_subprogram)
3090 /* C++ member function. */
3091 read_type_die (child_die, cu);
3092 dwarf2_add_member_fn (&fi, child_die, type, cu);
3094 else if (child_die->tag == DW_TAG_inheritance)
3096 /* C++ base class field. */
3097 dwarf2_add_field (&fi, child_die, cu);
3099 child_die = sibling_die (child_die);
3102 /* Attach fields and member functions to the type. */
3104 dwarf2_attach_fields_to_type (&fi, type, cu);
3107 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3109 /* Get the type which refers to the base class (possibly this
3110 class itself) which contains the vtable pointer for the current
3111 class from the DW_AT_containing_type attribute. */
3113 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3115 struct type *t = die_containing_type (die, cu);
3117 TYPE_VPTR_BASETYPE (type) = t;
3120 static const char vptr_name[] =
3121 {'_', 'v', 'p', 't', 'r', '\0'};
3124 /* Our own class provides vtbl ptr. */
3125 for (i = TYPE_NFIELDS (t) - 1;
3126 i >= TYPE_N_BASECLASSES (t);
3129 char *fieldname = TYPE_FIELD_NAME (t, i);
3131 if ((strncmp (fieldname, vptr_name,
3132 strlen (vptr_name) - 1)
3134 && is_cplus_marker (fieldname[strlen (vptr_name)]))
3136 TYPE_VPTR_FIELDNO (type) = i;
3141 /* Complain if virtual function table field not found. */
3142 if (i < TYPE_N_BASECLASSES (t))
3143 complaint (&symfile_complaints,
3144 "virtual function table pointer not found when defining class '%s'",
3145 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3150 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3155 do_cleanups (back_to);
3159 /* No children, must be stub. */
3160 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3163 processing_current_prefix = previous_prefix;
3164 if (back_to != NULL)
3165 do_cleanups (back_to);
3169 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3171 struct objfile *objfile = cu->objfile;
3172 const char *previous_prefix = processing_current_prefix;
3173 struct die_info *child_die = die->child;
3175 if (TYPE_TAG_NAME (die->type) != NULL)
3176 processing_current_prefix = TYPE_TAG_NAME (die->type);
3178 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3179 snapshots) has been known to create a die giving a declaration
3180 for a class that has, as a child, a die giving a definition for a
3181 nested class. So we have to process our children even if the
3182 current die is a declaration. Normally, of course, a declaration
3183 won't have any children at all. */
3185 while (child_die != NULL && child_die->tag)
3187 if (child_die->tag == DW_TAG_member
3188 || child_die->tag == DW_TAG_variable
3189 || child_die->tag == DW_TAG_inheritance)
3194 process_die (child_die, cu);
3196 child_die = sibling_die (child_die);
3199 if (die->child != NULL && ! die_is_declaration (die, cu))
3200 new_symbol (die, die->type, cu);
3202 processing_current_prefix = previous_prefix;
3205 /* Given a DW_AT_enumeration_type die, set its type. We do not
3206 complete the type's fields yet, or create any symbols. */
3209 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
3211 struct objfile *objfile = cu->objfile;
3213 struct attribute *attr;
3218 type = alloc_type (objfile);
3220 TYPE_CODE (type) = TYPE_CODE_ENUM;
3221 attr = dwarf2_attr (die, DW_AT_name, cu);
3222 if (attr && DW_STRING (attr))
3224 const char *name = DW_STRING (attr);
3226 if (processing_has_namespace_info)
3228 TYPE_TAG_NAME (type) = obconcat (&objfile->objfile_obstack,
3229 processing_current_prefix,
3230 processing_current_prefix[0] == '\0'
3236 TYPE_TAG_NAME (type) = obsavestring (name, strlen (name),
3237 &objfile->objfile_obstack);
3241 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3244 TYPE_LENGTH (type) = DW_UNSND (attr);
3248 TYPE_LENGTH (type) = 0;
3254 /* Determine the name of the type represented by DIE, which should be
3255 a named C++ compound type. Return the name in question; the caller
3256 is responsible for xfree()'ing it. */
3259 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
3261 struct cleanup *back_to = NULL;
3262 struct die_info *spec_die = die_specification (die, cu);
3263 char *new_prefix = NULL;
3265 /* If this is the definition of a class that is declared by another
3266 die, then processing_current_prefix may not be accurate; see
3267 read_func_scope for a similar example. */
3268 if (spec_die != NULL)
3270 char *specification_prefix = determine_prefix (spec_die, cu);
3271 processing_current_prefix = specification_prefix;
3272 back_to = make_cleanup (xfree, specification_prefix);
3275 /* If we don't have namespace debug info, guess the name by trying
3276 to demangle the names of members, just like we did in
3277 add_partial_structure. */
3278 if (!processing_has_namespace_info)
3280 struct die_info *child;
3282 for (child = die->child;
3283 child != NULL && child->tag != 0;
3284 child = sibling_die (child))
3286 if (child->tag == DW_TAG_subprogram)
3288 new_prefix = class_name_from_physname (dwarf2_linkage_name
3291 if (new_prefix != NULL)
3297 if (new_prefix == NULL)
3299 const char *name = dwarf2_name (die, cu);
3300 new_prefix = typename_concat (processing_current_prefix,
3301 name ? name : "<<anonymous>>");
3304 if (back_to != NULL)
3305 do_cleanups (back_to);
3310 /* Given a pointer to a die which begins an enumeration, process all
3311 the dies that define the members of the enumeration, and create the
3312 symbol for the enumeration type.
3314 NOTE: We reverse the order of the element list. */
3317 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
3319 struct objfile *objfile = cu->objfile;
3320 struct die_info *child_die;
3321 struct field *fields;
3322 struct attribute *attr;
3325 int unsigned_enum = 1;
3329 if (die->child != NULL)
3331 child_die = die->child;
3332 while (child_die && child_die->tag)
3334 if (child_die->tag != DW_TAG_enumerator)
3336 process_die (child_die, cu);
3340 attr = dwarf2_attr (child_die, DW_AT_name, cu);
3343 sym = new_symbol (child_die, die->type, cu);
3344 if (SYMBOL_VALUE (sym) < 0)
3347 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
3349 fields = (struct field *)
3351 (num_fields + DW_FIELD_ALLOC_CHUNK)
3352 * sizeof (struct field));
3355 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
3356 FIELD_TYPE (fields[num_fields]) = NULL;
3357 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
3358 FIELD_BITSIZE (fields[num_fields]) = 0;
3359 FIELD_STATIC_KIND (fields[num_fields]) = 0;
3365 child_die = sibling_die (child_die);
3370 TYPE_NFIELDS (die->type) = num_fields;
3371 TYPE_FIELDS (die->type) = (struct field *)
3372 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
3373 memcpy (TYPE_FIELDS (die->type), fields,
3374 sizeof (struct field) * num_fields);
3378 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
3381 new_symbol (die, die->type, cu);
3384 /* Extract all information from a DW_TAG_array_type DIE and put it in
3385 the DIE's type field. For now, this only handles one dimensional
3389 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
3391 struct objfile *objfile = cu->objfile;
3392 struct die_info *child_die;
3393 struct type *type = NULL;
3394 struct type *element_type, *range_type, *index_type;
3395 struct type **range_types = NULL;
3396 struct attribute *attr;
3398 struct cleanup *back_to;
3400 /* Return if we've already decoded this type. */
3406 element_type = die_type (die, cu);
3408 /* Irix 6.2 native cc creates array types without children for
3409 arrays with unspecified length. */
3410 if (die->child == NULL)
3412 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
3413 range_type = create_range_type (NULL, index_type, 0, -1);
3414 die->type = create_array_type (NULL, element_type, range_type);
3418 back_to = make_cleanup (null_cleanup, NULL);
3419 child_die = die->child;
3420 while (child_die && child_die->tag)
3422 if (child_die->tag == DW_TAG_subrange_type)
3424 read_subrange_type (child_die, cu);
3426 if (child_die->type != NULL)
3428 /* The range type was succesfully read. Save it for
3429 the array type creation. */
3430 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
3432 range_types = (struct type **)
3433 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
3434 * sizeof (struct type *));
3436 make_cleanup (free_current_contents, &range_types);
3438 range_types[ndim++] = child_die->type;
3441 child_die = sibling_die (child_die);
3444 /* Dwarf2 dimensions are output from left to right, create the
3445 necessary array types in backwards order. */
3446 type = element_type;
3448 type = create_array_type (NULL, type, range_types[ndim]);
3450 /* Understand Dwarf2 support for vector types (like they occur on
3451 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3452 array type. This is not part of the Dwarf2/3 standard yet, but a
3453 custom vendor extension. The main difference between a regular
3454 array and the vector variant is that vectors are passed by value
3456 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
3458 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
3460 do_cleanups (back_to);
3462 /* Install the type in the die. */
3466 /* First cut: install each common block member as a global variable. */
3469 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
3471 struct die_info *child_die;
3472 struct attribute *attr;
3474 CORE_ADDR base = (CORE_ADDR) 0;
3476 attr = dwarf2_attr (die, DW_AT_location, cu);
3479 /* Support the .debug_loc offsets */
3480 if (attr_form_is_block (attr))
3482 base = decode_locdesc (DW_BLOCK (attr), cu);
3484 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3486 dwarf2_complex_location_expr_complaint ();
3490 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3491 "common block member");
3494 if (die->child != NULL)
3496 child_die = die->child;
3497 while (child_die && child_die->tag)
3499 sym = new_symbol (child_die, NULL, cu);
3500 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
3503 SYMBOL_VALUE_ADDRESS (sym) =
3504 base + decode_locdesc (DW_BLOCK (attr), cu);
3505 add_symbol_to_list (sym, &global_symbols);
3507 child_die = sibling_die (child_die);
3512 /* Read a C++ namespace. */
3515 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
3517 struct objfile *objfile = cu->objfile;
3518 const char *previous_prefix = processing_current_prefix;
3521 struct die_info *current_die;
3523 name = namespace_name (die, &is_anonymous, cu);
3525 /* Now build the name of the current namespace. */
3527 if (previous_prefix[0] == '\0')
3529 processing_current_prefix = name;
3533 /* We need temp_name around because processing_current_prefix
3534 is a const char *. */
3535 char *temp_name = alloca (strlen (previous_prefix)
3536 + 2 + strlen(name) + 1);
3537 strcpy (temp_name, previous_prefix);
3538 strcat (temp_name, "::");
3539 strcat (temp_name, name);
3541 processing_current_prefix = temp_name;
3544 /* Add a symbol associated to this if we haven't seen the namespace
3545 before. Also, add a using directive if it's an anonymous
3548 if (dwarf2_extension (die, cu) == NULL)
3552 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3553 this cast will hopefully become unnecessary. */
3554 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
3555 (char *) processing_current_prefix,
3557 TYPE_TAG_NAME (type) = TYPE_NAME (type);
3559 new_symbol (die, type, cu);
3563 cp_add_using_directive (processing_current_prefix,
3564 strlen (previous_prefix),
3565 strlen (processing_current_prefix));
3568 if (die->child != NULL)
3570 struct die_info *child_die = die->child;
3572 while (child_die && child_die->tag)
3574 process_die (child_die, cu);
3575 child_die = sibling_die (child_die);
3579 processing_current_prefix = previous_prefix;
3582 /* Return the name of the namespace represented by DIE. Set
3583 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3587 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
3589 struct die_info *current_die;
3590 const char *name = NULL;
3592 /* Loop through the extensions until we find a name. */
3594 for (current_die = die;
3595 current_die != NULL;
3596 current_die = dwarf2_extension (die, cu))
3598 name = dwarf2_name (current_die, cu);
3603 /* Is it an anonymous namespace? */
3605 *is_anonymous = (name == NULL);
3607 name = "(anonymous namespace)";
3612 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3613 the user defined type vector. */
3616 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
3618 struct comp_unit_head *cu_header = &cu->header;
3620 struct attribute *attr_byte_size;
3621 struct attribute *attr_address_class;
3622 int byte_size, addr_class;
3629 type = lookup_pointer_type (die_type (die, cu));
3631 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
3633 byte_size = DW_UNSND (attr_byte_size);
3635 byte_size = cu_header->addr_size;
3637 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
3638 if (attr_address_class)
3639 addr_class = DW_UNSND (attr_address_class);
3641 addr_class = DW_ADDR_none;
3643 /* If the pointer size or address class is different than the
3644 default, create a type variant marked as such and set the
3645 length accordingly. */
3646 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
3648 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3652 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
3653 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
3654 type = make_type_with_address_space (type, type_flags);
3656 else if (TYPE_LENGTH (type) != byte_size)
3658 complaint (&symfile_complaints, "invalid pointer size %d", byte_size);
3661 /* Should we also complain about unhandled address classes? */
3665 TYPE_LENGTH (type) = byte_size;
3669 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3670 the user defined type vector. */
3673 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
3675 struct objfile *objfile = cu->objfile;
3677 struct type *to_type;
3678 struct type *domain;
3685 type = alloc_type (objfile);
3686 to_type = die_type (die, cu);
3687 domain = die_containing_type (die, cu);
3688 smash_to_member_type (type, domain, to_type);
3693 /* Extract all information from a DW_TAG_reference_type DIE and add to
3694 the user defined type vector. */
3697 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
3699 struct comp_unit_head *cu_header = &cu->header;
3701 struct attribute *attr;
3708 type = lookup_reference_type (die_type (die, cu));
3709 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3712 TYPE_LENGTH (type) = DW_UNSND (attr);
3716 TYPE_LENGTH (type) = cu_header->addr_size;
3722 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
3724 struct type *base_type;
3731 base_type = die_type (die, cu);
3732 die->type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
3736 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
3738 struct type *base_type;
3745 base_type = die_type (die, cu);
3746 die->type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
3749 /* Extract all information from a DW_TAG_string_type DIE and add to
3750 the user defined type vector. It isn't really a user defined type,
3751 but it behaves like one, with other DIE's using an AT_user_def_type
3752 attribute to reference it. */
3755 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
3757 struct objfile *objfile = cu->objfile;
3758 struct type *type, *range_type, *index_type, *char_type;
3759 struct attribute *attr;
3760 unsigned int length;
3767 attr = dwarf2_attr (die, DW_AT_string_length, cu);
3770 length = DW_UNSND (attr);
3774 /* check for the DW_AT_byte_size attribute */
3775 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3778 length = DW_UNSND (attr);
3785 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
3786 range_type = create_range_type (NULL, index_type, 1, length);
3787 if (cu->language == language_fortran)
3789 /* Need to create a unique string type for bounds
3791 type = create_string_type (0, range_type);
3795 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
3796 type = create_string_type (char_type, range_type);
3801 /* Handle DIES due to C code like:
3805 int (*funcp)(int a, long l);
3809 ('funcp' generates a DW_TAG_subroutine_type DIE)
3813 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
3815 struct type *type; /* Type that this function returns */
3816 struct type *ftype; /* Function that returns above type */
3817 struct attribute *attr;
3819 /* Decode the type that this subroutine returns */
3824 type = die_type (die, cu);
3825 ftype = lookup_function_type (type);
3827 /* All functions in C++ have prototypes. */
3828 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
3829 if ((attr && (DW_UNSND (attr) != 0))
3830 || cu->language == language_cplus)
3831 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
3833 if (die->child != NULL)
3835 struct die_info *child_die;
3839 /* Count the number of parameters.
3840 FIXME: GDB currently ignores vararg functions, but knows about
3841 vararg member functions. */
3842 child_die = die->child;
3843 while (child_die && child_die->tag)
3845 if (child_die->tag == DW_TAG_formal_parameter)
3847 else if (child_die->tag == DW_TAG_unspecified_parameters)
3848 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
3849 child_die = sibling_die (child_die);
3852 /* Allocate storage for parameters and fill them in. */
3853 TYPE_NFIELDS (ftype) = nparams;
3854 TYPE_FIELDS (ftype) = (struct field *)
3855 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
3857 child_die = die->child;
3858 while (child_die && child_die->tag)
3860 if (child_die->tag == DW_TAG_formal_parameter)
3862 /* Dwarf2 has no clean way to discern C++ static and non-static
3863 member functions. G++ helps GDB by marking the first
3864 parameter for non-static member functions (which is the
3865 this pointer) as artificial. We pass this information
3866 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3867 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
3869 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
3871 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
3872 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
3875 child_die = sibling_die (child_die);
3883 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
3885 struct objfile *objfile = cu->objfile;
3886 struct attribute *attr;
3891 attr = dwarf2_attr (die, DW_AT_name, cu);
3892 if (attr && DW_STRING (attr))
3894 name = DW_STRING (attr);
3896 die->type = init_type (TYPE_CODE_TYPEDEF, 0, TYPE_FLAG_TARGET_STUB, name, objfile);
3897 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
3901 /* Find a representation of a given base type and install
3902 it in the TYPE field of the die. */
3905 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
3907 struct objfile *objfile = cu->objfile;
3909 struct attribute *attr;
3910 int encoding = 0, size = 0;
3912 /* If we've already decoded this die, this is a no-op. */
3918 attr = dwarf2_attr (die, DW_AT_encoding, cu);
3921 encoding = DW_UNSND (attr);
3923 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3926 size = DW_UNSND (attr);
3928 attr = dwarf2_attr (die, DW_AT_name, cu);
3929 if (attr && DW_STRING (attr))
3931 enum type_code code = TYPE_CODE_INT;
3936 case DW_ATE_address:
3937 /* Turn DW_ATE_address into a void * pointer. */
3938 code = TYPE_CODE_PTR;
3939 type_flags |= TYPE_FLAG_UNSIGNED;
3941 case DW_ATE_boolean:
3942 code = TYPE_CODE_BOOL;
3943 type_flags |= TYPE_FLAG_UNSIGNED;
3945 case DW_ATE_complex_float:
3946 code = TYPE_CODE_COMPLEX;
3949 code = TYPE_CODE_FLT;
3952 case DW_ATE_signed_char:
3954 case DW_ATE_unsigned:
3955 case DW_ATE_unsigned_char:
3956 type_flags |= TYPE_FLAG_UNSIGNED;
3959 complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'",
3960 dwarf_type_encoding_name (encoding));
3963 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
3964 if (encoding == DW_ATE_address)
3965 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
3967 else if (encoding == DW_ATE_complex_float)
3970 TYPE_TARGET_TYPE (type)
3971 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
3972 else if (size == 16)
3973 TYPE_TARGET_TYPE (type)
3974 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
3976 TYPE_TARGET_TYPE (type)
3977 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
3982 type = dwarf_base_type (encoding, size, cu);
3987 /* Read the given DW_AT_subrange DIE. */
3990 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
3992 struct type *base_type;
3993 struct type *range_type;
3994 struct attribute *attr;
3998 /* If we have already decoded this die, then nothing more to do. */
4002 base_type = die_type (die, cu);
4003 if (base_type == NULL)
4005 complaint (&symfile_complaints,
4006 "DW_AT_type missing from DW_TAG_subrange_type");
4010 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4011 base_type = alloc_type (NULL);
4013 if (cu->language == language_fortran)
4015 /* FORTRAN implies a lower bound of 1, if not given. */
4019 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4021 low = dwarf2_get_attr_constant_value (attr, 0);
4023 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4026 if (attr->form == DW_FORM_block1)
4028 /* GCC encodes arrays with unspecified or dynamic length
4029 with a DW_FORM_block1 attribute.
4030 FIXME: GDB does not yet know how to handle dynamic
4031 arrays properly, treat them as arrays with unspecified
4034 FIXME: jimb/2003-09-22: GDB does not really know
4035 how to handle arrays of unspecified length
4036 either; we just represent them as zero-length
4037 arrays. Choose an appropriate upper bound given
4038 the lower bound we've computed above. */
4042 high = dwarf2_get_attr_constant_value (attr, 1);
4045 range_type = create_range_type (NULL, base_type, low, high);
4047 attr = dwarf2_attr (die, DW_AT_name, cu);
4048 if (attr && DW_STRING (attr))
4049 TYPE_NAME (range_type) = DW_STRING (attr);
4051 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4053 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4055 die->type = range_type;
4059 /* Read a whole compilation unit into a linked list of dies. */
4061 static struct die_info *
4062 read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4064 /* Reset die reference table; we are
4065 building new ones now. */
4066 dwarf2_empty_hash_tables ();
4068 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4071 /* Read a single die and all its descendents. Set the die's sibling
4072 field to NULL; set other fields in the die correctly, and set all
4073 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4074 location of the info_ptr after reading all of those dies. PARENT
4075 is the parent of the die in question. */
4077 static struct die_info *
4078 read_die_and_children (char *info_ptr, bfd *abfd,
4079 struct dwarf2_cu *cu,
4080 char **new_info_ptr,
4081 struct die_info *parent)
4083 struct die_info *die;
4087 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4088 store_in_ref_table (die->offset, die);
4092 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4098 *new_info_ptr = cur_ptr;
4101 die->sibling = NULL;
4102 die->parent = parent;
4106 /* Read a die, all of its descendents, and all of its siblings; set
4107 all of the fields of all of the dies correctly. Arguments are as
4108 in read_die_and_children. */
4110 static struct die_info *
4111 read_die_and_siblings (char *info_ptr, bfd *abfd,
4112 struct dwarf2_cu *cu,
4113 char **new_info_ptr,
4114 struct die_info *parent)
4116 struct die_info *first_die, *last_sibling;
4120 first_die = last_sibling = NULL;
4124 struct die_info *die
4125 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
4133 last_sibling->sibling = die;
4138 *new_info_ptr = cur_ptr;
4148 /* Free a linked list of dies. */
4151 free_die_list (struct die_info *dies)
4153 struct die_info *die, *next;
4158 if (die->child != NULL)
4159 free_die_list (die->child);
4160 next = die->sibling;
4168 do_free_die_list_cleanup (void *dies)
4170 free_die_list (dies);
4173 static struct cleanup *
4174 make_cleanup_free_die_list (struct die_info *dies)
4176 return make_cleanup (do_free_die_list_cleanup, dies);
4180 /* Read the contents of the section at OFFSET and of size SIZE from the
4181 object file specified by OBJFILE into the objfile_obstack and return it. */
4184 dwarf2_read_section (struct objfile *objfile, asection *sectp)
4186 bfd *abfd = objfile->obfd;
4188 bfd_size_type size = bfd_get_section_size_before_reloc (sectp);
4193 buf = (char *) obstack_alloc (&objfile->objfile_obstack, size);
4195 = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf);
4199 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
4200 || bfd_bread (buf, size, abfd) != size)
4201 error ("Dwarf Error: Can't read DWARF data from '%s'",
4202 bfd_get_filename (abfd));
4207 /* In DWARF version 2, the description of the debugging information is
4208 stored in a separate .debug_abbrev section. Before we read any
4209 dies from a section we read in all abbreviations and install them
4213 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
4215 struct comp_unit_head *cu_header = &cu->header;
4217 struct abbrev_info *cur_abbrev;
4218 unsigned int abbrev_number, bytes_read, abbrev_name;
4219 unsigned int abbrev_form, hash_number;
4221 /* Initialize dwarf2 abbrevs */
4222 memset (cu_header->dwarf2_abbrevs, 0,
4223 ABBREV_HASH_SIZE*sizeof (struct abbrev_info *));
4225 abbrev_ptr = dwarf_abbrev_buffer + cu_header->abbrev_offset;
4226 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4227 abbrev_ptr += bytes_read;
4229 /* loop until we reach an abbrev number of 0 */
4230 while (abbrev_number)
4232 cur_abbrev = dwarf_alloc_abbrev ();
4234 /* read in abbrev header */
4235 cur_abbrev->number = abbrev_number;
4236 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4237 abbrev_ptr += bytes_read;
4238 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
4241 /* now read in declarations */
4242 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4243 abbrev_ptr += bytes_read;
4244 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4245 abbrev_ptr += bytes_read;
4248 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
4250 cur_abbrev->attrs = (struct attr_abbrev *)
4251 xrealloc (cur_abbrev->attrs,
4252 (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
4253 * sizeof (struct attr_abbrev));
4255 cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
4256 cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
4257 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4258 abbrev_ptr += bytes_read;
4259 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4260 abbrev_ptr += bytes_read;
4263 hash_number = abbrev_number % ABBREV_HASH_SIZE;
4264 cur_abbrev->next = cu_header->dwarf2_abbrevs[hash_number];
4265 cu_header->dwarf2_abbrevs[hash_number] = cur_abbrev;
4267 /* Get next abbreviation.
4268 Under Irix6 the abbreviations for a compilation unit are not
4269 always properly terminated with an abbrev number of 0.
4270 Exit loop if we encounter an abbreviation which we have
4271 already read (which means we are about to read the abbreviations
4272 for the next compile unit) or if the end of the abbreviation
4273 table is reached. */
4274 if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
4275 >= dwarf_abbrev_size)
4277 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4278 abbrev_ptr += bytes_read;
4279 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
4284 /* Empty the abbrev table for a new compilation unit. */
4287 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table)
4290 struct abbrev_info *abbrev, *next;
4291 struct abbrev_info **abbrevs;
4293 abbrevs = (struct abbrev_info **)ptr_to_abbrevs_table;
4295 for (i = 0; i < ABBREV_HASH_SIZE; ++i)
4298 abbrev = abbrevs[i];
4301 next = abbrev->next;
4302 xfree (abbrev->attrs);
4310 /* Lookup an abbrev_info structure in the abbrev hash table. */
4312 static struct abbrev_info *
4313 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
4315 struct comp_unit_head *cu_header = &cu->header;
4316 unsigned int hash_number;
4317 struct abbrev_info *abbrev;
4319 hash_number = number % ABBREV_HASH_SIZE;
4320 abbrev = cu_header->dwarf2_abbrevs[hash_number];
4324 if (abbrev->number == number)
4327 abbrev = abbrev->next;
4332 /* Read a minimal amount of information into the minimal die structure. */
4335 read_partial_die (struct partial_die_info *part_die, bfd *abfd,
4336 char *info_ptr, struct dwarf2_cu *cu)
4338 unsigned int abbrev_number, bytes_read, i;
4339 struct abbrev_info *abbrev;
4340 struct attribute attr;
4341 struct attribute spec_attr;
4342 int found_spec_attr = 0;
4343 int has_low_pc_attr = 0;
4344 int has_high_pc_attr = 0;
4346 *part_die = zeroed_partial_die;
4347 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4348 info_ptr += bytes_read;
4352 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4355 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number,
4356 bfd_get_filename (abfd));
4358 part_die->offset = info_ptr - dwarf_info_buffer;
4359 part_die->tag = abbrev->tag;
4360 part_die->has_children = abbrev->has_children;
4361 part_die->abbrev = abbrev_number;
4363 for (i = 0; i < abbrev->num_attrs; ++i)
4365 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
4367 /* Store the data if it is of an attribute we want to keep in a
4368 partial symbol table. */
4373 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4374 if (part_die->name == NULL)
4375 part_die->name = DW_STRING (&attr);
4377 case DW_AT_MIPS_linkage_name:
4378 part_die->name = DW_STRING (&attr);
4381 has_low_pc_attr = 1;
4382 part_die->lowpc = DW_ADDR (&attr);
4385 has_high_pc_attr = 1;
4386 part_die->highpc = DW_ADDR (&attr);
4388 case DW_AT_location:
4389 /* Support the .debug_loc offsets */
4390 if (attr_form_is_block (&attr))
4392 part_die->locdesc = DW_BLOCK (&attr);
4394 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
4396 dwarf2_complex_location_expr_complaint ();
4400 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4401 "partial symbol information");
4404 case DW_AT_language:
4405 part_die->language = DW_UNSND (&attr);
4407 case DW_AT_external:
4408 part_die->is_external = DW_UNSND (&attr);
4410 case DW_AT_declaration:
4411 part_die->is_declaration = DW_UNSND (&attr);
4414 part_die->has_type = 1;
4416 case DW_AT_abstract_origin:
4417 case DW_AT_specification:
4418 found_spec_attr = 1;
4422 /* Ignore absolute siblings, they might point outside of
4423 the current compile unit. */
4424 if (attr.form == DW_FORM_ref_addr)
4425 complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
4428 dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr, cu);
4435 /* If we found a reference attribute and the die has no name, try
4436 to find a name in the referred to die. */
4438 if (found_spec_attr && part_die->name == NULL)
4440 struct partial_die_info spec_die;
4443 spec_ptr = dwarf_info_buffer
4444 + dwarf2_get_ref_die_offset (&spec_attr, cu);
4445 read_partial_die (&spec_die, abfd, spec_ptr, cu);
4448 part_die->name = spec_die.name;
4450 /* Copy DW_AT_external attribute if it is set. */
4451 if (spec_die.is_external)
4452 part_die->is_external = spec_die.is_external;
4456 /* When using the GNU linker, .gnu.linkonce. sections are used to
4457 eliminate duplicate copies of functions and vtables and such.
4458 The linker will arbitrarily choose one and discard the others.
4459 The AT_*_pc values for such functions refer to local labels in
4460 these sections. If the section from that file was discarded, the
4461 labels are not in the output, so the relocs get a value of 0.
4462 If this is a discarded function, mark the pc bounds as invalid,
4463 so that GDB will ignore it. */
4464 if (has_low_pc_attr && has_high_pc_attr
4465 && part_die->lowpc < part_die->highpc
4466 && (part_die->lowpc != 0
4467 || (bfd_get_file_flags (abfd) & HAS_RELOC)))
4468 part_die->has_pc_info = 1;
4472 /* Read the die from the .debug_info section buffer. Set DIEP to
4473 point to a newly allocated die with its information, except for its
4474 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4475 whether the die has children or not. */
4478 read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr,
4479 struct dwarf2_cu *cu, int *has_children)
4481 unsigned int abbrev_number, bytes_read, i, offset;
4482 struct abbrev_info *abbrev;
4483 struct die_info *die;
4485 offset = info_ptr - dwarf_info_buffer;
4486 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4487 info_ptr += bytes_read;
4490 die = dwarf_alloc_die ();
4492 die->abbrev = abbrev_number;
4499 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4502 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4504 bfd_get_filename (abfd));
4506 die = dwarf_alloc_die ();
4507 die->offset = offset;
4508 die->tag = abbrev->tag;
4509 die->abbrev = abbrev_number;
4512 die->num_attrs = abbrev->num_attrs;
4513 die->attrs = (struct attribute *)
4514 xmalloc (die->num_attrs * sizeof (struct attribute));
4516 for (i = 0; i < abbrev->num_attrs; ++i)
4518 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
4519 abfd, info_ptr, cu);
4523 *has_children = abbrev->has_children;
4527 /* Read an attribute value described by an attribute form. */
4530 read_attribute_value (struct attribute *attr, unsigned form,
4531 bfd *abfd, char *info_ptr,
4532 struct dwarf2_cu *cu)
4534 struct comp_unit_head *cu_header = &cu->header;
4535 unsigned int bytes_read;
4536 struct dwarf_block *blk;
4542 case DW_FORM_ref_addr:
4543 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
4544 info_ptr += bytes_read;
4546 case DW_FORM_block2:
4547 blk = dwarf_alloc_block ();
4548 blk->size = read_2_bytes (abfd, info_ptr);
4550 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4551 info_ptr += blk->size;
4552 DW_BLOCK (attr) = blk;
4554 case DW_FORM_block4:
4555 blk = dwarf_alloc_block ();
4556 blk->size = read_4_bytes (abfd, info_ptr);
4558 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4559 info_ptr += blk->size;
4560 DW_BLOCK (attr) = blk;
4563 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4567 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4571 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4574 case DW_FORM_string:
4575 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
4576 info_ptr += bytes_read;
4579 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
4581 info_ptr += bytes_read;
4584 blk = dwarf_alloc_block ();
4585 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4586 info_ptr += bytes_read;
4587 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4588 info_ptr += blk->size;
4589 DW_BLOCK (attr) = blk;
4591 case DW_FORM_block1:
4592 blk = dwarf_alloc_block ();
4593 blk->size = read_1_byte (abfd, info_ptr);
4595 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4596 info_ptr += blk->size;
4597 DW_BLOCK (attr) = blk;
4600 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4604 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4608 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
4609 info_ptr += bytes_read;
4612 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4613 info_ptr += bytes_read;
4616 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4620 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4624 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4628 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4631 case DW_FORM_ref_udata:
4632 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4633 info_ptr += bytes_read;
4635 case DW_FORM_indirect:
4636 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4637 info_ptr += bytes_read;
4638 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
4641 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4642 dwarf_form_name (form),
4643 bfd_get_filename (abfd));
4648 /* Read an attribute described by an abbreviated attribute. */
4651 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
4652 bfd *abfd, char *info_ptr, struct dwarf2_cu *cu)
4654 attr->name = abbrev->name;
4655 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
4658 /* read dwarf information from a buffer */
4661 read_1_byte (bfd *abfd, char *buf)
4663 return bfd_get_8 (abfd, (bfd_byte *) buf);
4667 read_1_signed_byte (bfd *abfd, char *buf)
4669 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
4673 read_2_bytes (bfd *abfd, char *buf)
4675 return bfd_get_16 (abfd, (bfd_byte *) buf);
4679 read_2_signed_bytes (bfd *abfd, char *buf)
4681 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4685 read_4_bytes (bfd *abfd, char *buf)
4687 return bfd_get_32 (abfd, (bfd_byte *) buf);
4691 read_4_signed_bytes (bfd *abfd, char *buf)
4693 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4696 static unsigned long
4697 read_8_bytes (bfd *abfd, char *buf)
4699 return bfd_get_64 (abfd, (bfd_byte *) buf);
4703 read_address (bfd *abfd, char *buf, struct dwarf2_cu *cu, int *bytes_read)
4705 struct comp_unit_head *cu_header = &cu->header;
4706 CORE_ADDR retval = 0;
4708 if (cu_header->signed_addr_p)
4710 switch (cu_header->addr_size)
4713 retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4716 retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4719 retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf);
4722 internal_error (__FILE__, __LINE__,
4723 "read_address: bad switch, signed [in module %s]",
4724 bfd_get_filename (abfd));
4729 switch (cu_header->addr_size)
4732 retval = bfd_get_16 (abfd, (bfd_byte *) buf);
4735 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4738 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4741 internal_error (__FILE__, __LINE__,
4742 "read_address: bad switch, unsigned [in module %s]",
4743 bfd_get_filename (abfd));
4747 *bytes_read = cu_header->addr_size;
4751 /* Read the initial length from a section. The (draft) DWARF 3
4752 specification allows the initial length to take up either 4 bytes
4753 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4754 bytes describe the length and all offsets will be 8 bytes in length
4757 An older, non-standard 64-bit format is also handled by this
4758 function. The older format in question stores the initial length
4759 as an 8-byte quantity without an escape value. Lengths greater
4760 than 2^32 aren't very common which means that the initial 4 bytes
4761 is almost always zero. Since a length value of zero doesn't make
4762 sense for the 32-bit format, this initial zero can be considered to
4763 be an escape value which indicates the presence of the older 64-bit
4764 format. As written, the code can't detect (old format) lengths
4765 greater than 4GB. If it becomes necessary to handle lengths somewhat
4766 larger than 4GB, we could allow other small values (such as the
4767 non-sensical values of 1, 2, and 3) to also be used as escape values
4768 indicating the presence of the old format.
4770 The value returned via bytes_read should be used to increment
4771 the relevant pointer after calling read_initial_length().
4773 As a side effect, this function sets the fields initial_length_size
4774 and offset_size in cu_header to the values appropriate for the
4775 length field. (The format of the initial length field determines
4776 the width of file offsets to be fetched later with fetch_offset().)
4778 [ Note: read_initial_length() and read_offset() are based on the
4779 document entitled "DWARF Debugging Information Format", revision
4780 3, draft 8, dated November 19, 2001. This document was obtained
4783 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4785 This document is only a draft and is subject to change. (So beware.)
4787 Details regarding the older, non-standard 64-bit format were
4788 determined empirically by examining 64-bit ELF files produced
4789 by the SGI toolchain on an IRIX 6.5 machine.
4791 - Kevin, July 16, 2002
4795 read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header,
4800 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4802 if (retval == 0xffffffff)
4804 retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
4806 if (cu_header != NULL)
4808 cu_header->initial_length_size = 12;
4809 cu_header->offset_size = 8;
4812 else if (retval == 0)
4814 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4816 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4818 if (cu_header != NULL)
4820 cu_header->initial_length_size = 8;
4821 cu_header->offset_size = 8;
4827 if (cu_header != NULL)
4829 cu_header->initial_length_size = 4;
4830 cu_header->offset_size = 4;
4837 /* Read an offset from the data stream. The size of the offset is
4838 given by cu_header->offset_size. */
4841 read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
4846 switch (cu_header->offset_size)
4849 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4853 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4857 internal_error (__FILE__, __LINE__,
4858 "read_offset: bad switch [in module %s]",
4859 bfd_get_filename (abfd));
4866 read_n_bytes (bfd *abfd, char *buf, unsigned int size)
4868 /* If the size of a host char is 8 bits, we can return a pointer
4869 to the buffer, otherwise we have to copy the data to a buffer
4870 allocated on the temporary obstack. */
4871 gdb_assert (HOST_CHAR_BIT == 8);
4876 read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4878 /* If the size of a host char is 8 bits, we can return a pointer
4879 to the string, otherwise we have to copy the string to a buffer
4880 allocated on the temporary obstack. */
4881 gdb_assert (HOST_CHAR_BIT == 8);
4884 *bytes_read_ptr = 1;
4887 *bytes_read_ptr = strlen (buf) + 1;
4892 read_indirect_string (bfd *abfd, char *buf,
4893 const struct comp_unit_head *cu_header,
4894 unsigned int *bytes_read_ptr)
4896 LONGEST str_offset = read_offset (abfd, buf, cu_header,
4897 (int *) bytes_read_ptr);
4899 if (dwarf_str_buffer == NULL)
4901 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4902 bfd_get_filename (abfd));
4905 if (str_offset >= dwarf_str_size)
4907 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4908 bfd_get_filename (abfd));
4911 gdb_assert (HOST_CHAR_BIT == 8);
4912 if (dwarf_str_buffer[str_offset] == '\0')
4914 return dwarf_str_buffer + str_offset;
4917 static unsigned long
4918 read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4920 unsigned long result;
4921 unsigned int num_read;
4931 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4934 result |= ((unsigned long)(byte & 127) << shift);
4935 if ((byte & 128) == 0)
4941 *bytes_read_ptr = num_read;
4946 read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4949 int i, shift, size, num_read;
4959 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4962 result |= ((long)(byte & 127) << shift);
4964 if ((byte & 128) == 0)
4969 if ((shift < size) && (byte & 0x40))
4971 result |= -(1 << shift);
4973 *bytes_read_ptr = num_read;
4978 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
4984 cu->language = language_c;
4986 case DW_LANG_C_plus_plus:
4987 cu->language = language_cplus;
4989 case DW_LANG_Fortran77:
4990 case DW_LANG_Fortran90:
4991 case DW_LANG_Fortran95:
4992 cu->language = language_fortran;
4994 case DW_LANG_Mips_Assembler:
4995 cu->language = language_asm;
4998 cu->language = language_java;
5002 case DW_LANG_Cobol74:
5003 case DW_LANG_Cobol85:
5004 case DW_LANG_Pascal83:
5005 case DW_LANG_Modula2:
5007 cu->language = language_minimal;
5010 cu->language_defn = language_def (cu->language);
5013 /* Return the named attribute or NULL if not there. */
5015 static struct attribute *
5016 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
5019 struct attribute *spec = NULL;
5021 for (i = 0; i < die->num_attrs; ++i)
5023 if (die->attrs[i].name == name)
5025 return &die->attrs[i];
5027 if (die->attrs[i].name == DW_AT_specification
5028 || die->attrs[i].name == DW_AT_abstract_origin)
5029 spec = &die->attrs[i];
5033 struct die_info *ref_die =
5034 follow_die_ref (dwarf2_get_ref_die_offset (spec, cu));
5037 return dwarf2_attr (ref_die, name, cu);
5044 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
5046 return (dwarf2_attr (die, DW_AT_declaration, cu)
5047 && ! dwarf2_attr (die, DW_AT_specification, cu));
5050 /* Return the die giving the specification for DIE, if there is
5053 static struct die_info *
5054 die_specification (struct die_info *die, struct dwarf2_cu *cu)
5056 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
5058 if (spec_attr == NULL)
5061 return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr, cu));
5064 /* Free the line_header structure *LH, and any arrays and strings it
5067 free_line_header (struct line_header *lh)
5069 if (lh->standard_opcode_lengths)
5070 xfree (lh->standard_opcode_lengths);
5072 /* Remember that all the lh->file_names[i].name pointers are
5073 pointers into debug_line_buffer, and don't need to be freed. */
5075 xfree (lh->file_names);
5077 /* Similarly for the include directory names. */
5078 if (lh->include_dirs)
5079 xfree (lh->include_dirs);
5085 /* Add an entry to LH's include directory table. */
5087 add_include_dir (struct line_header *lh, char *include_dir)
5089 /* Grow the array if necessary. */
5090 if (lh->include_dirs_size == 0)
5092 lh->include_dirs_size = 1; /* for testing */
5093 lh->include_dirs = xmalloc (lh->include_dirs_size
5094 * sizeof (*lh->include_dirs));
5096 else if (lh->num_include_dirs >= lh->include_dirs_size)
5098 lh->include_dirs_size *= 2;
5099 lh->include_dirs = xrealloc (lh->include_dirs,
5100 (lh->include_dirs_size
5101 * sizeof (*lh->include_dirs)));
5104 lh->include_dirs[lh->num_include_dirs++] = include_dir;
5108 /* Add an entry to LH's file name table. */
5110 add_file_name (struct line_header *lh,
5112 unsigned int dir_index,
5113 unsigned int mod_time,
5114 unsigned int length)
5116 struct file_entry *fe;
5118 /* Grow the array if necessary. */
5119 if (lh->file_names_size == 0)
5121 lh->file_names_size = 1; /* for testing */
5122 lh->file_names = xmalloc (lh->file_names_size
5123 * sizeof (*lh->file_names));
5125 else if (lh->num_file_names >= lh->file_names_size)
5127 lh->file_names_size *= 2;
5128 lh->file_names = xrealloc (lh->file_names,
5129 (lh->file_names_size
5130 * sizeof (*lh->file_names)));
5133 fe = &lh->file_names[lh->num_file_names++];
5135 fe->dir_index = dir_index;
5136 fe->mod_time = mod_time;
5137 fe->length = length;
5141 /* Read the statement program header starting at OFFSET in
5142 dwarf_line_buffer, according to the endianness of ABFD. Return a
5143 pointer to a struct line_header, allocated using xmalloc.
5145 NOTE: the strings in the include directory and file name tables of
5146 the returned object point into debug_line_buffer, and must not be
5148 static struct line_header *
5149 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
5150 struct dwarf2_cu *cu)
5152 struct cleanup *back_to;
5153 struct line_header *lh;
5157 char *cur_dir, *cur_file;
5159 if (dwarf_line_buffer == NULL)
5161 complaint (&symfile_complaints, "missing .debug_line section");
5165 /* Make sure that at least there's room for the total_length field. That
5166 could be 12 bytes long, but we're just going to fudge that. */
5167 if (offset + 4 >= dwarf_line_size)
5169 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5173 lh = xmalloc (sizeof (*lh));
5174 memset (lh, 0, sizeof (*lh));
5175 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
5178 line_ptr = dwarf_line_buffer + offset;
5180 /* read in the header */
5181 lh->total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read);
5182 line_ptr += bytes_read;
5183 if (line_ptr + lh->total_length > dwarf_line_buffer + dwarf_line_size)
5185 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5188 lh->statement_program_end = line_ptr + lh->total_length;
5189 lh->version = read_2_bytes (abfd, line_ptr);
5191 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
5192 line_ptr += bytes_read;
5193 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
5195 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
5197 lh->line_base = read_1_signed_byte (abfd, line_ptr);
5199 lh->line_range = read_1_byte (abfd, line_ptr);
5201 lh->opcode_base = read_1_byte (abfd, line_ptr);
5203 lh->standard_opcode_lengths
5204 = (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char));
5206 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
5207 for (i = 1; i < lh->opcode_base; ++i)
5209 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
5213 /* Read directory table */
5214 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5216 line_ptr += bytes_read;
5217 add_include_dir (lh, cur_dir);
5219 line_ptr += bytes_read;
5221 /* Read file name table */
5222 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5224 unsigned int dir_index, mod_time, length;
5226 line_ptr += bytes_read;
5227 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5228 line_ptr += bytes_read;
5229 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5230 line_ptr += bytes_read;
5231 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5232 line_ptr += bytes_read;
5234 add_file_name (lh, cur_file, dir_index, mod_time, length);
5236 line_ptr += bytes_read;
5237 lh->statement_program_start = line_ptr;
5239 if (line_ptr > dwarf_line_buffer + dwarf_line_size)
5240 complaint (&symfile_complaints,
5241 "line number info header doesn't fit in `.debug_line' section");
5243 discard_cleanups (back_to);
5247 /* This function exists to work around a bug in certain compilers
5248 (particularly GCC 2.95), in which the first line number marker of a
5249 function does not show up until after the prologue, right before
5250 the second line number marker. This function shifts ADDRESS down
5251 to the beginning of the function if necessary, and is called on
5252 addresses passed to record_line. */
5255 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
5257 struct function_range *fn;
5259 /* Find the function_range containing address. */
5264 cu->cached_fn = cu->first_fn;
5268 if (fn->lowpc <= address && fn->highpc > address)
5274 while (fn && fn != cu->cached_fn)
5275 if (fn->lowpc <= address && fn->highpc > address)
5285 if (address != fn->lowpc)
5286 complaint (&symfile_complaints,
5287 "misplaced first line number at 0x%lx for '%s'",
5288 (unsigned long) address, fn->name);
5293 /* Decode the line number information for the compilation unit whose
5294 line number info is at OFFSET in the .debug_line section.
5295 The compilation directory of the file is passed in COMP_DIR. */
5298 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
5299 struct dwarf2_cu *cu)
5303 unsigned int bytes_read;
5304 unsigned char op_code, extended_op, adj_opcode;
5306 struct objfile *objfile = cu->objfile;
5308 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5310 line_ptr = lh->statement_program_start;
5311 line_end = lh->statement_program_end;
5313 /* Read the statement sequences until there's nothing left. */
5314 while (line_ptr < line_end)
5316 /* state machine registers */
5317 CORE_ADDR address = 0;
5318 unsigned int file = 1;
5319 unsigned int line = 1;
5320 unsigned int column = 0;
5321 int is_stmt = lh->default_is_stmt;
5322 int basic_block = 0;
5323 int end_sequence = 0;
5325 /* Start a subfile for the current file of the state machine. */
5326 if (lh->num_file_names >= file)
5328 /* lh->include_dirs and lh->file_names are 0-based, but the
5329 directory and file name numbers in the statement program
5331 struct file_entry *fe = &lh->file_names[file - 1];
5334 dir = lh->include_dirs[fe->dir_index - 1];
5337 dwarf2_start_subfile (fe->name, dir);
5340 /* Decode the table. */
5341 while (!end_sequence)
5343 op_code = read_1_byte (abfd, line_ptr);
5346 if (op_code >= lh->opcode_base)
5347 { /* Special operand. */
5348 adj_opcode = op_code - lh->opcode_base;
5349 address += (adj_opcode / lh->line_range)
5350 * lh->minimum_instruction_length;
5351 line += lh->line_base + (adj_opcode % lh->line_range);
5352 /* append row to matrix using current values */
5353 record_line (current_subfile, line,
5354 check_cu_functions (address, cu));
5357 else switch (op_code)
5359 case DW_LNS_extended_op:
5360 line_ptr += 1; /* ignore length */
5361 extended_op = read_1_byte (abfd, line_ptr);
5363 switch (extended_op)
5365 case DW_LNE_end_sequence:
5367 record_line (current_subfile, 0, address);
5369 case DW_LNE_set_address:
5370 address = read_address (abfd, line_ptr, cu, &bytes_read);
5371 line_ptr += bytes_read;
5372 address += baseaddr;
5374 case DW_LNE_define_file:
5377 unsigned int dir_index, mod_time, length;
5379 cur_file = read_string (abfd, line_ptr, &bytes_read);
5380 line_ptr += bytes_read;
5382 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5383 line_ptr += bytes_read;
5385 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5386 line_ptr += bytes_read;
5388 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5389 line_ptr += bytes_read;
5390 add_file_name (lh, cur_file, dir_index, mod_time, length);
5394 complaint (&symfile_complaints,
5395 "mangled .debug_line section");
5400 record_line (current_subfile, line,
5401 check_cu_functions (address, cu));
5404 case DW_LNS_advance_pc:
5405 address += lh->minimum_instruction_length
5406 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5407 line_ptr += bytes_read;
5409 case DW_LNS_advance_line:
5410 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
5411 line_ptr += bytes_read;
5413 case DW_LNS_set_file:
5415 /* lh->include_dirs and lh->file_names are 0-based,
5416 but the directory and file name numbers in the
5417 statement program are 1-based. */
5418 struct file_entry *fe;
5420 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5421 line_ptr += bytes_read;
5422 fe = &lh->file_names[file - 1];
5424 dir = lh->include_dirs[fe->dir_index - 1];
5427 dwarf2_start_subfile (fe->name, dir);
5430 case DW_LNS_set_column:
5431 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5432 line_ptr += bytes_read;
5434 case DW_LNS_negate_stmt:
5435 is_stmt = (!is_stmt);
5437 case DW_LNS_set_basic_block:
5440 /* Add to the address register of the state machine the
5441 address increment value corresponding to special opcode
5442 255. Ie, this value is scaled by the minimum instruction
5443 length since special opcode 255 would have scaled the
5445 case DW_LNS_const_add_pc:
5446 address += (lh->minimum_instruction_length
5447 * ((255 - lh->opcode_base) / lh->line_range));
5449 case DW_LNS_fixed_advance_pc:
5450 address += read_2_bytes (abfd, line_ptr);
5454 { /* Unknown standard opcode, ignore it. */
5456 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
5458 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5459 line_ptr += bytes_read;
5467 /* Start a subfile for DWARF. FILENAME is the name of the file and
5468 DIRNAME the name of the source directory which contains FILENAME
5469 or NULL if not known.
5470 This routine tries to keep line numbers from identical absolute and
5471 relative file names in a common subfile.
5473 Using the `list' example from the GDB testsuite, which resides in
5474 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5475 of /srcdir/list0.c yields the following debugging information for list0.c:
5477 DW_AT_name: /srcdir/list0.c
5478 DW_AT_comp_dir: /compdir
5479 files.files[0].name: list0.h
5480 files.files[0].dir: /srcdir
5481 files.files[1].name: list0.c
5482 files.files[1].dir: /srcdir
5484 The line number information for list0.c has to end up in a single
5485 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5488 dwarf2_start_subfile (char *filename, char *dirname)
5490 /* If the filename isn't absolute, try to match an existing subfile
5491 with the full pathname. */
5493 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
5495 struct subfile *subfile;
5496 char *fullname = concat (dirname, "/", filename, NULL);
5498 for (subfile = subfiles; subfile; subfile = subfile->next)
5500 if (FILENAME_CMP (subfile->name, fullname) == 0)
5502 current_subfile = subfile;
5509 start_subfile (filename, dirname);
5513 var_decode_location (struct attribute *attr, struct symbol *sym,
5514 struct dwarf2_cu *cu)
5516 struct objfile *objfile = cu->objfile;
5517 struct comp_unit_head *cu_header = &cu->header;
5519 /* NOTE drow/2003-01-30: There used to be a comment and some special
5520 code here to turn a symbol with DW_AT_external and a
5521 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5522 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5523 with some versions of binutils) where shared libraries could have
5524 relocations against symbols in their debug information - the
5525 minimal symbol would have the right address, but the debug info
5526 would not. It's no longer necessary, because we will explicitly
5527 apply relocations when we read in the debug information now. */
5529 /* A DW_AT_location attribute with no contents indicates that a
5530 variable has been optimized away. */
5531 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
5533 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
5537 /* Handle one degenerate form of location expression specially, to
5538 preserve GDB's previous behavior when section offsets are
5539 specified. If this is just a DW_OP_addr then mark this symbol
5542 if (attr_form_is_block (attr)
5543 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
5544 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
5548 SYMBOL_VALUE_ADDRESS (sym) =
5549 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
5550 fixup_symbol_section (sym, objfile);
5551 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
5552 SYMBOL_SECTION (sym));
5553 SYMBOL_CLASS (sym) = LOC_STATIC;
5557 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5558 expression evaluator, and use LOC_COMPUTED only when necessary
5559 (i.e. when the value of a register or memory location is
5560 referenced, or a thread-local block, etc.). Then again, it might
5561 not be worthwhile. I'm assuming that it isn't unless performance
5562 or memory numbers show me otherwise. */
5564 dwarf2_symbol_mark_computed (attr, sym, cu);
5565 SYMBOL_CLASS (sym) = LOC_COMPUTED;
5568 /* Given a pointer to a DWARF information entry, figure out if we need
5569 to make a symbol table entry for it, and if so, create a new entry
5570 and return a pointer to it.
5571 If TYPE is NULL, determine symbol type from the die, otherwise
5572 used the passed type. */
5574 static struct symbol *
5575 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
5577 struct objfile *objfile = cu->objfile;
5578 struct symbol *sym = NULL;
5580 struct attribute *attr = NULL;
5581 struct attribute *attr2 = NULL;
5584 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5586 if (die->tag != DW_TAG_namespace)
5587 name = dwarf2_linkage_name (die, cu);
5589 name = TYPE_NAME (type);
5593 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5594 sizeof (struct symbol));
5595 OBJSTAT (objfile, n_syms++);
5596 memset (sym, 0, sizeof (struct symbol));
5598 /* Cache this symbol's name and the name's demangled form (if any). */
5599 SYMBOL_LANGUAGE (sym) = cu->language;
5600 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
5602 /* Default assumptions.
5603 Use the passed type or decode it from the die. */
5604 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5605 SYMBOL_CLASS (sym) = LOC_STATIC;
5607 SYMBOL_TYPE (sym) = type;
5609 SYMBOL_TYPE (sym) = die_type (die, cu);
5610 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
5613 SYMBOL_LINE (sym) = DW_UNSND (attr);
5618 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
5621 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
5623 SYMBOL_CLASS (sym) = LOC_LABEL;
5625 case DW_TAG_subprogram:
5626 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5628 SYMBOL_CLASS (sym) = LOC_BLOCK;
5629 attr2 = dwarf2_attr (die, DW_AT_external, cu);
5630 if (attr2 && (DW_UNSND (attr2) != 0))
5632 add_symbol_to_list (sym, &global_symbols);
5636 add_symbol_to_list (sym, cu->list_in_scope);
5639 case DW_TAG_variable:
5640 /* Compilation with minimal debug info may result in variables
5641 with missing type entries. Change the misleading `void' type
5642 to something sensible. */
5643 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
5644 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
5645 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
5646 "<variable, no debug info>",
5648 attr = dwarf2_attr (die, DW_AT_const_value, cu);
5651 dwarf2_const_value (attr, sym, cu);
5652 attr2 = dwarf2_attr (die, DW_AT_external, cu);
5653 if (attr2 && (DW_UNSND (attr2) != 0))
5654 add_symbol_to_list (sym, &global_symbols);
5656 add_symbol_to_list (sym, cu->list_in_scope);
5659 attr = dwarf2_attr (die, DW_AT_location, cu);
5662 var_decode_location (attr, sym, cu);
5663 attr2 = dwarf2_attr (die, DW_AT_external, cu);
5664 if (attr2 && (DW_UNSND (attr2) != 0))
5665 add_symbol_to_list (sym, &global_symbols);
5667 add_symbol_to_list (sym, cu->list_in_scope);
5671 /* We do not know the address of this symbol.
5672 If it is an external symbol and we have type information
5673 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5674 The address of the variable will then be determined from
5675 the minimal symbol table whenever the variable is
5677 attr2 = dwarf2_attr (die, DW_AT_external, cu);
5678 if (attr2 && (DW_UNSND (attr2) != 0)
5679 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
5681 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
5682 add_symbol_to_list (sym, &global_symbols);
5686 case DW_TAG_formal_parameter:
5687 attr = dwarf2_attr (die, DW_AT_location, cu);
5690 var_decode_location (attr, sym, cu);
5691 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5692 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
5693 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
5695 attr = dwarf2_attr (die, DW_AT_const_value, cu);
5698 dwarf2_const_value (attr, sym, cu);
5700 add_symbol_to_list (sym, cu->list_in_scope);
5702 case DW_TAG_unspecified_parameters:
5703 /* From varargs functions; gdb doesn't seem to have any
5704 interest in this information, so just ignore it for now.
5707 case DW_TAG_class_type:
5708 case DW_TAG_structure_type:
5709 case DW_TAG_union_type:
5710 case DW_TAG_enumeration_type:
5711 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5712 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5714 /* Make sure that the symbol includes appropriate enclosing
5715 classes/namespaces in its name. These are calculated in
5716 read_structure_type, and the correct name is saved in
5719 if (cu->language == language_cplus)
5721 struct type *type = SYMBOL_TYPE (sym);
5723 if (TYPE_TAG_NAME (type) != NULL)
5725 /* FIXME: carlton/2003-11-10: Should this use
5726 SYMBOL_SET_NAMES instead? (The same problem also
5727 arises a further down in the function.) */
5728 SYMBOL_LINKAGE_NAME (sym)
5729 = obsavestring (TYPE_TAG_NAME (type),
5730 strlen (TYPE_TAG_NAME (type)),
5731 &objfile->objfile_obstack);
5736 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
5737 really ever be static objects: otherwise, if you try
5738 to, say, break of a class's method and you're in a file
5739 which doesn't mention that class, it won't work unless
5740 the check for all static symbols in lookup_symbol_aux
5741 saves you. See the OtherFileClass tests in
5742 gdb.c++/namespace.exp. */
5744 struct pending **list_to_add;
5746 list_to_add = (cu->list_in_scope == &file_symbols
5747 && cu->language == language_cplus
5748 ? &global_symbols : cu->list_in_scope);
5750 add_symbol_to_list (sym, list_to_add);
5752 /* The semantics of C++ state that "struct foo { ... }" also
5753 defines a typedef for "foo". Synthesize a typedef symbol so
5754 that "ptype foo" works as expected. */
5755 if (cu->language == language_cplus)
5757 struct symbol *typedef_sym = (struct symbol *)
5758 obstack_alloc (&objfile->objfile_obstack,
5759 sizeof (struct symbol));
5760 *typedef_sym = *sym;
5761 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
5762 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
5763 TYPE_NAME (SYMBOL_TYPE (sym)) =
5764 obsavestring (SYMBOL_NATURAL_NAME (sym),
5765 strlen (SYMBOL_NATURAL_NAME (sym)),
5766 &objfile->objfile_obstack);
5767 add_symbol_to_list (typedef_sym, list_to_add);
5771 case DW_TAG_typedef:
5772 if (processing_has_namespace_info
5773 && processing_current_prefix[0] != '\0')
5775 SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
5776 processing_current_prefix,
5780 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5781 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5782 add_symbol_to_list (sym, cu->list_in_scope);
5784 case DW_TAG_base_type:
5785 case DW_TAG_subrange_type:
5786 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5787 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5788 add_symbol_to_list (sym, cu->list_in_scope);
5790 case DW_TAG_enumerator:
5791 if (processing_has_namespace_info
5792 && processing_current_prefix[0] != '\0')
5794 SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
5795 processing_current_prefix,
5799 attr = dwarf2_attr (die, DW_AT_const_value, cu);
5802 dwarf2_const_value (attr, sym, cu);
5805 /* NOTE: carlton/2003-11-10: See comment above in the
5806 DW_TAG_class_type, etc. block. */
5808 struct pending **list_to_add;
5810 list_to_add = (cu->list_in_scope == &file_symbols
5811 && cu->language == language_cplus
5812 ? &global_symbols : cu->list_in_scope);
5814 add_symbol_to_list (sym, list_to_add);
5817 case DW_TAG_namespace:
5818 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5819 add_symbol_to_list (sym, &global_symbols);
5822 /* Not a tag we recognize. Hopefully we aren't processing
5823 trash data, but since we must specifically ignore things
5824 we don't recognize, there is nothing else we should do at
5826 complaint (&symfile_complaints, "unsupported tag: '%s'",
5827 dwarf_tag_name (die->tag));
5834 /* Copy constant value from an attribute to a symbol. */
5837 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
5838 struct dwarf2_cu *cu)
5840 struct objfile *objfile = cu->objfile;
5841 struct comp_unit_head *cu_header = &cu->header;
5842 struct dwarf_block *blk;
5847 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
5848 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5849 cu_header->addr_size,
5850 TYPE_LENGTH (SYMBOL_TYPE
5852 SYMBOL_VALUE_BYTES (sym) = (char *)
5853 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
5854 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5855 it's body - store_unsigned_integer. */
5856 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
5858 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5860 case DW_FORM_block1:
5861 case DW_FORM_block2:
5862 case DW_FORM_block4:
5864 blk = DW_BLOCK (attr);
5865 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
5866 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5868 TYPE_LENGTH (SYMBOL_TYPE
5870 SYMBOL_VALUE_BYTES (sym) = (char *)
5871 obstack_alloc (&objfile->objfile_obstack, blk->size);
5872 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
5873 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5876 /* The DW_AT_const_value attributes are supposed to carry the
5877 symbol's value "represented as it would be on the target
5878 architecture." By the time we get here, it's already been
5879 converted to host endianness, so we just need to sign- or
5880 zero-extend it as appropriate. */
5882 dwarf2_const_value_data (attr, sym, 8);
5885 dwarf2_const_value_data (attr, sym, 16);
5888 dwarf2_const_value_data (attr, sym, 32);
5891 dwarf2_const_value_data (attr, sym, 64);
5895 SYMBOL_VALUE (sym) = DW_SND (attr);
5896 SYMBOL_CLASS (sym) = LOC_CONST;
5900 SYMBOL_VALUE (sym) = DW_UNSND (attr);
5901 SYMBOL_CLASS (sym) = LOC_CONST;
5905 complaint (&symfile_complaints,
5906 "unsupported const value attribute form: '%s'",
5907 dwarf_form_name (attr->form));
5908 SYMBOL_VALUE (sym) = 0;
5909 SYMBOL_CLASS (sym) = LOC_CONST;
5915 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5916 or zero-extend it as appropriate for the symbol's type. */
5918 dwarf2_const_value_data (struct attribute *attr,
5922 LONGEST l = DW_UNSND (attr);
5924 if (bits < sizeof (l) * 8)
5926 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
5927 l &= ((LONGEST) 1 << bits) - 1;
5929 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
5932 SYMBOL_VALUE (sym) = l;
5933 SYMBOL_CLASS (sym) = LOC_CONST;
5937 /* Return the type of the die in question using its DW_AT_type attribute. */
5939 static struct type *
5940 die_type (struct die_info *die, struct dwarf2_cu *cu)
5943 struct attribute *type_attr;
5944 struct die_info *type_die;
5947 type_attr = dwarf2_attr (die, DW_AT_type, cu);
5950 /* A missing DW_AT_type represents a void type. */
5951 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
5955 ref = dwarf2_get_ref_die_offset (type_attr, cu);
5956 type_die = follow_die_ref (ref);
5959 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5960 ref, cu->objfile->name);
5964 type = tag_type_to_type (type_die, cu);
5967 dump_die (type_die);
5968 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5974 /* Return the containing type of the die in question using its
5975 DW_AT_containing_type attribute. */
5977 static struct type *
5978 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
5980 struct type *type = NULL;
5981 struct attribute *type_attr;
5982 struct die_info *type_die = NULL;
5985 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
5988 ref = dwarf2_get_ref_die_offset (type_attr, cu);
5989 type_die = follow_die_ref (ref);
5992 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref,
5996 type = tag_type_to_type (type_die, cu);
6001 dump_die (type_die);
6002 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
6009 static struct type *
6010 type_at_offset (unsigned int offset, struct dwarf2_cu *cu)
6012 struct die_info *die;
6015 die = follow_die_ref (offset);
6018 error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
6021 type = tag_type_to_type (die, cu);
6026 static struct type *
6027 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
6035 read_type_die (die, cu);
6039 error ("Dwarf Error: Cannot find type of die [in module %s]",
6047 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
6049 char *prefix = determine_prefix (die, cu);
6050 const char *old_prefix = processing_current_prefix;
6051 struct cleanup *back_to = make_cleanup (xfree, prefix);
6052 processing_current_prefix = prefix;
6056 case DW_TAG_class_type:
6057 case DW_TAG_structure_type:
6058 case DW_TAG_union_type:
6059 read_structure_type (die, cu);
6061 case DW_TAG_enumeration_type:
6062 read_enumeration_type (die, cu);
6064 case DW_TAG_subprogram:
6065 case DW_TAG_subroutine_type:
6066 read_subroutine_type (die, cu);
6068 case DW_TAG_array_type:
6069 read_array_type (die, cu);
6071 case DW_TAG_pointer_type:
6072 read_tag_pointer_type (die, cu);
6074 case DW_TAG_ptr_to_member_type:
6075 read_tag_ptr_to_member_type (die, cu);
6077 case DW_TAG_reference_type:
6078 read_tag_reference_type (die, cu);
6080 case DW_TAG_const_type:
6081 read_tag_const_type (die, cu);
6083 case DW_TAG_volatile_type:
6084 read_tag_volatile_type (die, cu);
6086 case DW_TAG_string_type:
6087 read_tag_string_type (die, cu);
6089 case DW_TAG_typedef:
6090 read_typedef (die, cu);
6092 case DW_TAG_subrange_type:
6093 read_subrange_type (die, cu);
6095 case DW_TAG_base_type:
6096 read_base_type (die, cu);
6099 complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'",
6100 dwarf_tag_name (die->tag));
6104 processing_current_prefix = old_prefix;
6105 do_cleanups (back_to);
6108 /* Return the name of the namespace/class that DIE is defined within,
6109 or "" if we can't tell. The caller should xfree the result. */
6111 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6112 therein) for an example of how to use this function to deal with
6113 DW_AT_specification. */
6116 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
6118 struct die_info *parent;
6120 if (cu->language != language_cplus)
6123 parent = die->parent;
6127 return xstrdup ("");
6131 switch (parent->tag) {
6132 case DW_TAG_namespace:
6134 /* FIXME: carlton/2004-03-05: Should I follow extension dies
6135 before doing this check? */
6136 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6138 return xstrdup (TYPE_TAG_NAME (parent->type));
6143 char *parent_prefix = determine_prefix (parent, cu);
6144 char *retval = typename_concat (parent_prefix,
6145 namespace_name (parent, &dummy,
6147 xfree (parent_prefix);
6152 case DW_TAG_class_type:
6153 case DW_TAG_structure_type:
6155 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6157 return xstrdup (TYPE_TAG_NAME (parent->type));
6161 const char *old_prefix = processing_current_prefix;
6162 char *new_prefix = determine_prefix (parent, cu);
6165 processing_current_prefix = new_prefix;
6166 retval = determine_class_name (parent, cu);
6167 processing_current_prefix = old_prefix;
6174 return determine_prefix (parent, cu);
6179 /* Return a newly-allocated string formed by concatenating PREFIX,
6180 "::", and SUFFIX, except that if PREFIX is NULL or the empty
6181 string, just return a copy of SUFFIX. */
6184 typename_concat (const char *prefix, const char *suffix)
6186 if (prefix == NULL || prefix[0] == '\0')
6187 return xstrdup (suffix);
6190 char *retval = xmalloc (strlen (prefix) + 2 + strlen (suffix) + 1);
6192 strcpy (retval, prefix);
6193 strcat (retval, "::");
6194 strcat (retval, suffix);
6200 static struct type *
6201 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
6203 struct objfile *objfile = cu->objfile;
6205 /* FIXME - this should not produce a new (struct type *)
6206 every time. It should cache base types. */
6210 case DW_ATE_address:
6211 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
6213 case DW_ATE_boolean:
6214 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
6216 case DW_ATE_complex_float:
6219 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
6223 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
6229 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
6233 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
6240 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6243 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
6247 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6251 case DW_ATE_signed_char:
6252 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6254 case DW_ATE_unsigned:
6258 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6261 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
6265 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
6269 case DW_ATE_unsigned_char:
6270 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6273 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6280 copy_die (struct die_info *old_die)
6282 struct die_info *new_die;
6285 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
6286 memset (new_die, 0, sizeof (struct die_info));
6288 new_die->tag = old_die->tag;
6289 new_die->has_children = old_die->has_children;
6290 new_die->abbrev = old_die->abbrev;
6291 new_die->offset = old_die->offset;
6292 new_die->type = NULL;
6294 num_attrs = old_die->num_attrs;
6295 new_die->num_attrs = num_attrs;
6296 new_die->attrs = (struct attribute *)
6297 xmalloc (num_attrs * sizeof (struct attribute));
6299 for (i = 0; i < old_die->num_attrs; ++i)
6301 new_die->attrs[i].name = old_die->attrs[i].name;
6302 new_die->attrs[i].form = old_die->attrs[i].form;
6303 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
6306 new_die->next = NULL;
6311 /* Return sibling of die, NULL if no sibling. */
6313 static struct die_info *
6314 sibling_die (struct die_info *die)
6316 return die->sibling;
6319 /* Get linkage name of a die, return NULL if not found. */
6322 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
6324 struct attribute *attr;
6326 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
6327 if (attr && DW_STRING (attr))
6328 return DW_STRING (attr);
6329 attr = dwarf2_attr (die, DW_AT_name, cu);
6330 if (attr && DW_STRING (attr))
6331 return DW_STRING (attr);
6335 /* Get name of a die, return NULL if not found. */
6338 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
6340 struct attribute *attr;
6342 attr = dwarf2_attr (die, DW_AT_name, cu);
6343 if (attr && DW_STRING (attr))
6344 return DW_STRING (attr);
6348 /* Return the die that this die in an extension of, or NULL if there
6351 static struct die_info *
6352 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
6354 struct attribute *attr;
6355 struct die_info *extension_die;
6358 attr = dwarf2_attr (die, DW_AT_extension, cu);
6362 ref = dwarf2_get_ref_die_offset (attr, cu);
6363 extension_die = follow_die_ref (ref);
6366 error ("Dwarf Error: Cannot find referent at offset %d.", ref);
6369 return extension_die;
6372 /* Convert a DIE tag into its string name. */
6375 dwarf_tag_name (unsigned tag)
6379 case DW_TAG_padding:
6380 return "DW_TAG_padding";
6381 case DW_TAG_array_type:
6382 return "DW_TAG_array_type";
6383 case DW_TAG_class_type:
6384 return "DW_TAG_class_type";
6385 case DW_TAG_entry_point:
6386 return "DW_TAG_entry_point";
6387 case DW_TAG_enumeration_type:
6388 return "DW_TAG_enumeration_type";
6389 case DW_TAG_formal_parameter:
6390 return "DW_TAG_formal_parameter";
6391 case DW_TAG_imported_declaration:
6392 return "DW_TAG_imported_declaration";
6394 return "DW_TAG_label";
6395 case DW_TAG_lexical_block:
6396 return "DW_TAG_lexical_block";
6398 return "DW_TAG_member";
6399 case DW_TAG_pointer_type:
6400 return "DW_TAG_pointer_type";
6401 case DW_TAG_reference_type:
6402 return "DW_TAG_reference_type";
6403 case DW_TAG_compile_unit:
6404 return "DW_TAG_compile_unit";
6405 case DW_TAG_string_type:
6406 return "DW_TAG_string_type";
6407 case DW_TAG_structure_type:
6408 return "DW_TAG_structure_type";
6409 case DW_TAG_subroutine_type:
6410 return "DW_TAG_subroutine_type";
6411 case DW_TAG_typedef:
6412 return "DW_TAG_typedef";
6413 case DW_TAG_union_type:
6414 return "DW_TAG_union_type";
6415 case DW_TAG_unspecified_parameters:
6416 return "DW_TAG_unspecified_parameters";
6417 case DW_TAG_variant:
6418 return "DW_TAG_variant";
6419 case DW_TAG_common_block:
6420 return "DW_TAG_common_block";
6421 case DW_TAG_common_inclusion:
6422 return "DW_TAG_common_inclusion";
6423 case DW_TAG_inheritance:
6424 return "DW_TAG_inheritance";
6425 case DW_TAG_inlined_subroutine:
6426 return "DW_TAG_inlined_subroutine";
6428 return "DW_TAG_module";
6429 case DW_TAG_ptr_to_member_type:
6430 return "DW_TAG_ptr_to_member_type";
6431 case DW_TAG_set_type:
6432 return "DW_TAG_set_type";
6433 case DW_TAG_subrange_type:
6434 return "DW_TAG_subrange_type";
6435 case DW_TAG_with_stmt:
6436 return "DW_TAG_with_stmt";
6437 case DW_TAG_access_declaration:
6438 return "DW_TAG_access_declaration";
6439 case DW_TAG_base_type:
6440 return "DW_TAG_base_type";
6441 case DW_TAG_catch_block:
6442 return "DW_TAG_catch_block";
6443 case DW_TAG_const_type:
6444 return "DW_TAG_const_type";
6445 case DW_TAG_constant:
6446 return "DW_TAG_constant";
6447 case DW_TAG_enumerator:
6448 return "DW_TAG_enumerator";
6449 case DW_TAG_file_type:
6450 return "DW_TAG_file_type";
6452 return "DW_TAG_friend";
6453 case DW_TAG_namelist:
6454 return "DW_TAG_namelist";
6455 case DW_TAG_namelist_item:
6456 return "DW_TAG_namelist_item";
6457 case DW_TAG_packed_type:
6458 return "DW_TAG_packed_type";
6459 case DW_TAG_subprogram:
6460 return "DW_TAG_subprogram";
6461 case DW_TAG_template_type_param:
6462 return "DW_TAG_template_type_param";
6463 case DW_TAG_template_value_param:
6464 return "DW_TAG_template_value_param";
6465 case DW_TAG_thrown_type:
6466 return "DW_TAG_thrown_type";
6467 case DW_TAG_try_block:
6468 return "DW_TAG_try_block";
6469 case DW_TAG_variant_part:
6470 return "DW_TAG_variant_part";
6471 case DW_TAG_variable:
6472 return "DW_TAG_variable";
6473 case DW_TAG_volatile_type:
6474 return "DW_TAG_volatile_type";
6475 case DW_TAG_dwarf_procedure:
6476 return "DW_TAG_dwarf_procedure";
6477 case DW_TAG_restrict_type:
6478 return "DW_TAG_restrict_type";
6479 case DW_TAG_interface_type:
6480 return "DW_TAG_interface_type";
6481 case DW_TAG_namespace:
6482 return "DW_TAG_namespace";
6483 case DW_TAG_imported_module:
6484 return "DW_TAG_imported_module";
6485 case DW_TAG_unspecified_type:
6486 return "DW_TAG_unspecified_type";
6487 case DW_TAG_partial_unit:
6488 return "DW_TAG_partial_unit";
6489 case DW_TAG_imported_unit:
6490 return "DW_TAG_imported_unit";
6491 case DW_TAG_MIPS_loop:
6492 return "DW_TAG_MIPS_loop";
6493 case DW_TAG_format_label:
6494 return "DW_TAG_format_label";
6495 case DW_TAG_function_template:
6496 return "DW_TAG_function_template";
6497 case DW_TAG_class_template:
6498 return "DW_TAG_class_template";
6500 return "DW_TAG_<unknown>";
6504 /* Convert a DWARF attribute code into its string name. */
6507 dwarf_attr_name (unsigned attr)
6512 return "DW_AT_sibling";
6513 case DW_AT_location:
6514 return "DW_AT_location";
6516 return "DW_AT_name";
6517 case DW_AT_ordering:
6518 return "DW_AT_ordering";
6519 case DW_AT_subscr_data:
6520 return "DW_AT_subscr_data";
6521 case DW_AT_byte_size:
6522 return "DW_AT_byte_size";
6523 case DW_AT_bit_offset:
6524 return "DW_AT_bit_offset";
6525 case DW_AT_bit_size:
6526 return "DW_AT_bit_size";
6527 case DW_AT_element_list:
6528 return "DW_AT_element_list";
6529 case DW_AT_stmt_list:
6530 return "DW_AT_stmt_list";
6532 return "DW_AT_low_pc";
6534 return "DW_AT_high_pc";
6535 case DW_AT_language:
6536 return "DW_AT_language";
6538 return "DW_AT_member";
6540 return "DW_AT_discr";
6541 case DW_AT_discr_value:
6542 return "DW_AT_discr_value";
6543 case DW_AT_visibility:
6544 return "DW_AT_visibility";
6546 return "DW_AT_import";
6547 case DW_AT_string_length:
6548 return "DW_AT_string_length";
6549 case DW_AT_common_reference:
6550 return "DW_AT_common_reference";
6551 case DW_AT_comp_dir:
6552 return "DW_AT_comp_dir";
6553 case DW_AT_const_value:
6554 return "DW_AT_const_value";
6555 case DW_AT_containing_type:
6556 return "DW_AT_containing_type";
6557 case DW_AT_default_value:
6558 return "DW_AT_default_value";
6560 return "DW_AT_inline";
6561 case DW_AT_is_optional:
6562 return "DW_AT_is_optional";
6563 case DW_AT_lower_bound:
6564 return "DW_AT_lower_bound";
6565 case DW_AT_producer:
6566 return "DW_AT_producer";
6567 case DW_AT_prototyped:
6568 return "DW_AT_prototyped";
6569 case DW_AT_return_addr:
6570 return "DW_AT_return_addr";
6571 case DW_AT_start_scope:
6572 return "DW_AT_start_scope";
6573 case DW_AT_stride_size:
6574 return "DW_AT_stride_size";
6575 case DW_AT_upper_bound:
6576 return "DW_AT_upper_bound";
6577 case DW_AT_abstract_origin:
6578 return "DW_AT_abstract_origin";
6579 case DW_AT_accessibility:
6580 return "DW_AT_accessibility";
6581 case DW_AT_address_class:
6582 return "DW_AT_address_class";
6583 case DW_AT_artificial:
6584 return "DW_AT_artificial";
6585 case DW_AT_base_types:
6586 return "DW_AT_base_types";
6587 case DW_AT_calling_convention:
6588 return "DW_AT_calling_convention";
6590 return "DW_AT_count";
6591 case DW_AT_data_member_location:
6592 return "DW_AT_data_member_location";
6593 case DW_AT_decl_column:
6594 return "DW_AT_decl_column";
6595 case DW_AT_decl_file:
6596 return "DW_AT_decl_file";
6597 case DW_AT_decl_line:
6598 return "DW_AT_decl_line";
6599 case DW_AT_declaration:
6600 return "DW_AT_declaration";
6601 case DW_AT_discr_list:
6602 return "DW_AT_discr_list";
6603 case DW_AT_encoding:
6604 return "DW_AT_encoding";
6605 case DW_AT_external:
6606 return "DW_AT_external";
6607 case DW_AT_frame_base:
6608 return "DW_AT_frame_base";
6610 return "DW_AT_friend";
6611 case DW_AT_identifier_case:
6612 return "DW_AT_identifier_case";
6613 case DW_AT_macro_info:
6614 return "DW_AT_macro_info";
6615 case DW_AT_namelist_items:
6616 return "DW_AT_namelist_items";
6617 case DW_AT_priority:
6618 return "DW_AT_priority";
6620 return "DW_AT_segment";
6621 case DW_AT_specification:
6622 return "DW_AT_specification";
6623 case DW_AT_static_link:
6624 return "DW_AT_static_link";
6626 return "DW_AT_type";
6627 case DW_AT_use_location:
6628 return "DW_AT_use_location";
6629 case DW_AT_variable_parameter:
6630 return "DW_AT_variable_parameter";
6631 case DW_AT_virtuality:
6632 return "DW_AT_virtuality";
6633 case DW_AT_vtable_elem_location:
6634 return "DW_AT_vtable_elem_location";
6635 case DW_AT_allocated:
6636 return "DW_AT_allocated";
6637 case DW_AT_associated:
6638 return "DW_AT_associated";
6639 case DW_AT_data_location:
6640 return "DW_AT_data_location";
6642 return "DW_AT_stride";
6643 case DW_AT_entry_pc:
6644 return "DW_AT_entry_pc";
6645 case DW_AT_use_UTF8:
6646 return "DW_AT_use_UTF8";
6647 case DW_AT_extension:
6648 return "DW_AT_extension";
6650 return "DW_AT_ranges";
6651 case DW_AT_trampoline:
6652 return "DW_AT_trampoline";
6653 case DW_AT_call_column:
6654 return "DW_AT_call_column";
6655 case DW_AT_call_file:
6656 return "DW_AT_call_file";
6657 case DW_AT_call_line:
6658 return "DW_AT_call_line";
6660 case DW_AT_MIPS_fde:
6661 return "DW_AT_MIPS_fde";
6662 case DW_AT_MIPS_loop_begin:
6663 return "DW_AT_MIPS_loop_begin";
6664 case DW_AT_MIPS_tail_loop_begin:
6665 return "DW_AT_MIPS_tail_loop_begin";
6666 case DW_AT_MIPS_epilog_begin:
6667 return "DW_AT_MIPS_epilog_begin";
6668 case DW_AT_MIPS_loop_unroll_factor:
6669 return "DW_AT_MIPS_loop_unroll_factor";
6670 case DW_AT_MIPS_software_pipeline_depth:
6671 return "DW_AT_MIPS_software_pipeline_depth";
6673 case DW_AT_MIPS_linkage_name:
6674 return "DW_AT_MIPS_linkage_name";
6676 case DW_AT_sf_names:
6677 return "DW_AT_sf_names";
6678 case DW_AT_src_info:
6679 return "DW_AT_src_info";
6680 case DW_AT_mac_info:
6681 return "DW_AT_mac_info";
6682 case DW_AT_src_coords:
6683 return "DW_AT_src_coords";
6684 case DW_AT_body_begin:
6685 return "DW_AT_body_begin";
6686 case DW_AT_body_end:
6687 return "DW_AT_body_end";
6688 case DW_AT_GNU_vector:
6689 return "DW_AT_GNU_vector";
6691 return "DW_AT_<unknown>";
6695 /* Convert a DWARF value form code into its string name. */
6698 dwarf_form_name (unsigned form)
6703 return "DW_FORM_addr";
6704 case DW_FORM_block2:
6705 return "DW_FORM_block2";
6706 case DW_FORM_block4:
6707 return "DW_FORM_block4";
6709 return "DW_FORM_data2";
6711 return "DW_FORM_data4";
6713 return "DW_FORM_data8";
6714 case DW_FORM_string:
6715 return "DW_FORM_string";
6717 return "DW_FORM_block";
6718 case DW_FORM_block1:
6719 return "DW_FORM_block1";
6721 return "DW_FORM_data1";
6723 return "DW_FORM_flag";
6725 return "DW_FORM_sdata";
6727 return "DW_FORM_strp";
6729 return "DW_FORM_udata";
6730 case DW_FORM_ref_addr:
6731 return "DW_FORM_ref_addr";
6733 return "DW_FORM_ref1";
6735 return "DW_FORM_ref2";
6737 return "DW_FORM_ref4";
6739 return "DW_FORM_ref8";
6740 case DW_FORM_ref_udata:
6741 return "DW_FORM_ref_udata";
6742 case DW_FORM_indirect:
6743 return "DW_FORM_indirect";
6745 return "DW_FORM_<unknown>";
6749 /* Convert a DWARF stack opcode into its string name. */
6752 dwarf_stack_op_name (unsigned op)
6757 return "DW_OP_addr";
6759 return "DW_OP_deref";
6761 return "DW_OP_const1u";
6763 return "DW_OP_const1s";
6765 return "DW_OP_const2u";
6767 return "DW_OP_const2s";
6769 return "DW_OP_const4u";
6771 return "DW_OP_const4s";
6773 return "DW_OP_const8u";
6775 return "DW_OP_const8s";
6777 return "DW_OP_constu";
6779 return "DW_OP_consts";
6783 return "DW_OP_drop";
6785 return "DW_OP_over";
6787 return "DW_OP_pick";
6789 return "DW_OP_swap";
6793 return "DW_OP_xderef";
6801 return "DW_OP_minus";
6813 return "DW_OP_plus";
6814 case DW_OP_plus_uconst:
6815 return "DW_OP_plus_uconst";
6821 return "DW_OP_shra";
6839 return "DW_OP_skip";
6841 return "DW_OP_lit0";
6843 return "DW_OP_lit1";
6845 return "DW_OP_lit2";
6847 return "DW_OP_lit3";
6849 return "DW_OP_lit4";
6851 return "DW_OP_lit5";
6853 return "DW_OP_lit6";
6855 return "DW_OP_lit7";
6857 return "DW_OP_lit8";
6859 return "DW_OP_lit9";
6861 return "DW_OP_lit10";
6863 return "DW_OP_lit11";
6865 return "DW_OP_lit12";
6867 return "DW_OP_lit13";
6869 return "DW_OP_lit14";
6871 return "DW_OP_lit15";
6873 return "DW_OP_lit16";
6875 return "DW_OP_lit17";
6877 return "DW_OP_lit18";
6879 return "DW_OP_lit19";
6881 return "DW_OP_lit20";
6883 return "DW_OP_lit21";
6885 return "DW_OP_lit22";
6887 return "DW_OP_lit23";
6889 return "DW_OP_lit24";
6891 return "DW_OP_lit25";
6893 return "DW_OP_lit26";
6895 return "DW_OP_lit27";
6897 return "DW_OP_lit28";
6899 return "DW_OP_lit29";
6901 return "DW_OP_lit30";
6903 return "DW_OP_lit31";
6905 return "DW_OP_reg0";
6907 return "DW_OP_reg1";
6909 return "DW_OP_reg2";
6911 return "DW_OP_reg3";
6913 return "DW_OP_reg4";
6915 return "DW_OP_reg5";
6917 return "DW_OP_reg6";
6919 return "DW_OP_reg7";
6921 return "DW_OP_reg8";
6923 return "DW_OP_reg9";
6925 return "DW_OP_reg10";
6927 return "DW_OP_reg11";
6929 return "DW_OP_reg12";
6931 return "DW_OP_reg13";
6933 return "DW_OP_reg14";
6935 return "DW_OP_reg15";
6937 return "DW_OP_reg16";
6939 return "DW_OP_reg17";
6941 return "DW_OP_reg18";
6943 return "DW_OP_reg19";
6945 return "DW_OP_reg20";
6947 return "DW_OP_reg21";
6949 return "DW_OP_reg22";
6951 return "DW_OP_reg23";
6953 return "DW_OP_reg24";
6955 return "DW_OP_reg25";
6957 return "DW_OP_reg26";
6959 return "DW_OP_reg27";
6961 return "DW_OP_reg28";
6963 return "DW_OP_reg29";
6965 return "DW_OP_reg30";
6967 return "DW_OP_reg31";
6969 return "DW_OP_breg0";
6971 return "DW_OP_breg1";
6973 return "DW_OP_breg2";
6975 return "DW_OP_breg3";
6977 return "DW_OP_breg4";
6979 return "DW_OP_breg5";
6981 return "DW_OP_breg6";
6983 return "DW_OP_breg7";
6985 return "DW_OP_breg8";
6987 return "DW_OP_breg9";
6989 return "DW_OP_breg10";
6991 return "DW_OP_breg11";
6993 return "DW_OP_breg12";
6995 return "DW_OP_breg13";
6997 return "DW_OP_breg14";
6999 return "DW_OP_breg15";
7001 return "DW_OP_breg16";
7003 return "DW_OP_breg17";
7005 return "DW_OP_breg18";
7007 return "DW_OP_breg19";
7009 return "DW_OP_breg20";
7011 return "DW_OP_breg21";
7013 return "DW_OP_breg22";
7015 return "DW_OP_breg23";
7017 return "DW_OP_breg24";
7019 return "DW_OP_breg25";
7021 return "DW_OP_breg26";
7023 return "DW_OP_breg27";
7025 return "DW_OP_breg28";
7027 return "DW_OP_breg29";
7029 return "DW_OP_breg30";
7031 return "DW_OP_breg31";
7033 return "DW_OP_regx";
7035 return "DW_OP_fbreg";
7037 return "DW_OP_bregx";
7039 return "DW_OP_piece";
7040 case DW_OP_deref_size:
7041 return "DW_OP_deref_size";
7042 case DW_OP_xderef_size:
7043 return "DW_OP_xderef_size";
7046 /* DWARF 3 extensions. */
7047 case DW_OP_push_object_address:
7048 return "DW_OP_push_object_address";
7050 return "DW_OP_call2";
7052 return "DW_OP_call4";
7053 case DW_OP_call_ref:
7054 return "DW_OP_call_ref";
7055 /* GNU extensions. */
7056 case DW_OP_GNU_push_tls_address:
7057 return "DW_OP_GNU_push_tls_address";
7059 return "OP_<unknown>";
7064 dwarf_bool_name (unsigned mybool)
7072 /* Convert a DWARF type code into its string name. */
7075 dwarf_type_encoding_name (unsigned enc)
7079 case DW_ATE_address:
7080 return "DW_ATE_address";
7081 case DW_ATE_boolean:
7082 return "DW_ATE_boolean";
7083 case DW_ATE_complex_float:
7084 return "DW_ATE_complex_float";
7086 return "DW_ATE_float";
7088 return "DW_ATE_signed";
7089 case DW_ATE_signed_char:
7090 return "DW_ATE_signed_char";
7091 case DW_ATE_unsigned:
7092 return "DW_ATE_unsigned";
7093 case DW_ATE_unsigned_char:
7094 return "DW_ATE_unsigned_char";
7095 case DW_ATE_imaginary_float:
7096 return "DW_ATE_imaginary_float";
7098 return "DW_ATE_<unknown>";
7102 /* Convert a DWARF call frame info operation to its string name. */
7106 dwarf_cfi_name (unsigned cfi_opc)
7110 case DW_CFA_advance_loc:
7111 return "DW_CFA_advance_loc";
7113 return "DW_CFA_offset";
7114 case DW_CFA_restore:
7115 return "DW_CFA_restore";
7117 return "DW_CFA_nop";
7118 case DW_CFA_set_loc:
7119 return "DW_CFA_set_loc";
7120 case DW_CFA_advance_loc1:
7121 return "DW_CFA_advance_loc1";
7122 case DW_CFA_advance_loc2:
7123 return "DW_CFA_advance_loc2";
7124 case DW_CFA_advance_loc4:
7125 return "DW_CFA_advance_loc4";
7126 case DW_CFA_offset_extended:
7127 return "DW_CFA_offset_extended";
7128 case DW_CFA_restore_extended:
7129 return "DW_CFA_restore_extended";
7130 case DW_CFA_undefined:
7131 return "DW_CFA_undefined";
7132 case DW_CFA_same_value:
7133 return "DW_CFA_same_value";
7134 case DW_CFA_register:
7135 return "DW_CFA_register";
7136 case DW_CFA_remember_state:
7137 return "DW_CFA_remember_state";
7138 case DW_CFA_restore_state:
7139 return "DW_CFA_restore_state";
7140 case DW_CFA_def_cfa:
7141 return "DW_CFA_def_cfa";
7142 case DW_CFA_def_cfa_register:
7143 return "DW_CFA_def_cfa_register";
7144 case DW_CFA_def_cfa_offset:
7145 return "DW_CFA_def_cfa_offset";
7148 case DW_CFA_def_cfa_expression:
7149 return "DW_CFA_def_cfa_expression";
7150 case DW_CFA_expression:
7151 return "DW_CFA_expression";
7152 case DW_CFA_offset_extended_sf:
7153 return "DW_CFA_offset_extended_sf";
7154 case DW_CFA_def_cfa_sf:
7155 return "DW_CFA_def_cfa_sf";
7156 case DW_CFA_def_cfa_offset_sf:
7157 return "DW_CFA_def_cfa_offset_sf";
7159 /* SGI/MIPS specific */
7160 case DW_CFA_MIPS_advance_loc8:
7161 return "DW_CFA_MIPS_advance_loc8";
7163 /* GNU extensions */
7164 case DW_CFA_GNU_window_save:
7165 return "DW_CFA_GNU_window_save";
7166 case DW_CFA_GNU_args_size:
7167 return "DW_CFA_GNU_args_size";
7168 case DW_CFA_GNU_negative_offset_extended:
7169 return "DW_CFA_GNU_negative_offset_extended";
7172 return "DW_CFA_<unknown>";
7178 dump_die (struct die_info *die)
7182 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
7183 dwarf_tag_name (die->tag), die->abbrev, die->offset);
7184 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
7185 dwarf_bool_name (die->child != NULL));
7187 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
7188 for (i = 0; i < die->num_attrs; ++i)
7190 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
7191 dwarf_attr_name (die->attrs[i].name),
7192 dwarf_form_name (die->attrs[i].form));
7193 switch (die->attrs[i].form)
7195 case DW_FORM_ref_addr:
7197 fprintf_unfiltered (gdb_stderr, "address: ");
7198 print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
7200 case DW_FORM_block2:
7201 case DW_FORM_block4:
7203 case DW_FORM_block1:
7204 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
7215 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
7217 case DW_FORM_string:
7219 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
7220 DW_STRING (&die->attrs[i])
7221 ? DW_STRING (&die->attrs[i]) : "");
7224 if (DW_UNSND (&die->attrs[i]))
7225 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
7227 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
7229 case DW_FORM_indirect:
7230 /* the reader will have reduced the indirect form to
7231 the "base form" so this form should not occur */
7232 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
7235 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
7236 die->attrs[i].form);
7238 fprintf_unfiltered (gdb_stderr, "\n");
7243 dump_die_list (struct die_info *die)
7248 if (die->child != NULL)
7249 dump_die_list (die->child);
7250 if (die->sibling != NULL)
7251 dump_die_list (die->sibling);
7256 store_in_ref_table (unsigned int offset, struct die_info *die)
7259 struct die_info *old;
7261 h = (offset % REF_HASH_SIZE);
7262 old = die_ref_table[h];
7263 die->next_ref = old;
7264 die_ref_table[h] = die;
7269 dwarf2_empty_hash_tables (void)
7271 memset (die_ref_table, 0, sizeof (die_ref_table));
7275 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
7277 unsigned int result = 0;
7281 case DW_FORM_ref_addr:
7282 result = DW_ADDR (attr);
7288 case DW_FORM_ref_udata:
7289 result = cu->header.offset + DW_UNSND (attr);
7292 complaint (&symfile_complaints,
7293 "unsupported die ref attribute form: '%s'",
7294 dwarf_form_name (attr->form));
7299 /* Return the constant value held by the given attribute. Return -1
7300 if the value held by the attribute is not constant. */
7303 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
7305 if (attr->form == DW_FORM_sdata)
7306 return DW_SND (attr);
7307 else if (attr->form == DW_FORM_udata
7308 || attr->form == DW_FORM_data1
7309 || attr->form == DW_FORM_data2
7310 || attr->form == DW_FORM_data4
7311 || attr->form == DW_FORM_data8)
7312 return DW_UNSND (attr);
7315 complaint (&symfile_complaints, "Attribute value is not a constant (%s)",
7316 dwarf_form_name (attr->form));
7317 return default_value;
7321 static struct die_info *
7322 follow_die_ref (unsigned int offset)
7324 struct die_info *die;
7327 h = (offset % REF_HASH_SIZE);
7328 die = die_ref_table[h];
7331 if (die->offset == offset)
7335 die = die->next_ref;
7340 static struct type *
7341 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
7342 struct dwarf2_cu *cu)
7344 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
7346 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7347 typeid, objfile->name);
7350 /* Look for this particular type in the fundamental type vector. If
7351 one is not found, create and install one appropriate for the
7352 current language and the current target machine. */
7354 if (cu->ftypes[typeid] == NULL)
7356 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
7359 return (cu->ftypes[typeid]);
7362 /* Decode simple location descriptions.
7363 Given a pointer to a dwarf block that defines a location, compute
7364 the location and return the value.
7366 NOTE drow/2003-11-18: This function is called in two situations
7367 now: for the address of static or global variables (partial symbols
7368 only) and for offsets into structures which are expected to be
7369 (more or less) constant. The partial symbol case should go away,
7370 and only the constant case should remain. That will let this
7371 function complain more accurately. A few special modes are allowed
7372 without complaint for global variables (for instance, global
7373 register values and thread-local values).
7375 A location description containing no operations indicates that the
7376 object is optimized out. The return value is 0 for that case.
7377 FIXME drow/2003-11-16: No callers check for this case any more; soon all
7378 callers will only want a very basic result and this can become a
7381 When the result is a register number, the global isreg flag is set,
7382 otherwise it is cleared.
7384 Note that stack[0] is unused except as a default error return.
7385 Note that stack overflow is not yet handled. */
7388 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
7390 struct objfile *objfile = cu->objfile;
7391 struct comp_unit_head *cu_header = &cu->header;
7393 int size = blk->size;
7394 char *data = blk->data;
7395 CORE_ADDR stack[64];
7397 unsigned int bytes_read, unsnd;
7442 stack[++stacki] = op - DW_OP_lit0;
7478 stack[++stacki] = op - DW_OP_reg0;
7480 dwarf2_complex_location_expr_complaint ();
7485 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
7487 stack[++stacki] = unsnd;
7489 dwarf2_complex_location_expr_complaint ();
7493 stack[++stacki] = read_address (objfile->obfd, &data[i],
7499 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
7504 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
7509 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
7514 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
7519 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
7524 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
7529 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
7535 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
7540 stack[stacki + 1] = stack[stacki];
7545 stack[stacki - 1] += stack[stacki];
7549 case DW_OP_plus_uconst:
7550 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
7555 stack[stacki - 1] -= stack[stacki];
7560 /* If we're not the last op, then we definitely can't encode
7561 this using GDB's address_class enum. This is valid for partial
7562 global symbols, although the variable's address will be bogus
7565 dwarf2_complex_location_expr_complaint ();
7568 case DW_OP_GNU_push_tls_address:
7569 /* The top of the stack has the offset from the beginning
7570 of the thread control block at which the variable is located. */
7571 /* Nothing should follow this operator, so the top of stack would
7573 /* This is valid for partial global symbols, but the variable's
7574 address will be bogus in the psymtab. */
7576 dwarf2_complex_location_expr_complaint ();
7580 complaint (&symfile_complaints, "unsupported stack op: '%s'",
7581 dwarf_stack_op_name (op));
7582 return (stack[stacki]);
7585 return (stack[stacki]);
7588 /* memory allocation interface */
7591 dwarf2_free_tmp_obstack (void *ignore)
7593 obstack_free (&dwarf2_tmp_obstack, NULL);
7596 static struct dwarf_block *
7597 dwarf_alloc_block (void)
7599 struct dwarf_block *blk;
7601 blk = (struct dwarf_block *)
7602 obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
7606 static struct abbrev_info *
7607 dwarf_alloc_abbrev (void)
7609 struct abbrev_info *abbrev;
7611 abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
7612 memset (abbrev, 0, sizeof (struct abbrev_info));
7616 static struct die_info *
7617 dwarf_alloc_die (void)
7619 struct die_info *die;
7621 die = (struct die_info *) xmalloc (sizeof (struct die_info));
7622 memset (die, 0, sizeof (struct die_info));
7627 /* Macro support. */
7630 /* Return the full name of file number I in *LH's file name table.
7631 Use COMP_DIR as the name of the current directory of the
7632 compilation. The result is allocated using xmalloc; the caller is
7633 responsible for freeing it. */
7635 file_full_name (int file, struct line_header *lh, const char *comp_dir)
7637 struct file_entry *fe = &lh->file_names[file - 1];
7639 if (IS_ABSOLUTE_PATH (fe->name))
7640 return xstrdup (fe->name);
7648 dir = lh->include_dirs[fe->dir_index - 1];
7654 dir_len = strlen (dir);
7655 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
7656 strcpy (full_name, dir);
7657 full_name[dir_len] = '/';
7658 strcpy (full_name + dir_len + 1, fe->name);
7662 return xstrdup (fe->name);
7667 static struct macro_source_file *
7668 macro_start_file (int file, int line,
7669 struct macro_source_file *current_file,
7670 const char *comp_dir,
7671 struct line_header *lh, struct objfile *objfile)
7673 /* The full name of this source file. */
7674 char *full_name = file_full_name (file, lh, comp_dir);
7676 /* We don't create a macro table for this compilation unit
7677 at all until we actually get a filename. */
7678 if (! pending_macros)
7679 pending_macros = new_macro_table (&objfile->objfile_obstack,
7680 objfile->macro_cache);
7683 /* If we have no current file, then this must be the start_file
7684 directive for the compilation unit's main source file. */
7685 current_file = macro_set_main (pending_macros, full_name);
7687 current_file = macro_include (current_file, line, full_name);
7691 return current_file;
7695 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7696 followed by a null byte. */
7698 copy_string (const char *buf, int len)
7700 char *s = xmalloc (len + 1);
7701 memcpy (s, buf, len);
7709 consume_improper_spaces (const char *p, const char *body)
7713 complaint (&symfile_complaints,
7714 "macro definition contains spaces in formal argument list:\n`%s'",
7726 parse_macro_definition (struct macro_source_file *file, int line,
7731 /* The body string takes one of two forms. For object-like macro
7732 definitions, it should be:
7734 <macro name> " " <definition>
7736 For function-like macro definitions, it should be:
7738 <macro name> "() " <definition>
7740 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7742 Spaces may appear only where explicitly indicated, and in the
7745 The Dwarf 2 spec says that an object-like macro's name is always
7746 followed by a space, but versions of GCC around March 2002 omit
7747 the space when the macro's definition is the empty string.
7749 The Dwarf 2 spec says that there should be no spaces between the
7750 formal arguments in a function-like macro's formal argument list,
7751 but versions of GCC around March 2002 include spaces after the
7755 /* Find the extent of the macro name. The macro name is terminated
7756 by either a space or null character (for an object-like macro) or
7757 an opening paren (for a function-like macro). */
7758 for (p = body; *p; p++)
7759 if (*p == ' ' || *p == '(')
7762 if (*p == ' ' || *p == '\0')
7764 /* It's an object-like macro. */
7765 int name_len = p - body;
7766 char *name = copy_string (body, name_len);
7767 const char *replacement;
7770 replacement = body + name_len + 1;
7773 dwarf2_macro_malformed_definition_complaint (body);
7774 replacement = body + name_len;
7777 macro_define_object (file, line, name, replacement);
7783 /* It's a function-like macro. */
7784 char *name = copy_string (body, p - body);
7787 char **argv = xmalloc (argv_size * sizeof (*argv));
7791 p = consume_improper_spaces (p, body);
7793 /* Parse the formal argument list. */
7794 while (*p && *p != ')')
7796 /* Find the extent of the current argument name. */
7797 const char *arg_start = p;
7799 while (*p && *p != ',' && *p != ')' && *p != ' ')
7802 if (! *p || p == arg_start)
7803 dwarf2_macro_malformed_definition_complaint (body);
7806 /* Make sure argv has room for the new argument. */
7807 if (argc >= argv_size)
7810 argv = xrealloc (argv, argv_size * sizeof (*argv));
7813 argv[argc++] = copy_string (arg_start, p - arg_start);
7816 p = consume_improper_spaces (p, body);
7818 /* Consume the comma, if present. */
7823 p = consume_improper_spaces (p, body);
7832 /* Perfectly formed definition, no complaints. */
7833 macro_define_function (file, line, name,
7834 argc, (const char **) argv,
7836 else if (*p == '\0')
7838 /* Complain, but do define it. */
7839 dwarf2_macro_malformed_definition_complaint (body);
7840 macro_define_function (file, line, name,
7841 argc, (const char **) argv,
7845 /* Just complain. */
7846 dwarf2_macro_malformed_definition_complaint (body);
7849 /* Just complain. */
7850 dwarf2_macro_malformed_definition_complaint (body);
7856 for (i = 0; i < argc; i++)
7862 dwarf2_macro_malformed_definition_complaint (body);
7867 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
7868 char *comp_dir, bfd *abfd,
7869 struct dwarf2_cu *cu)
7871 char *mac_ptr, *mac_end;
7872 struct macro_source_file *current_file = 0;
7874 if (dwarf_macinfo_buffer == NULL)
7876 complaint (&symfile_complaints, "missing .debug_macinfo section");
7880 mac_ptr = dwarf_macinfo_buffer + offset;
7881 mac_end = dwarf_macinfo_buffer + dwarf_macinfo_size;
7885 enum dwarf_macinfo_record_type macinfo_type;
7887 /* Do we at least have room for a macinfo type byte? */
7888 if (mac_ptr >= mac_end)
7890 dwarf2_macros_too_long_complaint ();
7894 macinfo_type = read_1_byte (abfd, mac_ptr);
7897 switch (macinfo_type)
7899 /* A zero macinfo type indicates the end of the macro
7904 case DW_MACINFO_define:
7905 case DW_MACINFO_undef:
7911 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7912 mac_ptr += bytes_read;
7913 body = read_string (abfd, mac_ptr, &bytes_read);
7914 mac_ptr += bytes_read;
7917 complaint (&symfile_complaints,
7918 "debug info gives macro %s outside of any file: %s",
7920 DW_MACINFO_define ? "definition" : macinfo_type ==
7921 DW_MACINFO_undef ? "undefinition" :
7922 "something-or-other", body);
7925 if (macinfo_type == DW_MACINFO_define)
7926 parse_macro_definition (current_file, line, body);
7927 else if (macinfo_type == DW_MACINFO_undef)
7928 macro_undef (current_file, line, body);
7933 case DW_MACINFO_start_file:
7938 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7939 mac_ptr += bytes_read;
7940 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7941 mac_ptr += bytes_read;
7943 current_file = macro_start_file (file, line,
7944 current_file, comp_dir,
7949 case DW_MACINFO_end_file:
7951 complaint (&symfile_complaints,
7952 "macro debug info has an unmatched `close_file' directive");
7955 current_file = current_file->included_by;
7958 enum dwarf_macinfo_record_type next_type;
7960 /* GCC circa March 2002 doesn't produce the zero
7961 type byte marking the end of the compilation
7962 unit. Complain if it's not there, but exit no
7965 /* Do we at least have room for a macinfo type byte? */
7966 if (mac_ptr >= mac_end)
7968 dwarf2_macros_too_long_complaint ();
7972 /* We don't increment mac_ptr here, so this is just
7974 next_type = read_1_byte (abfd, mac_ptr);
7976 complaint (&symfile_complaints,
7977 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7984 case DW_MACINFO_vendor_ext:
7990 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7991 mac_ptr += bytes_read;
7992 string = read_string (abfd, mac_ptr, &bytes_read);
7993 mac_ptr += bytes_read;
7995 /* We don't recognize any vendor extensions. */
8002 /* Check if the attribute's form is a DW_FORM_block*
8003 if so return true else false. */
8005 attr_form_is_block (struct attribute *attr)
8007 return (attr == NULL ? 0 :
8008 attr->form == DW_FORM_block1
8009 || attr->form == DW_FORM_block2
8010 || attr->form == DW_FORM_block4
8011 || attr->form == DW_FORM_block);
8015 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
8016 struct dwarf2_cu *cu)
8018 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
8020 struct dwarf2_loclist_baton *baton;
8022 baton = obstack_alloc (&cu->objfile->objfile_obstack,
8023 sizeof (struct dwarf2_loclist_baton));
8024 baton->objfile = cu->objfile;
8026 /* We don't know how long the location list is, but make sure we
8027 don't run off the edge of the section. */
8028 baton->size = dwarf_loc_size - DW_UNSND (attr);
8029 baton->data = dwarf_loc_buffer + DW_UNSND (attr);
8030 baton->base_address = cu->header.base_address;
8031 if (cu->header.base_known == 0)
8032 complaint (&symfile_complaints,
8033 "Location list used without specifying the CU base address.");
8035 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
8036 SYMBOL_LOCATION_BATON (sym) = baton;
8040 struct dwarf2_locexpr_baton *baton;
8042 baton = obstack_alloc (&cu->objfile->objfile_obstack,
8043 sizeof (struct dwarf2_locexpr_baton));
8044 baton->objfile = cu->objfile;
8046 if (attr_form_is_block (attr))
8048 /* Note that we're just copying the block's data pointer
8049 here, not the actual data. We're still pointing into the
8050 dwarf_info_buffer for SYM's objfile; right now we never
8051 release that buffer, but when we do clean up properly
8052 this may need to change. */
8053 baton->size = DW_BLOCK (attr)->size;
8054 baton->data = DW_BLOCK (attr)->data;
8058 dwarf2_invalid_attrib_class_complaint ("location description",
8059 SYMBOL_NATURAL_NAME (sym));
8064 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
8065 SYMBOL_LOCATION_BATON (sym) = baton;