1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 support in dwarfread.c
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length; /* length of the .debug_info
83 unsigned short version; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
86 unsigned char addr_size; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length; /* length of the .debug_pubnames
99 unsigned char version; /* version number -- 2 for DWARF
101 unsigned int info_offset; /* offset into .debug_info section */
102 unsigned int info_size; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length; /* byte len of the .debug_aranges
115 unsigned short version; /* version number -- 2 for DWARF
117 unsigned int info_offset; /* offset into .debug_info section */
118 unsigned char addr_size; /* byte size of an address */
119 unsigned char seg_size; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length; /* byte length of the statement
131 unsigned short version; /* version number -- 2 for DWARF
133 unsigned int prologue_length; /* # bytes between prologue &
135 unsigned char minimum_instruction_length; /* byte size of
137 unsigned char default_is_stmt; /* initial value of is_stmt
140 unsigned char line_range;
141 unsigned char opcode_base; /* number assigned to first special
143 unsigned char *standard_opcode_lengths;
147 static const struct objfile_data *dwarf2_objfile_data_key;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size;
153 unsigned int abbrev_size;
154 unsigned int line_size;
155 unsigned int pubnames_size;
156 unsigned int aranges_size;
157 unsigned int loc_size;
158 unsigned int macinfo_size;
159 unsigned int str_size;
160 unsigned int ranges_size;
161 unsigned int frame_size;
162 unsigned int eh_frame_size;
164 /* Loaded data from the sections. */
169 char *macinfo_buffer;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data **all_comp_units;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data *read_in_chain;
185 static struct dwarf2_per_objfile *dwarf2_per_objfile;
187 static asection *dwarf_info_section;
188 static asection *dwarf_abbrev_section;
189 static asection *dwarf_line_section;
190 static asection *dwarf_pubnames_section;
191 static asection *dwarf_aranges_section;
192 static asection *dwarf_loc_section;
193 static asection *dwarf_macinfo_section;
194 static asection *dwarf_str_section;
195 static asection *dwarf_ranges_section;
196 asection *dwarf_frame_section;
197 asection *dwarf_eh_frame_section;
199 /* names of the debugging sections */
201 #define INFO_SECTION ".debug_info"
202 #define ABBREV_SECTION ".debug_abbrev"
203 #define LINE_SECTION ".debug_line"
204 #define PUBNAMES_SECTION ".debug_pubnames"
205 #define ARANGES_SECTION ".debug_aranges"
206 #define LOC_SECTION ".debug_loc"
207 #define MACINFO_SECTION ".debug_macinfo"
208 #define STR_SECTION ".debug_str"
209 #define RANGES_SECTION ".debug_ranges"
210 #define FRAME_SECTION ".debug_frame"
211 #define EH_FRAME_SECTION ".eh_frame"
213 /* local data types */
215 /* We hold several abbreviation tables in memory at the same time. */
216 #ifndef ABBREV_HASH_SIZE
217 #define ABBREV_HASH_SIZE 121
220 /* The data in a compilation unit header, after target2host
221 translation, looks like this. */
222 struct comp_unit_head
224 unsigned long length;
226 unsigned int abbrev_offset;
227 unsigned char addr_size;
228 unsigned char signed_addr_p;
230 /* Size of file offsets; either 4 or 8. */
231 unsigned int offset_size;
233 /* Size of the length field; either 4 or 12. */
234 unsigned int initial_length_size;
236 /* Offset to the first byte of this compilation unit header in the
237 .debug_info section, for resolving relative reference dies. */
240 /* Pointer to this compilation unit header in the .debug_info
244 /* Pointer to the first die of this compilation unit. This will be
245 the first byte following the compilation unit header. */
248 /* Pointer to the next compilation unit header in the program. */
249 struct comp_unit_head *next;
251 /* Base address of this compilation unit. */
252 CORE_ADDR base_address;
254 /* Non-zero if base_address has been set. */
258 /* Fixed size for the DIE hash table. */
259 #ifndef REF_HASH_SIZE
260 #define REF_HASH_SIZE 1021
263 /* Internal state when decoding a particular compilation unit. */
266 /* The objfile containing this compilation unit. */
267 struct objfile *objfile;
269 /* The header of the compilation unit.
271 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
272 should logically be moved to the dwarf2_cu structure. */
273 struct comp_unit_head header;
275 struct function_range *first_fn, *last_fn, *cached_fn;
277 /* The language we are debugging. */
278 enum language language;
279 const struct language_defn *language_defn;
281 const char *producer;
283 /* The generic symbol table building routines have separate lists for
284 file scope symbols and all all other scopes (local scopes). So
285 we need to select the right one to pass to add_symbol_to_list().
286 We do it by keeping a pointer to the correct list in list_in_scope.
288 FIXME: The original dwarf code just treated the file scope as the
289 first local scope, and all other local scopes as nested local
290 scopes, and worked fine. Check to see if we really need to
291 distinguish these in buildsym.c. */
292 struct pending **list_in_scope;
294 /* Maintain an array of referenced fundamental types for the current
295 compilation unit being read. For DWARF version 1, we have to construct
296 the fundamental types on the fly, since no information about the
297 fundamental types is supplied. Each such fundamental type is created by
298 calling a language dependent routine to create the type, and then a
299 pointer to that type is then placed in the array at the index specified
300 by it's FT_<TYPENAME> value. The array has a fixed size set by the
301 FT_NUM_MEMBERS compile time constant, which is the number of predefined
302 fundamental types gdb knows how to construct. */
303 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
305 /* DWARF abbreviation table associated with this compilation unit. */
306 struct abbrev_info **dwarf2_abbrevs;
308 /* Storage for the abbrev table. */
309 struct obstack abbrev_obstack;
311 /* Hash table holding all the loaded partial DIEs. */
314 /* Storage for things with the same lifetime as this read-in compilation
315 unit, including partial DIEs. */
316 struct obstack comp_unit_obstack;
318 /* When multiple dwarf2_cu structures are living in memory, this field
319 chains them all together, so that they can be released efficiently.
320 We will probably also want a generation counter so that most-recently-used
321 compilation units are cached... */
322 struct dwarf2_per_cu_data *read_in_chain;
324 /* Backchain to our per_cu entry if the tree has been built. */
325 struct dwarf2_per_cu_data *per_cu;
327 /* How many compilation units ago was this CU last referenced? */
330 /* A hash table of die offsets for following references. */
331 struct die_info *die_ref_table[REF_HASH_SIZE];
333 /* Full DIEs if read in. */
334 struct die_info *dies;
336 /* A set of pointers to dwarf2_per_cu_data objects for compilation
337 units referenced by this one. Only set during full symbol processing;
338 partial symbol tables do not have dependencies. */
341 /* Mark used when releasing cached dies. */
342 unsigned int mark : 1;
344 /* This flag will be set if this compilation unit might include
345 inter-compilation-unit references. */
346 unsigned int has_form_ref_addr : 1;
348 /* This flag will be set if this compilation unit includes any
349 DW_TAG_namespace DIEs. If we know that there are explicit
350 DIEs for namespaces, we don't need to try to infer them
351 from mangled names. */
352 unsigned int has_namespace_info : 1;
355 /* Persistent data held for a compilation unit, even when not
356 processing it. We put a pointer to this structure in the
357 read_symtab_private field of the psymtab. If we encounter
358 inter-compilation-unit references, we also maintain a sorted
359 list of all compilation units. */
361 struct dwarf2_per_cu_data
363 /* The start offset and length of this compilation unit. 2**31-1
364 bytes should suffice to store the length of any compilation unit
365 - if it doesn't, GDB will fall over anyway. */
366 unsigned long offset;
367 unsigned long length : 31;
369 /* Flag indicating this compilation unit will be read in before
370 any of the current compilation units are processed. */
371 unsigned long queued : 1;
373 /* Set iff currently read in. */
374 struct dwarf2_cu *cu;
376 /* If full symbols for this CU have been read in, then this field
377 holds a map of DIE offsets to types. It isn't always possible
378 to reconstruct this information later, so we have to preserve
382 /* The partial symbol table associated with this compilation unit. */
383 struct partial_symtab *psymtab;
386 /* The line number information for a compilation unit (found in the
387 .debug_line section) begins with a "statement program header",
388 which contains the following information. */
391 unsigned int total_length;
392 unsigned short version;
393 unsigned int header_length;
394 unsigned char minimum_instruction_length;
395 unsigned char default_is_stmt;
397 unsigned char line_range;
398 unsigned char opcode_base;
400 /* standard_opcode_lengths[i] is the number of operands for the
401 standard opcode whose value is i. This means that
402 standard_opcode_lengths[0] is unused, and the last meaningful
403 element is standard_opcode_lengths[opcode_base - 1]. */
404 unsigned char *standard_opcode_lengths;
406 /* The include_directories table. NOTE! These strings are not
407 allocated with xmalloc; instead, they are pointers into
408 debug_line_buffer. If you try to free them, `free' will get
410 unsigned int num_include_dirs, include_dirs_size;
413 /* The file_names table. NOTE! These strings are not allocated
414 with xmalloc; instead, they are pointers into debug_line_buffer.
415 Don't try to free them directly. */
416 unsigned int num_file_names, file_names_size;
420 unsigned int dir_index;
421 unsigned int mod_time;
423 int included_p; /* Non-zero if referenced by the Line Number Program. */
426 /* The start and end of the statement program following this
427 header. These point into dwarf2_per_objfile->line_buffer. */
428 char *statement_program_start, *statement_program_end;
431 /* When we construct a partial symbol table entry we only
432 need this much information. */
433 struct partial_die_info
435 /* Offset of this DIE. */
438 /* DWARF-2 tag for this DIE. */
439 ENUM_BITFIELD(dwarf_tag) tag : 16;
441 /* Language code associated with this DIE. This is only used
442 for the compilation unit DIE. */
443 unsigned int language : 8;
445 /* Assorted flags describing the data found in this DIE. */
446 unsigned int has_children : 1;
447 unsigned int is_external : 1;
448 unsigned int is_declaration : 1;
449 unsigned int has_type : 1;
450 unsigned int has_specification : 1;
451 unsigned int has_stmt_list : 1;
452 unsigned int has_pc_info : 1;
454 /* Flag set if the SCOPE field of this structure has been
456 unsigned int scope_set : 1;
458 /* The name of this DIE. Normally the value of DW_AT_name, but
459 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
464 /* The scope to prepend to our children. This is generally
465 allocated on the comp_unit_obstack, so will disappear
466 when this compilation unit leaves the cache. */
469 /* The location description associated with this DIE, if any. */
470 struct dwarf_block *locdesc;
472 /* If HAS_PC_INFO, the PC range associated with this DIE. */
476 /* Pointer into the info_buffer pointing at the target of
477 DW_AT_sibling, if any. */
480 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
481 DW_AT_specification (or DW_AT_abstract_origin or
483 unsigned int spec_offset;
485 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
486 unsigned int line_offset;
488 /* Pointers to this DIE's parent, first child, and next sibling,
490 struct partial_die_info *die_parent, *die_child, *die_sibling;
493 /* This data structure holds the information of an abbrev. */
496 unsigned int number; /* number identifying abbrev */
497 enum dwarf_tag tag; /* dwarf tag */
498 unsigned short has_children; /* boolean */
499 unsigned short num_attrs; /* number of attributes */
500 struct attr_abbrev *attrs; /* an array of attribute descriptions */
501 struct abbrev_info *next; /* next in chain */
506 enum dwarf_attribute name;
507 enum dwarf_form form;
510 /* This data structure holds a complete die structure. */
513 enum dwarf_tag tag; /* Tag indicating type of die */
514 unsigned int abbrev; /* Abbrev number */
515 unsigned int offset; /* Offset in .debug_info section */
516 unsigned int num_attrs; /* Number of attributes */
517 struct attribute *attrs; /* An array of attributes */
518 struct die_info *next_ref; /* Next die in ref hash table */
520 /* The dies in a compilation unit form an n-ary tree. PARENT
521 points to this die's parent; CHILD points to the first child of
522 this node; and all the children of a given node are chained
523 together via their SIBLING fields, terminated by a die whose
525 struct die_info *child; /* Its first child, if any. */
526 struct die_info *sibling; /* Its next sibling, if any. */
527 struct die_info *parent; /* Its parent, if any. */
529 struct type *type; /* Cached type information */
532 /* Attributes have a name and a value */
535 enum dwarf_attribute name;
536 enum dwarf_form form;
540 struct dwarf_block *blk;
548 struct function_range
551 CORE_ADDR lowpc, highpc;
553 struct function_range *next;
556 /* Get at parts of an attribute structure */
558 #define DW_STRING(attr) ((attr)->u.str)
559 #define DW_UNSND(attr) ((attr)->u.unsnd)
560 #define DW_BLOCK(attr) ((attr)->u.blk)
561 #define DW_SND(attr) ((attr)->u.snd)
562 #define DW_ADDR(attr) ((attr)->u.addr)
564 /* Blocks are a bunch of untyped bytes. */
571 #ifndef ATTR_ALLOC_CHUNK
572 #define ATTR_ALLOC_CHUNK 4
575 /* Allocate fields for structs, unions and enums in this size. */
576 #ifndef DW_FIELD_ALLOC_CHUNK
577 #define DW_FIELD_ALLOC_CHUNK 4
580 /* A zeroed version of a partial die for initialization purposes. */
581 static struct partial_die_info zeroed_partial_die;
583 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
584 but this would require a corresponding change in unpack_field_as_long
586 static int bits_per_byte = 8;
588 /* The routines that read and process dies for a C struct or C++ class
589 pass lists of data member fields and lists of member function fields
590 in an instance of a field_info structure, as defined below. */
593 /* List of data member and baseclasses fields. */
596 struct nextfield *next;
603 /* Number of fields. */
606 /* Number of baseclasses. */
609 /* Set if the accesibility of one of the fields is not public. */
610 int non_public_fields;
612 /* Member function fields array, entries are allocated in the order they
613 are encountered in the object file. */
616 struct nextfnfield *next;
617 struct fn_field fnfield;
621 /* Member function fieldlist array, contains name of possibly overloaded
622 member function, number of overloaded member functions and a pointer
623 to the head of the member function field chain. */
628 struct nextfnfield *head;
632 /* Number of entries in the fnfieldlists array. */
636 /* One item on the queue of compilation units to read in full symbols
638 struct dwarf2_queue_item
640 struct dwarf2_per_cu_data *per_cu;
641 struct dwarf2_queue_item *next;
644 /* The current queue. */
645 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
647 /* Loaded secondary compilation units are kept in memory until they
648 have not been referenced for the processing of this many
649 compilation units. Set this to zero to disable caching. Cache
650 sizes of up to at least twenty will improve startup time for
651 typical inter-CU-reference binaries, at an obvious memory cost. */
652 static int dwarf2_max_cache_age = 5;
654 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
655 struct cmd_list_element *c, const char *value)
657 fprintf_filtered (file, _("\
658 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
663 /* Various complaints about symbol reading that don't abort the process */
666 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
668 complaint (&symfile_complaints,
669 _("statement list doesn't fit in .debug_line section"));
673 dwarf2_complex_location_expr_complaint (void)
675 complaint (&symfile_complaints, _("location expression too complex"));
679 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
682 complaint (&symfile_complaints,
683 _("const value length mismatch for '%s', got %d, expected %d"), arg1,
688 dwarf2_macros_too_long_complaint (void)
690 complaint (&symfile_complaints,
691 _("macro info runs off end of `.debug_macinfo' section"));
695 dwarf2_macro_malformed_definition_complaint (const char *arg1)
697 complaint (&symfile_complaints,
698 _("macro debug info contains a malformed macro definition:\n`%s'"),
703 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
705 complaint (&symfile_complaints,
706 _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
709 /* local function prototypes */
711 static void dwarf2_locate_sections (bfd *, asection *, void *);
714 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
717 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
720 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
721 struct partial_die_info *,
722 struct partial_symtab *);
724 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
726 static void scan_partial_symbols (struct partial_die_info *,
727 CORE_ADDR *, CORE_ADDR *,
730 static void add_partial_symbol (struct partial_die_info *,
733 static int pdi_needs_namespace (enum dwarf_tag tag);
735 static void add_partial_namespace (struct partial_die_info *pdi,
736 CORE_ADDR *lowpc, CORE_ADDR *highpc,
737 struct dwarf2_cu *cu);
739 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
740 struct dwarf2_cu *cu);
742 static char *locate_pdi_sibling (struct partial_die_info *orig_pdi,
745 struct dwarf2_cu *cu);
747 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
749 static void psymtab_to_symtab_1 (struct partial_symtab *);
751 char *dwarf2_read_section (struct objfile *, asection *);
753 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
755 static void dwarf2_free_abbrev_table (void *);
757 static struct abbrev_info *peek_die_abbrev (char *, unsigned int *,
760 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
763 static struct partial_die_info *load_partial_dies (bfd *, char *, int,
766 static char *read_partial_die (struct partial_die_info *,
767 struct abbrev_info *abbrev, unsigned int,
768 bfd *, char *, struct dwarf2_cu *);
770 static struct partial_die_info *find_partial_die (unsigned long,
773 static void fixup_partial_die (struct partial_die_info *,
776 static char *read_full_die (struct die_info **, bfd *, char *,
777 struct dwarf2_cu *, int *);
779 static char *read_attribute (struct attribute *, struct attr_abbrev *,
780 bfd *, char *, struct dwarf2_cu *);
782 static char *read_attribute_value (struct attribute *, unsigned,
783 bfd *, char *, struct dwarf2_cu *);
785 static unsigned int read_1_byte (bfd *, char *);
787 static int read_1_signed_byte (bfd *, char *);
789 static unsigned int read_2_bytes (bfd *, char *);
791 static unsigned int read_4_bytes (bfd *, char *);
793 static unsigned long read_8_bytes (bfd *, char *);
795 static CORE_ADDR read_address (bfd *, char *ptr, struct dwarf2_cu *,
798 static LONGEST read_initial_length (bfd *, char *,
799 struct comp_unit_head *, unsigned int *);
801 static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *,
804 static char *read_n_bytes (bfd *, char *, unsigned int);
806 static char *read_string (bfd *, char *, unsigned int *);
808 static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
811 static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
813 static long read_signed_leb128 (bfd *, char *, unsigned int *);
815 static char *skip_leb128 (bfd *, char *);
817 static void set_cu_language (unsigned int, struct dwarf2_cu *);
819 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
822 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
823 struct dwarf2_cu *cu);
825 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
827 static struct die_info *die_specification (struct die_info *die,
830 static void free_line_header (struct line_header *lh);
832 static void add_file_name (struct line_header *, char *, unsigned int,
833 unsigned int, unsigned int);
835 static struct line_header *(dwarf_decode_line_header
836 (unsigned int offset,
837 bfd *abfd, struct dwarf2_cu *cu));
839 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
840 struct dwarf2_cu *, struct partial_symtab *);
842 static void dwarf2_start_subfile (char *, char *);
844 static struct symbol *new_symbol (struct die_info *, struct type *,
847 static void dwarf2_const_value (struct attribute *, struct symbol *,
850 static void dwarf2_const_value_data (struct attribute *attr,
854 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
856 static struct type *die_containing_type (struct die_info *,
859 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
861 static void read_type_die (struct die_info *, struct dwarf2_cu *);
863 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
865 static char *typename_concat (struct obstack *, const char *prefix, const char *suffix,
868 static void read_typedef (struct die_info *, struct dwarf2_cu *);
870 static void read_base_type (struct die_info *, struct dwarf2_cu *);
872 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
874 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
876 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
878 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
880 static int dwarf2_get_pc_bounds (struct die_info *,
881 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
883 static void get_scope_pc_bounds (struct die_info *,
884 CORE_ADDR *, CORE_ADDR *,
887 static void dwarf2_add_field (struct field_info *, struct die_info *,
890 static void dwarf2_attach_fields_to_type (struct field_info *,
891 struct type *, struct dwarf2_cu *);
893 static void dwarf2_add_member_fn (struct field_info *,
894 struct die_info *, struct type *,
897 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
898 struct type *, struct dwarf2_cu *);
900 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
902 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
904 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
906 static void read_common_block (struct die_info *, struct dwarf2_cu *);
908 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
910 static const char *namespace_name (struct die_info *die,
911 int *is_anonymous, struct dwarf2_cu *);
913 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
915 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
917 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
919 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
921 static void read_array_type (struct die_info *, struct dwarf2_cu *);
923 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
926 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
928 static void read_tag_ptr_to_member_type (struct die_info *,
931 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
933 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
935 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
937 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
939 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
941 static struct die_info *read_comp_unit (char *, bfd *, struct dwarf2_cu *);
943 static struct die_info *read_die_and_children (char *info_ptr, bfd *abfd,
946 struct die_info *parent);
948 static struct die_info *read_die_and_siblings (char *info_ptr, bfd *abfd,
951 struct die_info *parent);
953 static void free_die_list (struct die_info *);
955 static void process_die (struct die_info *, struct dwarf2_cu *);
957 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
959 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
961 static struct die_info *dwarf2_extension (struct die_info *die,
964 static char *dwarf_tag_name (unsigned int);
966 static char *dwarf_attr_name (unsigned int);
968 static char *dwarf_form_name (unsigned int);
970 static char *dwarf_stack_op_name (unsigned int);
972 static char *dwarf_bool_name (unsigned int);
974 static char *dwarf_type_encoding_name (unsigned int);
977 static char *dwarf_cfi_name (unsigned int);
979 struct die_info *copy_die (struct die_info *);
982 static struct die_info *sibling_die (struct die_info *);
984 static void dump_die (struct die_info *);
986 static void dump_die_list (struct die_info *);
988 static void store_in_ref_table (unsigned int, struct die_info *,
991 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
994 static int dwarf2_get_attr_constant_value (struct attribute *, int);
996 static struct die_info *follow_die_ref (struct die_info *,
1000 static struct type *dwarf2_fundamental_type (struct objfile *, int,
1001 struct dwarf2_cu *);
1003 /* memory allocation interface */
1005 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1007 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1009 static struct die_info *dwarf_alloc_die (void);
1011 static void initialize_cu_func_list (struct dwarf2_cu *);
1013 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1014 struct dwarf2_cu *);
1016 static void dwarf_decode_macros (struct line_header *, unsigned int,
1017 char *, bfd *, struct dwarf2_cu *);
1019 static int attr_form_is_block (struct attribute *);
1022 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
1023 struct dwarf2_cu *cu);
1025 static char *skip_one_die (char *info_ptr, struct abbrev_info *abbrev,
1026 struct dwarf2_cu *cu);
1028 static void free_stack_comp_unit (void *);
1030 static void *hashtab_obstack_allocate (void *data, size_t size, size_t count);
1032 static void dummy_obstack_deallocate (void *object, void *data);
1034 static hashval_t partial_die_hash (const void *item);
1036 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1038 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1039 (unsigned long offset, struct objfile *objfile);
1041 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1042 (unsigned long offset, struct objfile *objfile);
1044 static void free_one_comp_unit (void *);
1046 static void free_cached_comp_units (void *);
1048 static void age_cached_comp_units (void);
1050 static void free_one_cached_comp_unit (void *);
1052 static void set_die_type (struct die_info *, struct type *,
1053 struct dwarf2_cu *);
1055 static void reset_die_and_siblings_types (struct die_info *,
1056 struct dwarf2_cu *);
1058 static void create_all_comp_units (struct objfile *);
1060 static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *);
1062 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1064 static void dwarf2_add_dependence (struct dwarf2_cu *,
1065 struct dwarf2_per_cu_data *);
1067 static void dwarf2_mark (struct dwarf2_cu *);
1069 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1071 /* Try to locate the sections we need for DWARF 2 debugging
1072 information and return true if we have enough to do something. */
1075 dwarf2_has_info (struct objfile *objfile)
1077 struct dwarf2_per_objfile *data;
1079 /* Initialize per-objfile state. */
1080 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1081 memset (data, 0, sizeof (*data));
1082 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1083 dwarf2_per_objfile = data;
1085 dwarf_info_section = 0;
1086 dwarf_abbrev_section = 0;
1087 dwarf_line_section = 0;
1088 dwarf_str_section = 0;
1089 dwarf_macinfo_section = 0;
1090 dwarf_frame_section = 0;
1091 dwarf_eh_frame_section = 0;
1092 dwarf_ranges_section = 0;
1093 dwarf_loc_section = 0;
1095 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1096 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
1099 /* This function is mapped across the sections and remembers the
1100 offset and size of each of the debugging sections we are interested
1104 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
1106 if (strcmp (sectp->name, INFO_SECTION) == 0)
1108 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1109 dwarf_info_section = sectp;
1111 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1113 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1114 dwarf_abbrev_section = sectp;
1116 else if (strcmp (sectp->name, LINE_SECTION) == 0)
1118 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1119 dwarf_line_section = sectp;
1121 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1123 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1124 dwarf_pubnames_section = sectp;
1126 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1128 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1129 dwarf_aranges_section = sectp;
1131 else if (strcmp (sectp->name, LOC_SECTION) == 0)
1133 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1134 dwarf_loc_section = sectp;
1136 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1138 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1139 dwarf_macinfo_section = sectp;
1141 else if (strcmp (sectp->name, STR_SECTION) == 0)
1143 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1144 dwarf_str_section = sectp;
1146 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1148 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1149 dwarf_frame_section = sectp;
1151 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1153 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1154 if (aflag & SEC_HAS_CONTENTS)
1156 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1157 dwarf_eh_frame_section = sectp;
1160 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1162 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1163 dwarf_ranges_section = sectp;
1167 /* Build a partial symbol table. */
1170 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1172 /* We definitely need the .debug_info and .debug_abbrev sections */
1174 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1175 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1177 if (dwarf_line_section)
1178 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1180 dwarf2_per_objfile->line_buffer = NULL;
1182 if (dwarf_str_section)
1183 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1185 dwarf2_per_objfile->str_buffer = NULL;
1187 if (dwarf_macinfo_section)
1188 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1189 dwarf_macinfo_section);
1191 dwarf2_per_objfile->macinfo_buffer = NULL;
1193 if (dwarf_ranges_section)
1194 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1196 dwarf2_per_objfile->ranges_buffer = NULL;
1198 if (dwarf_loc_section)
1199 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1201 dwarf2_per_objfile->loc_buffer = NULL;
1204 || (objfile->global_psymbols.size == 0
1205 && objfile->static_psymbols.size == 0))
1207 init_psymbol_list (objfile, 1024);
1211 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1213 /* Things are significantly easier if we have .debug_aranges and
1214 .debug_pubnames sections */
1216 dwarf2_build_psymtabs_easy (objfile, mainline);
1220 /* only test this case for now */
1222 /* In this case we have to work a bit harder */
1223 dwarf2_build_psymtabs_hard (objfile, mainline);
1228 /* Build the partial symbol table from the information in the
1229 .debug_pubnames and .debug_aranges sections. */
1232 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1234 bfd *abfd = objfile->obfd;
1235 char *aranges_buffer, *pubnames_buffer;
1236 char *aranges_ptr, *pubnames_ptr;
1237 unsigned int entry_length, version, info_offset, info_size;
1239 pubnames_buffer = dwarf2_read_section (objfile,
1240 dwarf_pubnames_section);
1241 pubnames_ptr = pubnames_buffer;
1242 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1244 struct comp_unit_head cu_header;
1245 unsigned int bytes_read;
1247 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1249 pubnames_ptr += bytes_read;
1250 version = read_1_byte (abfd, pubnames_ptr);
1252 info_offset = read_4_bytes (abfd, pubnames_ptr);
1254 info_size = read_4_bytes (abfd, pubnames_ptr);
1258 aranges_buffer = dwarf2_read_section (objfile,
1259 dwarf_aranges_section);
1264 /* Read in the comp unit header information from the debug_info at
1268 read_comp_unit_head (struct comp_unit_head *cu_header,
1269 char *info_ptr, bfd *abfd)
1272 unsigned int bytes_read;
1273 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1275 info_ptr += bytes_read;
1276 cu_header->version = read_2_bytes (abfd, info_ptr);
1278 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1280 info_ptr += bytes_read;
1281 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1283 signed_addr = bfd_get_sign_extend_vma (abfd);
1284 if (signed_addr < 0)
1285 internal_error (__FILE__, __LINE__,
1286 _("read_comp_unit_head: dwarf from non elf file"));
1287 cu_header->signed_addr_p = signed_addr;
1292 partial_read_comp_unit_head (struct comp_unit_head *header, char *info_ptr,
1295 char *beg_of_comp_unit = info_ptr;
1297 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1299 if (header->version != 2)
1300 error (_("Dwarf Error: wrong version in compilation unit header "
1301 "(is %d, should be %d) [in module %s]"), header->version,
1302 2, bfd_get_filename (abfd));
1304 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1305 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1306 "(offset 0x%lx + 6) [in module %s]"),
1307 (long) header->abbrev_offset,
1308 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1309 bfd_get_filename (abfd));
1311 if (beg_of_comp_unit + header->length + header->initial_length_size
1312 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1313 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1314 "(offset 0x%lx + 0) [in module %s]"),
1315 (long) header->length,
1316 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1317 bfd_get_filename (abfd));
1322 /* Allocate a new partial symtab for file named NAME and mark this new
1323 partial symtab as being an include of PST. */
1326 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1327 struct objfile *objfile)
1329 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1331 subpst->section_offsets = pst->section_offsets;
1332 subpst->textlow = 0;
1333 subpst->texthigh = 0;
1335 subpst->dependencies = (struct partial_symtab **)
1336 obstack_alloc (&objfile->objfile_obstack,
1337 sizeof (struct partial_symtab *));
1338 subpst->dependencies[0] = pst;
1339 subpst->number_of_dependencies = 1;
1341 subpst->globals_offset = 0;
1342 subpst->n_global_syms = 0;
1343 subpst->statics_offset = 0;
1344 subpst->n_static_syms = 0;
1345 subpst->symtab = NULL;
1346 subpst->read_symtab = pst->read_symtab;
1349 /* No private part is necessary for include psymtabs. This property
1350 can be used to differentiate between such include psymtabs and
1351 the regular ones. */
1352 subpst->read_symtab_private = NULL;
1355 /* Read the Line Number Program data and extract the list of files
1356 included by the source file represented by PST. Build an include
1357 partial symtab for each of these included files.
1359 This procedure assumes that there *is* a Line Number Program in
1360 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1361 before calling this procedure. */
1364 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1365 struct partial_die_info *pdi,
1366 struct partial_symtab *pst)
1368 struct objfile *objfile = cu->objfile;
1369 bfd *abfd = objfile->obfd;
1370 struct line_header *lh;
1372 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1374 return; /* No linetable, so no includes. */
1376 dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1378 free_line_header (lh);
1382 /* Build the partial symbol table by doing a quick pass through the
1383 .debug_info and .debug_abbrev sections. */
1386 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1388 /* Instead of reading this into a big buffer, we should probably use
1389 mmap() on architectures that support it. (FIXME) */
1390 bfd *abfd = objfile->obfd;
1392 char *beg_of_comp_unit;
1393 struct partial_die_info comp_unit_die;
1394 struct partial_symtab *pst;
1395 struct cleanup *back_to;
1396 CORE_ADDR lowpc, highpc, baseaddr;
1398 info_ptr = dwarf2_per_objfile->info_buffer;
1400 /* Any cached compilation units will be linked by the per-objfile
1401 read_in_chain. Make sure to free them when we're done. */
1402 back_to = make_cleanup (free_cached_comp_units, NULL);
1404 create_all_comp_units (objfile);
1406 /* Since the objects we're extracting from .debug_info vary in
1407 length, only the individual functions to extract them (like
1408 read_comp_unit_head and load_partial_die) can really know whether
1409 the buffer is large enough to hold another complete object.
1411 At the moment, they don't actually check that. If .debug_info
1412 holds just one extra byte after the last compilation unit's dies,
1413 then read_comp_unit_head will happily read off the end of the
1414 buffer. read_partial_die is similarly casual. Those functions
1417 For this loop condition, simply checking whether there's any data
1418 left at all should be sufficient. */
1419 while (info_ptr < (dwarf2_per_objfile->info_buffer
1420 + dwarf2_per_objfile->info_size))
1422 struct cleanup *back_to_inner;
1423 struct dwarf2_cu cu;
1424 struct abbrev_info *abbrev;
1425 unsigned int bytes_read;
1426 struct dwarf2_per_cu_data *this_cu;
1428 beg_of_comp_unit = info_ptr;
1430 memset (&cu, 0, sizeof (cu));
1432 obstack_init (&cu.comp_unit_obstack);
1434 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1436 cu.objfile = objfile;
1437 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1439 /* Complete the cu_header */
1440 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1441 cu.header.first_die_ptr = info_ptr;
1442 cu.header.cu_head_ptr = beg_of_comp_unit;
1444 cu.list_in_scope = &file_symbols;
1446 /* Read the abbrevs for this compilation unit into a table */
1447 dwarf2_read_abbrevs (abfd, &cu);
1448 make_cleanup (dwarf2_free_abbrev_table, &cu);
1450 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile);
1452 /* Read the compilation unit die */
1453 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1454 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1455 abfd, info_ptr, &cu);
1457 /* Set the language we're debugging */
1458 set_cu_language (comp_unit_die.language, &cu);
1460 /* Allocate a new partial symbol table structure */
1461 pst = start_psymtab_common (objfile, objfile->section_offsets,
1462 comp_unit_die.name ? comp_unit_die.name : "",
1463 comp_unit_die.lowpc,
1464 objfile->global_psymbols.next,
1465 objfile->static_psymbols.next);
1467 if (comp_unit_die.dirname)
1468 pst->dirname = xstrdup (comp_unit_die.dirname);
1470 pst->read_symtab_private = (char *) this_cu;
1472 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1474 /* Store the function that reads in the rest of the symbol table */
1475 pst->read_symtab = dwarf2_psymtab_to_symtab;
1477 /* If this compilation unit was already read in, free the
1478 cached copy in order to read it in again. This is
1479 necessary because we skipped some symbols when we first
1480 read in the compilation unit (see load_partial_dies).
1481 This problem could be avoided, but the benefit is
1483 if (this_cu->cu != NULL)
1484 free_one_cached_comp_unit (this_cu->cu);
1486 cu.per_cu = this_cu;
1488 /* Note that this is a pointer to our stack frame, being
1489 added to a global data structure. It will be cleaned up
1490 in free_stack_comp_unit when we finish with this
1491 compilation unit. */
1494 this_cu->psymtab = pst;
1496 /* Check if comp unit has_children.
1497 If so, read the rest of the partial symbols from this comp unit.
1498 If not, there's no more debug_info for this comp unit. */
1499 if (comp_unit_die.has_children)
1501 struct partial_die_info *first_die;
1503 lowpc = ((CORE_ADDR) -1);
1504 highpc = ((CORE_ADDR) 0);
1506 first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1508 scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1510 /* If we didn't find a lowpc, set it to highpc to avoid
1511 complaints from `maint check'. */
1512 if (lowpc == ((CORE_ADDR) -1))
1515 /* If the compilation unit didn't have an explicit address range,
1516 then use the information extracted from its child dies. */
1517 if (! comp_unit_die.has_pc_info)
1519 comp_unit_die.lowpc = lowpc;
1520 comp_unit_die.highpc = highpc;
1523 pst->textlow = comp_unit_die.lowpc + baseaddr;
1524 pst->texthigh = comp_unit_die.highpc + baseaddr;
1526 pst->n_global_syms = objfile->global_psymbols.next -
1527 (objfile->global_psymbols.list + pst->globals_offset);
1528 pst->n_static_syms = objfile->static_psymbols.next -
1529 (objfile->static_psymbols.list + pst->statics_offset);
1530 sort_pst_symbols (pst);
1532 /* If there is already a psymtab or symtab for a file of this
1533 name, remove it. (If there is a symtab, more drastic things
1534 also happen.) This happens in VxWorks. */
1535 free_named_symtabs (pst->filename);
1537 info_ptr = beg_of_comp_unit + cu.header.length
1538 + cu.header.initial_length_size;
1540 if (comp_unit_die.has_stmt_list)
1542 /* Get the list of files included in the current compilation unit,
1543 and build a psymtab for each of them. */
1544 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1547 do_cleanups (back_to_inner);
1549 do_cleanups (back_to);
1552 /* Load the DIEs for a secondary CU into memory. */
1555 load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile)
1557 bfd *abfd = objfile->obfd;
1558 char *info_ptr, *beg_of_comp_unit;
1559 struct partial_die_info comp_unit_die;
1560 struct dwarf2_cu *cu;
1561 struct abbrev_info *abbrev;
1562 unsigned int bytes_read;
1563 struct cleanup *back_to;
1565 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset;
1566 beg_of_comp_unit = info_ptr;
1568 cu = xmalloc (sizeof (struct dwarf2_cu));
1569 memset (cu, 0, sizeof (struct dwarf2_cu));
1571 obstack_init (&cu->comp_unit_obstack);
1573 cu->objfile = objfile;
1574 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd);
1576 /* Complete the cu_header. */
1577 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1578 cu->header.first_die_ptr = info_ptr;
1579 cu->header.cu_head_ptr = beg_of_comp_unit;
1581 /* Read the abbrevs for this compilation unit into a table. */
1582 dwarf2_read_abbrevs (abfd, cu);
1583 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
1585 /* Read the compilation unit die. */
1586 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1587 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1588 abfd, info_ptr, cu);
1590 /* Set the language we're debugging. */
1591 set_cu_language (comp_unit_die.language, cu);
1593 /* Link this compilation unit into the compilation unit tree. */
1595 cu->per_cu = this_cu;
1597 /* Check if comp unit has_children.
1598 If so, read the rest of the partial symbols from this comp unit.
1599 If not, there's no more debug_info for this comp unit. */
1600 if (comp_unit_die.has_children)
1601 load_partial_dies (abfd, info_ptr, 0, cu);
1603 do_cleanups (back_to);
1606 /* Create a list of all compilation units in OBJFILE. We do this only
1607 if an inter-comp-unit reference is found; presumably if there is one,
1608 there will be many, and one will occur early in the .debug_info section.
1609 So there's no point in building this list incrementally. */
1612 create_all_comp_units (struct objfile *objfile)
1616 struct dwarf2_per_cu_data **all_comp_units;
1617 char *info_ptr = dwarf2_per_objfile->info_buffer;
1621 all_comp_units = xmalloc (n_allocated
1622 * sizeof (struct dwarf2_per_cu_data *));
1624 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1626 struct comp_unit_head cu_header;
1627 char *beg_of_comp_unit;
1628 struct dwarf2_per_cu_data *this_cu;
1629 unsigned long offset;
1630 unsigned int bytes_read;
1632 offset = info_ptr - dwarf2_per_objfile->info_buffer;
1634 /* Read just enough information to find out where the next
1635 compilation unit is. */
1636 cu_header.initial_length_size = 0;
1637 cu_header.length = read_initial_length (objfile->obfd, info_ptr,
1638 &cu_header, &bytes_read);
1640 /* Save the compilation unit for later lookup. */
1641 this_cu = obstack_alloc (&objfile->objfile_obstack,
1642 sizeof (struct dwarf2_per_cu_data));
1643 memset (this_cu, 0, sizeof (*this_cu));
1644 this_cu->offset = offset;
1645 this_cu->length = cu_header.length + cu_header.initial_length_size;
1647 if (n_comp_units == n_allocated)
1650 all_comp_units = xrealloc (all_comp_units,
1652 * sizeof (struct dwarf2_per_cu_data *));
1654 all_comp_units[n_comp_units++] = this_cu;
1656 info_ptr = info_ptr + this_cu->length;
1659 dwarf2_per_objfile->all_comp_units
1660 = obstack_alloc (&objfile->objfile_obstack,
1661 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1662 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
1663 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1664 xfree (all_comp_units);
1665 dwarf2_per_objfile->n_comp_units = n_comp_units;
1668 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1669 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1673 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1674 CORE_ADDR *highpc, struct dwarf2_cu *cu)
1676 struct objfile *objfile = cu->objfile;
1677 bfd *abfd = objfile->obfd;
1678 struct partial_die_info *pdi;
1680 /* Now, march along the PDI's, descending into ones which have
1681 interesting children but skipping the children of the other ones,
1682 until we reach the end of the compilation unit. */
1688 fixup_partial_die (pdi, cu);
1690 /* Anonymous namespaces have no name but have interesting
1691 children, so we need to look at them. Ditto for anonymous
1694 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1695 || pdi->tag == DW_TAG_enumeration_type)
1699 case DW_TAG_subprogram:
1700 if (pdi->has_pc_info)
1702 if (pdi->lowpc < *lowpc)
1704 *lowpc = pdi->lowpc;
1706 if (pdi->highpc > *highpc)
1708 *highpc = pdi->highpc;
1710 if (!pdi->is_declaration)
1712 add_partial_symbol (pdi, cu);
1716 case DW_TAG_variable:
1717 case DW_TAG_typedef:
1718 case DW_TAG_union_type:
1719 if (!pdi->is_declaration)
1721 add_partial_symbol (pdi, cu);
1724 case DW_TAG_class_type:
1725 case DW_TAG_structure_type:
1726 if (!pdi->is_declaration)
1728 add_partial_symbol (pdi, cu);
1731 case DW_TAG_enumeration_type:
1732 if (!pdi->is_declaration)
1733 add_partial_enumeration (pdi, cu);
1735 case DW_TAG_base_type:
1736 case DW_TAG_subrange_type:
1737 /* File scope base type definitions are added to the partial
1739 add_partial_symbol (pdi, cu);
1741 case DW_TAG_namespace:
1742 add_partial_namespace (pdi, lowpc, highpc, cu);
1749 /* If the die has a sibling, skip to the sibling. */
1751 pdi = pdi->die_sibling;
1755 /* Functions used to compute the fully scoped name of a partial DIE.
1757 Normally, this is simple. For C++, the parent DIE's fully scoped
1758 name is concatenated with "::" and the partial DIE's name. For
1759 Java, the same thing occurs except that "." is used instead of "::".
1760 Enumerators are an exception; they use the scope of their parent
1761 enumeration type, i.e. the name of the enumeration type is not
1762 prepended to the enumerator.
1764 There are two complexities. One is DW_AT_specification; in this
1765 case "parent" means the parent of the target of the specification,
1766 instead of the direct parent of the DIE. The other is compilers
1767 which do not emit DW_TAG_namespace; in this case we try to guess
1768 the fully qualified name of structure types from their members'
1769 linkage names. This must be done using the DIE's children rather
1770 than the children of any DW_AT_specification target. We only need
1771 to do this for structures at the top level, i.e. if the target of
1772 any DW_AT_specification (if any; otherwise the DIE itself) does not
1775 /* Compute the scope prefix associated with PDI's parent, in
1776 compilation unit CU. The result will be allocated on CU's
1777 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1778 field. NULL is returned if no prefix is necessary. */
1780 partial_die_parent_scope (struct partial_die_info *pdi,
1781 struct dwarf2_cu *cu)
1783 char *grandparent_scope;
1784 struct partial_die_info *parent, *real_pdi;
1786 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1787 then this means the parent of the specification DIE. */
1790 while (real_pdi->has_specification)
1791 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
1793 parent = real_pdi->die_parent;
1797 if (parent->scope_set)
1798 return parent->scope;
1800 fixup_partial_die (parent, cu);
1802 grandparent_scope = partial_die_parent_scope (parent, cu);
1804 if (parent->tag == DW_TAG_namespace
1805 || parent->tag == DW_TAG_structure_type
1806 || parent->tag == DW_TAG_class_type
1807 || parent->tag == DW_TAG_union_type)
1809 if (grandparent_scope == NULL)
1810 parent->scope = parent->name;
1812 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
1815 else if (parent->tag == DW_TAG_enumeration_type)
1816 /* Enumerators should not get the name of the enumeration as a prefix. */
1817 parent->scope = grandparent_scope;
1820 /* FIXME drow/2004-04-01: What should we be doing with
1821 function-local names? For partial symbols, we should probably be
1823 complaint (&symfile_complaints,
1824 _("unhandled containing DIE tag %d for DIE at %d"),
1825 parent->tag, pdi->offset);
1826 parent->scope = grandparent_scope;
1829 parent->scope_set = 1;
1830 return parent->scope;
1833 /* Return the fully scoped name associated with PDI, from compilation unit
1834 CU. The result will be allocated with malloc. */
1836 partial_die_full_name (struct partial_die_info *pdi,
1837 struct dwarf2_cu *cu)
1841 parent_scope = partial_die_parent_scope (pdi, cu);
1842 if (parent_scope == NULL)
1845 return typename_concat (NULL, parent_scope, pdi->name, cu);
1849 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1851 struct objfile *objfile = cu->objfile;
1854 const char *my_prefix;
1855 const struct partial_symbol *psym = NULL;
1857 int built_actual_name = 0;
1859 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1863 if (pdi_needs_namespace (pdi->tag))
1865 actual_name = partial_die_full_name (pdi, cu);
1867 built_actual_name = 1;
1870 if (actual_name == NULL)
1871 actual_name = pdi->name;
1875 case DW_TAG_subprogram:
1876 if (pdi->is_external)
1878 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1879 mst_text, objfile); */
1880 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1881 VAR_DOMAIN, LOC_BLOCK,
1882 &objfile->global_psymbols,
1883 0, pdi->lowpc + baseaddr,
1884 cu->language, objfile);
1888 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1889 mst_file_text, objfile); */
1890 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1891 VAR_DOMAIN, LOC_BLOCK,
1892 &objfile->static_psymbols,
1893 0, pdi->lowpc + baseaddr,
1894 cu->language, objfile);
1897 case DW_TAG_variable:
1898 if (pdi->is_external)
1901 Don't enter into the minimal symbol tables as there is
1902 a minimal symbol table entry from the ELF symbols already.
1903 Enter into partial symbol table if it has a location
1904 descriptor or a type.
1905 If the location descriptor is missing, new_symbol will create
1906 a LOC_UNRESOLVED symbol, the address of the variable will then
1907 be determined from the minimal symbol table whenever the variable
1909 The address for the partial symbol table entry is not
1910 used by GDB, but it comes in handy for debugging partial symbol
1914 addr = decode_locdesc (pdi->locdesc, cu);
1915 if (pdi->locdesc || pdi->has_type)
1916 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1917 VAR_DOMAIN, LOC_STATIC,
1918 &objfile->global_psymbols,
1920 cu->language, objfile);
1924 /* Static Variable. Skip symbols without location descriptors. */
1925 if (pdi->locdesc == NULL)
1927 addr = decode_locdesc (pdi->locdesc, cu);
1928 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1929 mst_file_data, objfile); */
1930 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1931 VAR_DOMAIN, LOC_STATIC,
1932 &objfile->static_psymbols,
1934 cu->language, objfile);
1937 case DW_TAG_typedef:
1938 case DW_TAG_base_type:
1939 case DW_TAG_subrange_type:
1940 add_psymbol_to_list (actual_name, strlen (actual_name),
1941 VAR_DOMAIN, LOC_TYPEDEF,
1942 &objfile->static_psymbols,
1943 0, (CORE_ADDR) 0, cu->language, objfile);
1945 case DW_TAG_namespace:
1946 add_psymbol_to_list (actual_name, strlen (actual_name),
1947 VAR_DOMAIN, LOC_TYPEDEF,
1948 &objfile->global_psymbols,
1949 0, (CORE_ADDR) 0, cu->language, objfile);
1951 case DW_TAG_class_type:
1952 case DW_TAG_structure_type:
1953 case DW_TAG_union_type:
1954 case DW_TAG_enumeration_type:
1955 /* Skip aggregate types without children, these are external
1957 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1958 static vs. global. */
1959 if (pdi->has_children == 0)
1961 add_psymbol_to_list (actual_name, strlen (actual_name),
1962 STRUCT_DOMAIN, LOC_TYPEDEF,
1963 (cu->language == language_cplus
1964 || cu->language == language_java)
1965 ? &objfile->global_psymbols
1966 : &objfile->static_psymbols,
1967 0, (CORE_ADDR) 0, cu->language, objfile);
1969 if (cu->language == language_cplus
1970 || cu->language == language_java)
1972 /* For C++ and Java, these implicitly act as typedefs as well. */
1973 add_psymbol_to_list (actual_name, strlen (actual_name),
1974 VAR_DOMAIN, LOC_TYPEDEF,
1975 &objfile->global_psymbols,
1976 0, (CORE_ADDR) 0, cu->language, objfile);
1979 case DW_TAG_enumerator:
1980 add_psymbol_to_list (actual_name, strlen (actual_name),
1981 VAR_DOMAIN, LOC_CONST,
1982 (cu->language == language_cplus
1983 || cu->language == language_java)
1984 ? &objfile->global_psymbols
1985 : &objfile->static_psymbols,
1986 0, (CORE_ADDR) 0, cu->language, objfile);
1992 /* Check to see if we should scan the name for possible namespace
1993 info. Only do this if this is C++, if we don't have namespace
1994 debugging info in the file, if the psym is of an appropriate type
1995 (otherwise we'll have psym == NULL), and if we actually had a
1996 mangled name to begin with. */
1998 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1999 cases which do not set PSYM above? */
2001 if (cu->language == language_cplus
2002 && cu->has_namespace_info == 0
2004 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2005 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2008 if (built_actual_name)
2009 xfree (actual_name);
2012 /* Determine whether a die of type TAG living in a C++ class or
2013 namespace needs to have the name of the scope prepended to the
2014 name listed in the die. */
2017 pdi_needs_namespace (enum dwarf_tag tag)
2021 case DW_TAG_namespace:
2022 case DW_TAG_typedef:
2023 case DW_TAG_class_type:
2024 case DW_TAG_structure_type:
2025 case DW_TAG_union_type:
2026 case DW_TAG_enumeration_type:
2027 case DW_TAG_enumerator:
2034 /* Read a partial die corresponding to a namespace; also, add a symbol
2035 corresponding to that namespace to the symbol table. NAMESPACE is
2036 the name of the enclosing namespace. */
2039 add_partial_namespace (struct partial_die_info *pdi,
2040 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2041 struct dwarf2_cu *cu)
2043 struct objfile *objfile = cu->objfile;
2045 /* Add a symbol for the namespace. */
2047 add_partial_symbol (pdi, cu);
2049 /* Now scan partial symbols in that namespace. */
2051 if (pdi->has_children)
2052 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
2055 /* See if we can figure out if the class lives in a namespace. We do
2056 this by looking for a member function; its demangled name will
2057 contain namespace info, if there is any. */
2060 guess_structure_name (struct partial_die_info *struct_pdi,
2061 struct dwarf2_cu *cu)
2063 if ((cu->language == language_cplus
2064 || cu->language == language_java)
2065 && cu->has_namespace_info == 0
2066 && struct_pdi->has_children)
2068 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2069 what template types look like, because the demangler
2070 frequently doesn't give the same name as the debug info. We
2071 could fix this by only using the demangled name to get the
2072 prefix (but see comment in read_structure_type). */
2074 struct partial_die_info *child_pdi = struct_pdi->die_child;
2075 struct partial_die_info *real_pdi;
2077 /* If this DIE (this DIE's specification, if any) has a parent, then
2078 we should not do this. We'll prepend the parent's fully qualified
2079 name when we create the partial symbol. */
2081 real_pdi = struct_pdi;
2082 while (real_pdi->has_specification)
2083 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2085 if (real_pdi->die_parent != NULL)
2088 while (child_pdi != NULL)
2090 if (child_pdi->tag == DW_TAG_subprogram)
2092 char *actual_class_name
2093 = language_class_name_from_physname (cu->language_defn,
2095 if (actual_class_name != NULL)
2098 = obsavestring (actual_class_name,
2099 strlen (actual_class_name),
2100 &cu->comp_unit_obstack);
2101 xfree (actual_class_name);
2106 child_pdi = child_pdi->die_sibling;
2111 /* Read a partial die corresponding to an enumeration type. */
2114 add_partial_enumeration (struct partial_die_info *enum_pdi,
2115 struct dwarf2_cu *cu)
2117 struct objfile *objfile = cu->objfile;
2118 bfd *abfd = objfile->obfd;
2119 struct partial_die_info *pdi;
2121 if (enum_pdi->name != NULL)
2122 add_partial_symbol (enum_pdi, cu);
2124 pdi = enum_pdi->die_child;
2127 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2128 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2130 add_partial_symbol (pdi, cu);
2131 pdi = pdi->die_sibling;
2135 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2136 Return the corresponding abbrev, or NULL if the number is zero (indicating
2137 an empty DIE). In either case *BYTES_READ will be set to the length of
2138 the initial number. */
2140 static struct abbrev_info *
2141 peek_die_abbrev (char *info_ptr, unsigned int *bytes_read,
2142 struct dwarf2_cu *cu)
2144 bfd *abfd = cu->objfile->obfd;
2145 unsigned int abbrev_number;
2146 struct abbrev_info *abbrev;
2148 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2150 if (abbrev_number == 0)
2153 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2156 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2157 bfd_get_filename (abfd));
2163 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2164 pointer to the end of a series of DIEs, terminated by an empty
2165 DIE. Any children of the skipped DIEs will also be skipped. */
2168 skip_children (char *info_ptr, struct dwarf2_cu *cu)
2170 struct abbrev_info *abbrev;
2171 unsigned int bytes_read;
2175 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2177 return info_ptr + bytes_read;
2179 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
2183 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2184 should point just after the initial uleb128 of a DIE, and the
2185 abbrev corresponding to that skipped uleb128 should be passed in
2186 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2190 skip_one_die (char *info_ptr, struct abbrev_info *abbrev,
2191 struct dwarf2_cu *cu)
2193 unsigned int bytes_read;
2194 struct attribute attr;
2195 bfd *abfd = cu->objfile->obfd;
2196 unsigned int form, i;
2198 for (i = 0; i < abbrev->num_attrs; i++)
2200 /* The only abbrev we care about is DW_AT_sibling. */
2201 if (abbrev->attrs[i].name == DW_AT_sibling)
2203 read_attribute (&attr, &abbrev->attrs[i],
2204 abfd, info_ptr, cu);
2205 if (attr.form == DW_FORM_ref_addr)
2206 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2208 return dwarf2_per_objfile->info_buffer
2209 + dwarf2_get_ref_die_offset (&attr, cu);
2212 /* If it isn't DW_AT_sibling, skip this attribute. */
2213 form = abbrev->attrs[i].form;
2218 case DW_FORM_ref_addr:
2219 info_ptr += cu->header.addr_size;
2238 case DW_FORM_string:
2239 read_string (abfd, info_ptr, &bytes_read);
2240 info_ptr += bytes_read;
2243 info_ptr += cu->header.offset_size;
2246 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2247 info_ptr += bytes_read;
2249 case DW_FORM_block1:
2250 info_ptr += 1 + read_1_byte (abfd, info_ptr);
2252 case DW_FORM_block2:
2253 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2255 case DW_FORM_block4:
2256 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2260 case DW_FORM_ref_udata:
2261 info_ptr = skip_leb128 (abfd, info_ptr);
2263 case DW_FORM_indirect:
2264 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2265 info_ptr += bytes_read;
2266 /* We need to continue parsing from here, so just go back to
2268 goto skip_attribute;
2271 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2272 dwarf_form_name (form),
2273 bfd_get_filename (abfd));
2277 if (abbrev->has_children)
2278 return skip_children (info_ptr, cu);
2283 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2284 the next DIE after ORIG_PDI. */
2287 locate_pdi_sibling (struct partial_die_info *orig_pdi, char *info_ptr,
2288 bfd *abfd, struct dwarf2_cu *cu)
2290 /* Do we know the sibling already? */
2292 if (orig_pdi->sibling)
2293 return orig_pdi->sibling;
2295 /* Are there any children to deal with? */
2297 if (!orig_pdi->has_children)
2300 /* Skip the children the long way. */
2302 return skip_children (info_ptr, cu);
2305 /* Expand this partial symbol table into a full symbol table. */
2308 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2310 /* FIXME: This is barely more than a stub. */
2315 warning (_("bug: psymtab for %s is already read in."), pst->filename);
2321 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
2322 gdb_flush (gdb_stdout);
2325 /* Restore our global data. */
2326 dwarf2_per_objfile = objfile_data (pst->objfile,
2327 dwarf2_objfile_data_key);
2329 psymtab_to_symtab_1 (pst);
2331 /* Finish up the debug error message. */
2333 printf_filtered (_("done.\n"));
2338 /* Add PER_CU to the queue. */
2341 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
2343 struct dwarf2_queue_item *item;
2346 item = xmalloc (sizeof (*item));
2347 item->per_cu = per_cu;
2350 if (dwarf2_queue == NULL)
2351 dwarf2_queue = item;
2353 dwarf2_queue_tail->next = item;
2355 dwarf2_queue_tail = item;
2358 /* Process the queue. */
2361 process_queue (struct objfile *objfile)
2363 struct dwarf2_queue_item *item, *next_item;
2365 /* Initially, there is just one item on the queue. Load its DIEs,
2366 and the DIEs of any other compilation units it requires,
2369 for (item = dwarf2_queue; item != NULL; item = item->next)
2371 /* Read in this compilation unit. This may add new items to
2372 the end of the queue. */
2373 load_full_comp_unit (item->per_cu);
2375 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
2376 dwarf2_per_objfile->read_in_chain = item->per_cu;
2378 /* If this compilation unit has already had full symbols created,
2379 reset the TYPE fields in each DIE. */
2380 if (item->per_cu->psymtab->readin)
2381 reset_die_and_siblings_types (item->per_cu->cu->dies,
2385 /* Now everything left on the queue needs to be read in. Process
2386 them, one at a time, removing from the queue as we finish. */
2387 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
2389 if (!item->per_cu->psymtab->readin)
2390 process_full_comp_unit (item->per_cu);
2392 item->per_cu->queued = 0;
2393 next_item = item->next;
2397 dwarf2_queue_tail = NULL;
2400 /* Free all allocated queue entries. This function only releases anything if
2401 an error was thrown; if the queue was processed then it would have been
2402 freed as we went along. */
2405 dwarf2_release_queue (void *dummy)
2407 struct dwarf2_queue_item *item, *last;
2409 item = dwarf2_queue;
2412 /* Anything still marked queued is likely to be in an
2413 inconsistent state, so discard it. */
2414 if (item->per_cu->queued)
2416 if (item->per_cu->cu != NULL)
2417 free_one_cached_comp_unit (item->per_cu->cu);
2418 item->per_cu->queued = 0;
2426 dwarf2_queue = dwarf2_queue_tail = NULL;
2429 /* Read in full symbols for PST, and anything it depends on. */
2432 psymtab_to_symtab_1 (struct partial_symtab *pst)
2434 struct dwarf2_per_cu_data *per_cu;
2435 struct cleanup *back_to;
2438 for (i = 0; i < pst->number_of_dependencies; i++)
2439 if (!pst->dependencies[i]->readin)
2441 /* Inform about additional files that need to be read in. */
2444 /* FIXME: i18n: Need to make this a single string. */
2445 fputs_filtered (" ", gdb_stdout);
2447 fputs_filtered ("and ", gdb_stdout);
2449 printf_filtered ("%s...", pst->dependencies[i]->filename);
2450 wrap_here (""); /* Flush output */
2451 gdb_flush (gdb_stdout);
2453 psymtab_to_symtab_1 (pst->dependencies[i]);
2456 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
2460 /* It's an include file, no symbols to read for it.
2461 Everything is in the parent symtab. */
2466 back_to = make_cleanup (dwarf2_release_queue, NULL);
2468 queue_comp_unit (per_cu);
2470 process_queue (pst->objfile);
2472 /* Age the cache, releasing compilation units that have not
2473 been used recently. */
2474 age_cached_comp_units ();
2476 do_cleanups (back_to);
2479 /* Load the DIEs associated with PST and PER_CU into memory. */
2481 static struct dwarf2_cu *
2482 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2484 struct partial_symtab *pst = per_cu->psymtab;
2485 bfd *abfd = pst->objfile->obfd;
2486 struct dwarf2_cu *cu;
2487 unsigned long offset;
2489 struct cleanup *back_to, *free_cu_cleanup;
2490 struct attribute *attr;
2493 /* Set local variables from the partial symbol table info. */
2494 offset = per_cu->offset;
2496 info_ptr = dwarf2_per_objfile->info_buffer + offset;
2498 cu = xmalloc (sizeof (struct dwarf2_cu));
2499 memset (cu, 0, sizeof (struct dwarf2_cu));
2501 /* If an error occurs while loading, release our storage. */
2502 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
2504 cu->objfile = pst->objfile;
2506 /* read in the comp_unit header */
2507 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
2509 /* Read the abbrevs for this compilation unit */
2510 dwarf2_read_abbrevs (abfd, cu);
2511 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2513 cu->header.offset = offset;
2515 cu->per_cu = per_cu;
2518 /* We use this obstack for block values in dwarf_alloc_block. */
2519 obstack_init (&cu->comp_unit_obstack);
2521 cu->dies = read_comp_unit (info_ptr, abfd, cu);
2523 /* We try not to read any attributes in this function, because not
2524 all objfiles needed for references have been loaded yet, and symbol
2525 table processing isn't initialized. But we have to set the CU language,
2526 or we won't be able to build types correctly. */
2527 attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
2529 set_cu_language (DW_UNSND (attr), cu);
2531 set_cu_language (language_minimal, cu);
2533 do_cleanups (back_to);
2535 /* We've successfully allocated this compilation unit. Let our caller
2536 clean it up when finished with it. */
2537 discard_cleanups (free_cu_cleanup);
2542 /* Generate full symbol information for PST and CU, whose DIEs have
2543 already been loaded into memory. */
2546 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2548 struct partial_symtab *pst = per_cu->psymtab;
2549 struct dwarf2_cu *cu = per_cu->cu;
2550 struct objfile *objfile = pst->objfile;
2551 bfd *abfd = objfile->obfd;
2552 CORE_ADDR lowpc, highpc;
2553 struct symtab *symtab;
2554 struct cleanup *back_to;
2555 struct attribute *attr;
2558 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2560 /* We're in the global namespace. */
2561 processing_current_prefix = "";
2564 back_to = make_cleanup (really_free_pendings, NULL);
2566 cu->list_in_scope = &file_symbols;
2568 /* Find the base address of the compilation unit for range lists and
2569 location lists. It will normally be specified by DW_AT_low_pc.
2570 In DWARF-3 draft 4, the base address could be overridden by
2571 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2572 compilation units with discontinuous ranges. */
2574 cu->header.base_known = 0;
2575 cu->header.base_address = 0;
2577 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
2580 cu->header.base_address = DW_ADDR (attr);
2581 cu->header.base_known = 1;
2585 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
2588 cu->header.base_address = DW_ADDR (attr);
2589 cu->header.base_known = 1;
2593 /* Do line number decoding in read_file_scope () */
2594 process_die (cu->dies, cu);
2596 /* Some compilers don't define a DW_AT_high_pc attribute for the
2597 compilation unit. If the DW_AT_high_pc is missing, synthesize
2598 it, by scanning the DIE's below the compilation unit. */
2599 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
2601 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2603 /* Set symtab language to language from DW_AT_language.
2604 If the compilation is from a C file generated by language preprocessors,
2605 do not set the language if it was already deduced by start_subfile. */
2607 && !(cu->language == language_c && symtab->language != language_c))
2609 symtab->language = cu->language;
2611 pst->symtab = symtab;
2614 do_cleanups (back_to);
2617 /* Process a die and its children. */
2620 process_die (struct die_info *die, struct dwarf2_cu *cu)
2624 case DW_TAG_padding:
2626 case DW_TAG_compile_unit:
2627 read_file_scope (die, cu);
2629 case DW_TAG_subprogram:
2630 read_subroutine_type (die, cu);
2631 read_func_scope (die, cu);
2633 case DW_TAG_inlined_subroutine:
2634 /* FIXME: These are ignored for now.
2635 They could be used to set breakpoints on all inlined instances
2636 of a function and make GDB `next' properly over inlined functions. */
2638 case DW_TAG_lexical_block:
2639 case DW_TAG_try_block:
2640 case DW_TAG_catch_block:
2641 read_lexical_block_scope (die, cu);
2643 case DW_TAG_class_type:
2644 case DW_TAG_structure_type:
2645 case DW_TAG_union_type:
2646 read_structure_type (die, cu);
2647 process_structure_scope (die, cu);
2649 case DW_TAG_enumeration_type:
2650 read_enumeration_type (die, cu);
2651 process_enumeration_scope (die, cu);
2654 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2655 a symbol or process any children. Therefore it doesn't do anything
2656 that won't be done on-demand by read_type_die. */
2657 case DW_TAG_subroutine_type:
2658 read_subroutine_type (die, cu);
2660 case DW_TAG_array_type:
2661 read_array_type (die, cu);
2663 case DW_TAG_pointer_type:
2664 read_tag_pointer_type (die, cu);
2666 case DW_TAG_ptr_to_member_type:
2667 read_tag_ptr_to_member_type (die, cu);
2669 case DW_TAG_reference_type:
2670 read_tag_reference_type (die, cu);
2672 case DW_TAG_string_type:
2673 read_tag_string_type (die, cu);
2677 case DW_TAG_base_type:
2678 read_base_type (die, cu);
2679 /* Add a typedef symbol for the type definition, if it has a
2681 new_symbol (die, die->type, cu);
2683 case DW_TAG_subrange_type:
2684 read_subrange_type (die, cu);
2685 /* Add a typedef symbol for the type definition, if it has a
2687 new_symbol (die, die->type, cu);
2689 case DW_TAG_common_block:
2690 read_common_block (die, cu);
2692 case DW_TAG_common_inclusion:
2694 case DW_TAG_namespace:
2695 processing_has_namespace_info = 1;
2696 read_namespace (die, cu);
2698 case DW_TAG_imported_declaration:
2699 case DW_TAG_imported_module:
2700 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2701 information contained in these. DW_TAG_imported_declaration
2702 dies shouldn't have children; DW_TAG_imported_module dies
2703 shouldn't in the C++ case, but conceivably could in the
2704 Fortran case, so we'll have to replace this gdb_assert if
2705 Fortran compilers start generating that info. */
2706 processing_has_namespace_info = 1;
2707 gdb_assert (die->child == NULL);
2710 new_symbol (die, NULL, cu);
2716 initialize_cu_func_list (struct dwarf2_cu *cu)
2718 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2722 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2724 struct objfile *objfile = cu->objfile;
2725 struct comp_unit_head *cu_header = &cu->header;
2726 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2727 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2728 CORE_ADDR highpc = ((CORE_ADDR) 0);
2729 struct attribute *attr;
2730 char *name = "<unknown>";
2731 char *comp_dir = NULL;
2732 struct die_info *child_die;
2733 bfd *abfd = objfile->obfd;
2734 struct line_header *line_header = 0;
2737 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2739 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2741 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2742 from finish_block. */
2743 if (lowpc == ((CORE_ADDR) -1))
2748 attr = dwarf2_attr (die, DW_AT_name, cu);
2751 name = DW_STRING (attr);
2753 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2756 comp_dir = DW_STRING (attr);
2759 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2760 directory, get rid of it. */
2761 char *cp = strchr (comp_dir, ':');
2763 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2768 attr = dwarf2_attr (die, DW_AT_language, cu);
2771 set_cu_language (DW_UNSND (attr), cu);
2774 attr = dwarf2_attr (die, DW_AT_producer, cu);
2776 cu->producer = DW_STRING (attr);
2778 /* We assume that we're processing GCC output. */
2779 processing_gcc_compilation = 2;
2781 /* FIXME:Do something here. */
2782 if (dip->at_producer != NULL)
2784 handle_producer (dip->at_producer);
2788 /* The compilation unit may be in a different language or objfile,
2789 zero out all remembered fundamental types. */
2790 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2792 start_symtab (name, comp_dir, lowpc);
2793 record_debugformat ("DWARF 2");
2795 initialize_cu_func_list (cu);
2797 /* Process all dies in compilation unit. */
2798 if (die->child != NULL)
2800 child_die = die->child;
2801 while (child_die && child_die->tag)
2803 process_die (child_die, cu);
2804 child_die = sibling_die (child_die);
2808 /* Decode line number information if present. */
2809 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2812 unsigned int line_offset = DW_UNSND (attr);
2813 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2816 make_cleanup ((make_cleanup_ftype *) free_line_header,
2817 (void *) line_header);
2818 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2822 /* Decode macro information, if present. Dwarf 2 macro information
2823 refers to information in the line number info statement program
2824 header, so we can only read it if we've read the header
2826 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2827 if (attr && line_header)
2829 unsigned int macro_offset = DW_UNSND (attr);
2830 dwarf_decode_macros (line_header, macro_offset,
2831 comp_dir, abfd, cu);
2833 do_cleanups (back_to);
2837 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2838 struct dwarf2_cu *cu)
2840 struct function_range *thisfn;
2842 thisfn = (struct function_range *)
2843 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2844 thisfn->name = name;
2845 thisfn->lowpc = lowpc;
2846 thisfn->highpc = highpc;
2847 thisfn->seen_line = 0;
2848 thisfn->next = NULL;
2850 if (cu->last_fn == NULL)
2851 cu->first_fn = thisfn;
2853 cu->last_fn->next = thisfn;
2855 cu->last_fn = thisfn;
2859 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2861 struct objfile *objfile = cu->objfile;
2862 struct context_stack *new;
2865 struct die_info *child_die;
2866 struct attribute *attr;
2868 const char *previous_prefix = processing_current_prefix;
2869 struct cleanup *back_to = NULL;
2872 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2874 name = dwarf2_linkage_name (die, cu);
2876 /* Ignore functions with missing or empty names and functions with
2877 missing or invalid low and high pc attributes. */
2878 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2881 if (cu->language == language_cplus
2882 || cu->language == language_java)
2884 struct die_info *spec_die = die_specification (die, cu);
2886 /* NOTE: carlton/2004-01-23: We have to be careful in the
2887 presence of DW_AT_specification. For example, with GCC 3.4,
2892 // Definition of N::foo.
2896 then we'll have a tree of DIEs like this:
2898 1: DW_TAG_compile_unit
2899 2: DW_TAG_namespace // N
2900 3: DW_TAG_subprogram // declaration of N::foo
2901 4: DW_TAG_subprogram // definition of N::foo
2902 DW_AT_specification // refers to die #3
2904 Thus, when processing die #4, we have to pretend that we're
2905 in the context of its DW_AT_specification, namely the contex
2908 if (spec_die != NULL)
2910 char *specification_prefix = determine_prefix (spec_die, cu);
2911 processing_current_prefix = specification_prefix;
2912 back_to = make_cleanup (xfree, specification_prefix);
2919 /* Record the function range for dwarf_decode_lines. */
2920 add_to_cu_func_list (name, lowpc, highpc, cu);
2922 new = push_context (0, lowpc);
2923 new->name = new_symbol (die, die->type, cu);
2925 /* If there is a location expression for DW_AT_frame_base, record
2927 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2929 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2930 expression is being recorded directly in the function's symbol
2931 and not in a separate frame-base object. I guess this hack is
2932 to avoid adding some sort of frame-base adjunct/annex to the
2933 function's symbol :-(. The problem with doing this is that it
2934 results in a function symbol with a location expression that
2935 has nothing to do with the location of the function, ouch! The
2936 relationship should be: a function's symbol has-a frame base; a
2937 frame-base has-a location expression. */
2938 dwarf2_symbol_mark_computed (attr, new->name, cu);
2940 cu->list_in_scope = &local_symbols;
2942 if (die->child != NULL)
2944 child_die = die->child;
2945 while (child_die && child_die->tag)
2947 process_die (child_die, cu);
2948 child_die = sibling_die (child_die);
2952 new = pop_context ();
2953 /* Make a block for the local symbols within. */
2954 finish_block (new->name, &local_symbols, new->old_blocks,
2955 lowpc, highpc, objfile);
2957 /* In C++, we can have functions nested inside functions (e.g., when
2958 a function declares a class that has methods). This means that
2959 when we finish processing a function scope, we may need to go
2960 back to building a containing block's symbol lists. */
2961 local_symbols = new->locals;
2962 param_symbols = new->params;
2964 /* If we've finished processing a top-level function, subsequent
2965 symbols go in the file symbol list. */
2966 if (outermost_context_p ())
2967 cu->list_in_scope = &file_symbols;
2969 processing_current_prefix = previous_prefix;
2970 if (back_to != NULL)
2971 do_cleanups (back_to);
2974 /* Process all the DIES contained within a lexical block scope. Start
2975 a new scope, process the dies, and then close the scope. */
2978 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2980 struct objfile *objfile = cu->objfile;
2981 struct context_stack *new;
2982 CORE_ADDR lowpc, highpc;
2983 struct die_info *child_die;
2986 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2988 /* Ignore blocks with missing or invalid low and high pc attributes. */
2989 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2990 as multiple lexical blocks? Handling children in a sane way would
2991 be nasty. Might be easier to properly extend generic blocks to
2993 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2998 push_context (0, lowpc);
2999 if (die->child != NULL)
3001 child_die = die->child;
3002 while (child_die && child_die->tag)
3004 process_die (child_die, cu);
3005 child_die = sibling_die (child_die);
3008 new = pop_context ();
3010 if (local_symbols != NULL)
3012 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3015 local_symbols = new->locals;
3018 /* Get low and high pc attributes from a die. Return 1 if the attributes
3019 are present and valid, otherwise, return 0. Return -1 if the range is
3020 discontinuous, i.e. derived from DW_AT_ranges information. */
3022 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
3023 CORE_ADDR *highpc, struct dwarf2_cu *cu)
3025 struct objfile *objfile = cu->objfile;
3026 struct comp_unit_head *cu_header = &cu->header;
3027 struct attribute *attr;
3028 bfd *obfd = objfile->obfd;
3033 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
3036 high = DW_ADDR (attr);
3037 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3039 low = DW_ADDR (attr);
3041 /* Found high w/o low attribute. */
3044 /* Found consecutive range of addresses. */
3049 attr = dwarf2_attr (die, DW_AT_ranges, cu);
3052 unsigned int addr_size = cu_header->addr_size;
3053 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3054 /* Value of the DW_AT_ranges attribute is the offset in the
3055 .debug_ranges section. */
3056 unsigned int offset = DW_UNSND (attr);
3057 /* Base address selection entry. */
3065 found_base = cu_header->base_known;
3066 base = cu_header->base_address;
3068 if (offset >= dwarf2_per_objfile->ranges_size)
3070 complaint (&symfile_complaints,
3071 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3075 buffer = dwarf2_per_objfile->ranges_buffer + offset;
3077 /* Read in the largest possible address. */
3078 marker = read_address (obfd, buffer, cu, &dummy);
3079 if ((marker & mask) == mask)
3081 /* If we found the largest possible address, then
3082 read the base address. */
3083 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3084 buffer += 2 * addr_size;
3085 offset += 2 * addr_size;
3093 CORE_ADDR range_beginning, range_end;
3095 range_beginning = read_address (obfd, buffer, cu, &dummy);
3096 buffer += addr_size;
3097 range_end = read_address (obfd, buffer, cu, &dummy);
3098 buffer += addr_size;
3099 offset += 2 * addr_size;
3101 /* An end of list marker is a pair of zero addresses. */
3102 if (range_beginning == 0 && range_end == 0)
3103 /* Found the end of list entry. */
3106 /* Each base address selection entry is a pair of 2 values.
3107 The first is the largest possible address, the second is
3108 the base address. Check for a base address here. */
3109 if ((range_beginning & mask) == mask)
3111 /* If we found the largest possible address, then
3112 read the base address. */
3113 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3120 /* We have no valid base address for the ranges
3122 complaint (&symfile_complaints,
3123 _("Invalid .debug_ranges data (no base address)"));
3127 range_beginning += base;
3130 /* FIXME: This is recording everything as a low-high
3131 segment of consecutive addresses. We should have a
3132 data structure for discontiguous block ranges
3136 low = range_beginning;
3142 if (range_beginning < low)
3143 low = range_beginning;
3144 if (range_end > high)
3150 /* If the first entry is an end-of-list marker, the range
3151 describes an empty scope, i.e. no instructions. */
3161 /* When using the GNU linker, .gnu.linkonce. sections are used to
3162 eliminate duplicate copies of functions and vtables and such.
3163 The linker will arbitrarily choose one and discard the others.
3164 The AT_*_pc values for such functions refer to local labels in
3165 these sections. If the section from that file was discarded, the
3166 labels are not in the output, so the relocs get a value of 0.
3167 If this is a discarded function, mark the pc bounds as invalid,
3168 so that GDB will ignore it. */
3169 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
3177 /* Get the low and high pc's represented by the scope DIE, and store
3178 them in *LOWPC and *HIGHPC. If the correct values can't be
3179 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3182 get_scope_pc_bounds (struct die_info *die,
3183 CORE_ADDR *lowpc, CORE_ADDR *highpc,
3184 struct dwarf2_cu *cu)
3186 CORE_ADDR best_low = (CORE_ADDR) -1;
3187 CORE_ADDR best_high = (CORE_ADDR) 0;
3188 CORE_ADDR current_low, current_high;
3190 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
3192 best_low = current_low;
3193 best_high = current_high;
3197 struct die_info *child = die->child;
3199 while (child && child->tag)
3201 switch (child->tag) {
3202 case DW_TAG_subprogram:
3203 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
3205 best_low = min (best_low, current_low);
3206 best_high = max (best_high, current_high);
3209 case DW_TAG_namespace:
3210 /* FIXME: carlton/2004-01-16: Should we do this for
3211 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3212 that current GCC's always emit the DIEs corresponding
3213 to definitions of methods of classes as children of a
3214 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3215 the DIEs giving the declarations, which could be
3216 anywhere). But I don't see any reason why the
3217 standards says that they have to be there. */
3218 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
3220 if (current_low != ((CORE_ADDR) -1))
3222 best_low = min (best_low, current_low);
3223 best_high = max (best_high, current_high);
3231 child = sibling_die (child);
3236 *highpc = best_high;
3239 /* Add an aggregate field to the field list. */
3242 dwarf2_add_field (struct field_info *fip, struct die_info *die,
3243 struct dwarf2_cu *cu)
3245 struct objfile *objfile = cu->objfile;
3246 struct nextfield *new_field;
3247 struct attribute *attr;
3249 char *fieldname = "";
3251 /* Allocate a new field list entry and link it in. */
3252 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3253 make_cleanup (xfree, new_field);
3254 memset (new_field, 0, sizeof (struct nextfield));
3255 new_field->next = fip->fields;
3256 fip->fields = new_field;
3259 /* Handle accessibility and virtuality of field.
3260 The default accessibility for members is public, the default
3261 accessibility for inheritance is private. */
3262 if (die->tag != DW_TAG_inheritance)
3263 new_field->accessibility = DW_ACCESS_public;
3265 new_field->accessibility = DW_ACCESS_private;
3266 new_field->virtuality = DW_VIRTUALITY_none;
3268 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3270 new_field->accessibility = DW_UNSND (attr);
3271 if (new_field->accessibility != DW_ACCESS_public)
3272 fip->non_public_fields = 1;
3273 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
3275 new_field->virtuality = DW_UNSND (attr);
3277 fp = &new_field->field;
3279 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
3281 /* Data member other than a C++ static data member. */
3283 /* Get type of field. */
3284 fp->type = die_type (die, cu);
3286 FIELD_STATIC_KIND (*fp) = 0;
3288 /* Get bit size of field (zero if none). */
3289 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
3292 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
3296 FIELD_BITSIZE (*fp) = 0;
3299 /* Get bit offset of field. */
3300 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3303 FIELD_BITPOS (*fp) =
3304 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
3307 FIELD_BITPOS (*fp) = 0;
3308 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
3311 if (BITS_BIG_ENDIAN)
3313 /* For big endian bits, the DW_AT_bit_offset gives the
3314 additional bit offset from the MSB of the containing
3315 anonymous object to the MSB of the field. We don't
3316 have to do anything special since we don't need to
3317 know the size of the anonymous object. */
3318 FIELD_BITPOS (*fp) += DW_UNSND (attr);
3322 /* For little endian bits, compute the bit offset to the
3323 MSB of the anonymous object, subtract off the number of
3324 bits from the MSB of the field to the MSB of the
3325 object, and then subtract off the number of bits of
3326 the field itself. The result is the bit offset of
3327 the LSB of the field. */
3329 int bit_offset = DW_UNSND (attr);
3331 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3334 /* The size of the anonymous object containing
3335 the bit field is explicit, so use the
3336 indicated size (in bytes). */
3337 anonymous_size = DW_UNSND (attr);
3341 /* The size of the anonymous object containing
3342 the bit field must be inferred from the type
3343 attribute of the data member containing the
3345 anonymous_size = TYPE_LENGTH (fp->type);
3347 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
3348 - bit_offset - FIELD_BITSIZE (*fp);
3352 /* Get name of field. */
3353 attr = dwarf2_attr (die, DW_AT_name, cu);
3354 if (attr && DW_STRING (attr))
3355 fieldname = DW_STRING (attr);
3357 /* The name is already allocated along with this objfile, so we don't
3358 need to duplicate it for the type. */
3359 fp->name = fieldname;
3361 /* Change accessibility for artificial fields (e.g. virtual table
3362 pointer or virtual base class pointer) to private. */
3363 if (dwarf2_attr (die, DW_AT_artificial, cu))
3365 new_field->accessibility = DW_ACCESS_private;
3366 fip->non_public_fields = 1;
3369 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
3371 /* C++ static member. */
3373 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3374 is a declaration, but all versions of G++ as of this writing
3375 (so through at least 3.2.1) incorrectly generate
3376 DW_TAG_variable tags. */
3380 /* Get name of field. */
3381 attr = dwarf2_attr (die, DW_AT_name, cu);
3382 if (attr && DW_STRING (attr))
3383 fieldname = DW_STRING (attr);
3387 /* Get physical name. */
3388 physname = dwarf2_linkage_name (die, cu);
3390 /* The name is already allocated along with this objfile, so we don't
3391 need to duplicate it for the type. */
3392 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
3393 FIELD_TYPE (*fp) = die_type (die, cu);
3394 FIELD_NAME (*fp) = fieldname;
3396 else if (die->tag == DW_TAG_inheritance)
3398 /* C++ base class field. */
3399 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3401 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
3403 FIELD_BITSIZE (*fp) = 0;
3404 FIELD_STATIC_KIND (*fp) = 0;
3405 FIELD_TYPE (*fp) = die_type (die, cu);
3406 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
3407 fip->nbaseclasses++;
3411 /* Create the vector of fields, and attach it to the type. */
3414 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3415 struct dwarf2_cu *cu)
3417 int nfields = fip->nfields;
3419 /* Record the field count, allocate space for the array of fields,
3420 and create blank accessibility bitfields if necessary. */
3421 TYPE_NFIELDS (type) = nfields;
3422 TYPE_FIELDS (type) = (struct field *)
3423 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3424 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3426 if (fip->non_public_fields)
3428 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3430 TYPE_FIELD_PRIVATE_BITS (type) =
3431 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3432 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3434 TYPE_FIELD_PROTECTED_BITS (type) =
3435 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3436 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3438 TYPE_FIELD_IGNORE_BITS (type) =
3439 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3440 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3443 /* If the type has baseclasses, allocate and clear a bit vector for
3444 TYPE_FIELD_VIRTUAL_BITS. */
3445 if (fip->nbaseclasses)
3447 int num_bytes = B_BYTES (fip->nbaseclasses);
3450 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3451 pointer = (char *) TYPE_ALLOC (type, num_bytes);
3452 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3453 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3454 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3457 /* Copy the saved-up fields into the field vector. Start from the head
3458 of the list, adding to the tail of the field array, so that they end
3459 up in the same order in the array in which they were added to the list. */
3460 while (nfields-- > 0)
3462 TYPE_FIELD (type, nfields) = fip->fields->field;
3463 switch (fip->fields->accessibility)
3465 case DW_ACCESS_private:
3466 SET_TYPE_FIELD_PRIVATE (type, nfields);
3469 case DW_ACCESS_protected:
3470 SET_TYPE_FIELD_PROTECTED (type, nfields);
3473 case DW_ACCESS_public:
3477 /* Unknown accessibility. Complain and treat it as public. */
3479 complaint (&symfile_complaints, _("unsupported accessibility %d"),
3480 fip->fields->accessibility);
3484 if (nfields < fip->nbaseclasses)
3486 switch (fip->fields->virtuality)
3488 case DW_VIRTUALITY_virtual:
3489 case DW_VIRTUALITY_pure_virtual:
3490 SET_TYPE_FIELD_VIRTUAL (type, nfields);
3494 fip->fields = fip->fields->next;
3498 /* Add a member function to the proper fieldlist. */
3501 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3502 struct type *type, struct dwarf2_cu *cu)
3504 struct objfile *objfile = cu->objfile;
3505 struct attribute *attr;
3506 struct fnfieldlist *flp;
3508 struct fn_field *fnp;
3511 struct nextfnfield *new_fnfield;
3513 /* Get name of member function. */
3514 attr = dwarf2_attr (die, DW_AT_name, cu);
3515 if (attr && DW_STRING (attr))
3516 fieldname = DW_STRING (attr);
3520 /* Get the mangled name. */
3521 physname = dwarf2_linkage_name (die, cu);
3523 /* Look up member function name in fieldlist. */
3524 for (i = 0; i < fip->nfnfields; i++)
3526 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3530 /* Create new list element if necessary. */
3531 if (i < fip->nfnfields)
3532 flp = &fip->fnfieldlists[i];
3535 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3537 fip->fnfieldlists = (struct fnfieldlist *)
3538 xrealloc (fip->fnfieldlists,
3539 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3540 * sizeof (struct fnfieldlist));
3541 if (fip->nfnfields == 0)
3542 make_cleanup (free_current_contents, &fip->fnfieldlists);
3544 flp = &fip->fnfieldlists[fip->nfnfields];
3545 flp->name = fieldname;
3551 /* Create a new member function field and chain it to the field list
3553 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3554 make_cleanup (xfree, new_fnfield);
3555 memset (new_fnfield, 0, sizeof (struct nextfnfield));
3556 new_fnfield->next = flp->head;
3557 flp->head = new_fnfield;
3560 /* Fill in the member function field info. */
3561 fnp = &new_fnfield->fnfield;
3562 /* The name is already allocated along with this objfile, so we don't
3563 need to duplicate it for the type. */
3564 fnp->physname = physname ? physname : "";
3565 fnp->type = alloc_type (objfile);
3566 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3568 int nparams = TYPE_NFIELDS (die->type);
3570 /* TYPE is the domain of this method, and DIE->TYPE is the type
3571 of the method itself (TYPE_CODE_METHOD). */
3572 smash_to_method_type (fnp->type, type,
3573 TYPE_TARGET_TYPE (die->type),
3574 TYPE_FIELDS (die->type),
3575 TYPE_NFIELDS (die->type),
3576 TYPE_VARARGS (die->type));
3578 /* Handle static member functions.
3579 Dwarf2 has no clean way to discern C++ static and non-static
3580 member functions. G++ helps GDB by marking the first
3581 parameter for non-static member functions (which is the
3582 this pointer) as artificial. We obtain this information
3583 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3584 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3585 fnp->voffset = VOFFSET_STATIC;
3588 complaint (&symfile_complaints, _("member function type missing for '%s'"),
3591 /* Get fcontext from DW_AT_containing_type if present. */
3592 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3593 fnp->fcontext = die_containing_type (die, cu);
3595 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3596 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3598 /* Get accessibility. */
3599 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3602 switch (DW_UNSND (attr))
3604 case DW_ACCESS_private:
3605 fnp->is_private = 1;
3607 case DW_ACCESS_protected:
3608 fnp->is_protected = 1;
3613 /* Check for artificial methods. */
3614 attr = dwarf2_attr (die, DW_AT_artificial, cu);
3615 if (attr && DW_UNSND (attr) != 0)
3616 fnp->is_artificial = 1;
3618 /* Get index in virtual function table if it is a virtual member function. */
3619 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3622 /* Support the .debug_loc offsets */
3623 if (attr_form_is_block (attr))
3625 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3627 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3629 dwarf2_complex_location_expr_complaint ();
3633 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3639 /* Create the vector of member function fields, and attach it to the type. */
3642 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3643 struct dwarf2_cu *cu)
3645 struct fnfieldlist *flp;
3646 int total_length = 0;
3649 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3650 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3651 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3653 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3655 struct nextfnfield *nfp = flp->head;
3656 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3659 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3660 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3661 fn_flp->fn_fields = (struct fn_field *)
3662 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3663 for (k = flp->length; (k--, nfp); nfp = nfp->next)
3664 fn_flp->fn_fields[k] = nfp->fnfield;
3666 total_length += flp->length;
3669 TYPE_NFN_FIELDS (type) = fip->nfnfields;
3670 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3674 /* Returns non-zero if NAME is the name of a vtable member in CU's
3675 language, zero otherwise. */
3677 is_vtable_name (const char *name, struct dwarf2_cu *cu)
3679 static const char vptr[] = "_vptr";
3680 static const char vtable[] = "vtable";
3682 /* Look for the C++ and Java forms of the vtable. */
3683 if ((cu->language == language_java
3684 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
3685 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
3686 && is_cplus_marker (name[sizeof (vptr) - 1])))
3693 /* Called when we find the DIE that starts a structure or union scope
3694 (definition) to process all dies that define the members of the
3697 NOTE: we need to call struct_type regardless of whether or not the
3698 DIE has an at_name attribute, since it might be an anonymous
3699 structure or union. This gets the type entered into our set of
3702 However, if the structure is incomplete (an opaque struct/union)
3703 then suppress creating a symbol table entry for it since gdb only
3704 wants to find the one with the complete definition. Note that if
3705 it is complete, we just call new_symbol, which does it's own
3706 checking about whether the struct/union is anonymous or not (and
3707 suppresses creating a symbol table entry itself). */
3710 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3712 struct objfile *objfile = cu->objfile;
3714 struct attribute *attr;
3715 const char *previous_prefix = processing_current_prefix;
3716 struct cleanup *back_to = NULL;
3721 type = alloc_type (objfile);
3723 INIT_CPLUS_SPECIFIC (type);
3724 attr = dwarf2_attr (die, DW_AT_name, cu);
3725 if (attr && DW_STRING (attr))
3727 if (cu->language == language_cplus
3728 || cu->language == language_java)
3730 char *new_prefix = determine_class_name (die, cu);
3731 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3732 strlen (new_prefix),
3733 &objfile->objfile_obstack);
3734 back_to = make_cleanup (xfree, new_prefix);
3735 processing_current_prefix = new_prefix;
3739 /* The name is already allocated along with this objfile, so
3740 we don't need to duplicate it for the type. */
3741 TYPE_TAG_NAME (type) = DW_STRING (attr);
3745 if (die->tag == DW_TAG_structure_type)
3747 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3749 else if (die->tag == DW_TAG_union_type)
3751 TYPE_CODE (type) = TYPE_CODE_UNION;
3755 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3757 TYPE_CODE (type) = TYPE_CODE_CLASS;
3760 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3763 TYPE_LENGTH (type) = DW_UNSND (attr);
3767 TYPE_LENGTH (type) = 0;
3770 if (die_is_declaration (die, cu))
3771 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3773 /* We need to add the type field to the die immediately so we don't
3774 infinitely recurse when dealing with pointers to the structure
3775 type within the structure itself. */
3776 set_die_type (die, type, cu);
3778 if (die->child != NULL && ! die_is_declaration (die, cu))
3780 struct field_info fi;
3781 struct die_info *child_die;
3782 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3784 memset (&fi, 0, sizeof (struct field_info));
3786 child_die = die->child;
3788 while (child_die && child_die->tag)
3790 if (child_die->tag == DW_TAG_member
3791 || child_die->tag == DW_TAG_variable)
3793 /* NOTE: carlton/2002-11-05: A C++ static data member
3794 should be a DW_TAG_member that is a declaration, but
3795 all versions of G++ as of this writing (so through at
3796 least 3.2.1) incorrectly generate DW_TAG_variable
3797 tags for them instead. */
3798 dwarf2_add_field (&fi, child_die, cu);
3800 else if (child_die->tag == DW_TAG_subprogram)
3802 /* C++ member function. */
3803 read_type_die (child_die, cu);
3804 dwarf2_add_member_fn (&fi, child_die, type, cu);
3806 else if (child_die->tag == DW_TAG_inheritance)
3808 /* C++ base class field. */
3809 dwarf2_add_field (&fi, child_die, cu);
3811 child_die = sibling_die (child_die);
3814 /* Attach fields and member functions to the type. */
3816 dwarf2_attach_fields_to_type (&fi, type, cu);
3819 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3821 /* Get the type which refers to the base class (possibly this
3822 class itself) which contains the vtable pointer for the current
3823 class from the DW_AT_containing_type attribute. */
3825 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3827 struct type *t = die_containing_type (die, cu);
3829 TYPE_VPTR_BASETYPE (type) = t;
3834 /* Our own class provides vtbl ptr. */
3835 for (i = TYPE_NFIELDS (t) - 1;
3836 i >= TYPE_N_BASECLASSES (t);
3839 char *fieldname = TYPE_FIELD_NAME (t, i);
3841 if (is_vtable_name (fieldname, cu))
3843 TYPE_VPTR_FIELDNO (type) = i;
3848 /* Complain if virtual function table field not found. */
3849 if (i < TYPE_N_BASECLASSES (t))
3850 complaint (&symfile_complaints,
3851 _("virtual function table pointer not found when defining class '%s'"),
3852 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3857 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3860 else if (cu->producer
3861 && strncmp (cu->producer,
3862 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3864 /* The IBM XLC compiler does not provide direct indication
3865 of the containing type, but the vtable pointer is
3866 always named __vfp. */
3870 for (i = TYPE_NFIELDS (type) - 1;
3871 i >= TYPE_N_BASECLASSES (type);
3874 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
3876 TYPE_VPTR_FIELDNO (type) = i;
3877 TYPE_VPTR_BASETYPE (type) = type;
3884 do_cleanups (back_to);
3887 processing_current_prefix = previous_prefix;
3888 if (back_to != NULL)
3889 do_cleanups (back_to);
3893 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3895 struct objfile *objfile = cu->objfile;
3896 const char *previous_prefix = processing_current_prefix;
3897 struct die_info *child_die = die->child;
3899 if (TYPE_TAG_NAME (die->type) != NULL)
3900 processing_current_prefix = TYPE_TAG_NAME (die->type);
3902 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3903 snapshots) has been known to create a die giving a declaration
3904 for a class that has, as a child, a die giving a definition for a
3905 nested class. So we have to process our children even if the
3906 current die is a declaration. Normally, of course, a declaration
3907 won't have any children at all. */
3909 while (child_die != NULL && child_die->tag)
3911 if (child_die->tag == DW_TAG_member
3912 || child_die->tag == DW_TAG_variable
3913 || child_die->tag == DW_TAG_inheritance)
3918 process_die (child_die, cu);
3920 child_die = sibling_die (child_die);
3923 if (die->child != NULL && ! die_is_declaration (die, cu))
3924 new_symbol (die, die->type, cu);
3926 processing_current_prefix = previous_prefix;
3929 /* Given a DW_AT_enumeration_type die, set its type. We do not
3930 complete the type's fields yet, or create any symbols. */
3933 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
3935 struct objfile *objfile = cu->objfile;
3937 struct attribute *attr;
3942 type = alloc_type (objfile);
3944 TYPE_CODE (type) = TYPE_CODE_ENUM;
3945 attr = dwarf2_attr (die, DW_AT_name, cu);
3946 if (attr && DW_STRING (attr))
3948 char *name = DW_STRING (attr);
3950 if (processing_has_namespace_info)
3952 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
3953 processing_current_prefix,
3958 /* The name is already allocated along with this objfile, so
3959 we don't need to duplicate it for the type. */
3960 TYPE_TAG_NAME (type) = name;
3964 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3967 TYPE_LENGTH (type) = DW_UNSND (attr);
3971 TYPE_LENGTH (type) = 0;
3974 set_die_type (die, type, cu);
3977 /* Determine the name of the type represented by DIE, which should be
3978 a named C++ or Java compound type. Return the name in question; the caller
3979 is responsible for xfree()'ing it. */
3982 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
3984 struct cleanup *back_to = NULL;
3985 struct die_info *spec_die = die_specification (die, cu);
3986 char *new_prefix = NULL;
3988 /* If this is the definition of a class that is declared by another
3989 die, then processing_current_prefix may not be accurate; see
3990 read_func_scope for a similar example. */
3991 if (spec_die != NULL)
3993 char *specification_prefix = determine_prefix (spec_die, cu);
3994 processing_current_prefix = specification_prefix;
3995 back_to = make_cleanup (xfree, specification_prefix);
3998 /* If we don't have namespace debug info, guess the name by trying
3999 to demangle the names of members, just like we did in
4000 guess_structure_name. */
4001 if (!processing_has_namespace_info)
4003 struct die_info *child;
4005 for (child = die->child;
4006 child != NULL && child->tag != 0;
4007 child = sibling_die (child))
4009 if (child->tag == DW_TAG_subprogram)
4012 = language_class_name_from_physname (cu->language_defn,
4016 if (new_prefix != NULL)
4022 if (new_prefix == NULL)
4024 const char *name = dwarf2_name (die, cu);
4025 new_prefix = typename_concat (NULL, processing_current_prefix,
4026 name ? name : "<<anonymous>>",
4030 if (back_to != NULL)
4031 do_cleanups (back_to);
4036 /* Given a pointer to a die which begins an enumeration, process all
4037 the dies that define the members of the enumeration, and create the
4038 symbol for the enumeration type.
4040 NOTE: We reverse the order of the element list. */
4043 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4045 struct objfile *objfile = cu->objfile;
4046 struct die_info *child_die;
4047 struct field *fields;
4048 struct attribute *attr;
4051 int unsigned_enum = 1;
4055 if (die->child != NULL)
4057 child_die = die->child;
4058 while (child_die && child_die->tag)
4060 if (child_die->tag != DW_TAG_enumerator)
4062 process_die (child_die, cu);
4066 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4069 sym = new_symbol (child_die, die->type, cu);
4070 if (SYMBOL_VALUE (sym) < 0)
4073 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4075 fields = (struct field *)
4077 (num_fields + DW_FIELD_ALLOC_CHUNK)
4078 * sizeof (struct field));
4081 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4082 FIELD_TYPE (fields[num_fields]) = NULL;
4083 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4084 FIELD_BITSIZE (fields[num_fields]) = 0;
4085 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4091 child_die = sibling_die (child_die);
4096 TYPE_NFIELDS (die->type) = num_fields;
4097 TYPE_FIELDS (die->type) = (struct field *)
4098 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4099 memcpy (TYPE_FIELDS (die->type), fields,
4100 sizeof (struct field) * num_fields);
4104 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4107 new_symbol (die, die->type, cu);
4110 /* Extract all information from a DW_TAG_array_type DIE and put it in
4111 the DIE's type field. For now, this only handles one dimensional
4115 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4117 struct objfile *objfile = cu->objfile;
4118 struct die_info *child_die;
4119 struct type *type = NULL;
4120 struct type *element_type, *range_type, *index_type;
4121 struct type **range_types = NULL;
4122 struct attribute *attr;
4124 struct cleanup *back_to;
4126 /* Return if we've already decoded this type. */
4132 element_type = die_type (die, cu);
4134 /* Irix 6.2 native cc creates array types without children for
4135 arrays with unspecified length. */
4136 if (die->child == NULL)
4138 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4139 range_type = create_range_type (NULL, index_type, 0, -1);
4140 set_die_type (die, create_array_type (NULL, element_type, range_type),
4145 back_to = make_cleanup (null_cleanup, NULL);
4146 child_die = die->child;
4147 while (child_die && child_die->tag)
4149 if (child_die->tag == DW_TAG_subrange_type)
4151 read_subrange_type (child_die, cu);
4153 if (child_die->type != NULL)
4155 /* The range type was succesfully read. Save it for
4156 the array type creation. */
4157 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4159 range_types = (struct type **)
4160 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4161 * sizeof (struct type *));
4163 make_cleanup (free_current_contents, &range_types);
4165 range_types[ndim++] = child_die->type;
4168 child_die = sibling_die (child_die);
4171 /* Dwarf2 dimensions are output from left to right, create the
4172 necessary array types in backwards order. */
4174 type = element_type;
4176 if (read_array_order (die, cu) == DW_ORD_col_major)
4180 type = create_array_type (NULL, type, range_types[i++]);
4185 type = create_array_type (NULL, type, range_types[ndim]);
4188 /* Understand Dwarf2 support for vector types (like they occur on
4189 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4190 array type. This is not part of the Dwarf2/3 standard yet, but a
4191 custom vendor extension. The main difference between a regular
4192 array and the vector variant is that vectors are passed by value
4194 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4196 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4198 do_cleanups (back_to);
4200 /* Install the type in the die. */
4201 set_die_type (die, type, cu);
4204 static enum dwarf_array_dim_ordering
4205 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4207 struct attribute *attr;
4209 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4211 if (attr) return DW_SND (attr);
4214 GNU F77 is a special case, as at 08/2004 array type info is the
4215 opposite order to the dwarf2 specification, but data is still
4216 laid out as per normal fortran.
4218 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4222 if (cu->language == language_fortran &&
4223 cu->producer && strstr (cu->producer, "GNU F77"))
4225 return DW_ORD_row_major;
4228 switch (cu->language_defn->la_array_ordering)
4230 case array_column_major:
4231 return DW_ORD_col_major;
4232 case array_row_major:
4234 return DW_ORD_row_major;
4239 /* First cut: install each common block member as a global variable. */
4242 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4244 struct die_info *child_die;
4245 struct attribute *attr;
4247 CORE_ADDR base = (CORE_ADDR) 0;
4249 attr = dwarf2_attr (die, DW_AT_location, cu);
4252 /* Support the .debug_loc offsets */
4253 if (attr_form_is_block (attr))
4255 base = decode_locdesc (DW_BLOCK (attr), cu);
4257 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4259 dwarf2_complex_location_expr_complaint ();
4263 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4264 "common block member");
4267 if (die->child != NULL)
4269 child_die = die->child;
4270 while (child_die && child_die->tag)
4272 sym = new_symbol (child_die, NULL, cu);
4273 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4276 SYMBOL_VALUE_ADDRESS (sym) =
4277 base + decode_locdesc (DW_BLOCK (attr), cu);
4278 add_symbol_to_list (sym, &global_symbols);
4280 child_die = sibling_die (child_die);
4285 /* Read a C++ namespace. */
4288 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4290 struct objfile *objfile = cu->objfile;
4291 const char *previous_prefix = processing_current_prefix;
4294 struct die_info *current_die;
4295 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4297 name = namespace_name (die, &is_anonymous, cu);
4299 /* Now build the name of the current namespace. */
4301 if (previous_prefix[0] == '\0')
4303 processing_current_prefix = name;
4307 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4308 make_cleanup (xfree, temp_name);
4309 processing_current_prefix = temp_name;
4312 /* Add a symbol associated to this if we haven't seen the namespace
4313 before. Also, add a using directive if it's an anonymous
4316 if (dwarf2_extension (die, cu) == NULL)
4320 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4321 this cast will hopefully become unnecessary. */
4322 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4323 (char *) processing_current_prefix,
4325 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4327 new_symbol (die, type, cu);
4328 set_die_type (die, type, cu);
4331 cp_add_using_directive (processing_current_prefix,
4332 strlen (previous_prefix),
4333 strlen (processing_current_prefix));
4336 if (die->child != NULL)
4338 struct die_info *child_die = die->child;
4340 while (child_die && child_die->tag)
4342 process_die (child_die, cu);
4343 child_die = sibling_die (child_die);
4347 processing_current_prefix = previous_prefix;
4348 do_cleanups (back_to);
4351 /* Return the name of the namespace represented by DIE. Set
4352 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4356 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4358 struct die_info *current_die;
4359 const char *name = NULL;
4361 /* Loop through the extensions until we find a name. */
4363 for (current_die = die;
4364 current_die != NULL;
4365 current_die = dwarf2_extension (die, cu))
4367 name = dwarf2_name (current_die, cu);
4372 /* Is it an anonymous namespace? */
4374 *is_anonymous = (name == NULL);
4376 name = "(anonymous namespace)";
4381 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4382 the user defined type vector. */
4385 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4387 struct comp_unit_head *cu_header = &cu->header;
4389 struct attribute *attr_byte_size;
4390 struct attribute *attr_address_class;
4391 int byte_size, addr_class;
4398 type = lookup_pointer_type (die_type (die, cu));
4400 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4402 byte_size = DW_UNSND (attr_byte_size);
4404 byte_size = cu_header->addr_size;
4406 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4407 if (attr_address_class)
4408 addr_class = DW_UNSND (attr_address_class);
4410 addr_class = DW_ADDR_none;
4412 /* If the pointer size or address class is different than the
4413 default, create a type variant marked as such and set the
4414 length accordingly. */
4415 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4417 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4421 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
4422 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4423 type = make_type_with_address_space (type, type_flags);
4425 else if (TYPE_LENGTH (type) != byte_size)
4427 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4430 /* Should we also complain about unhandled address classes? */
4434 TYPE_LENGTH (type) = byte_size;
4435 set_die_type (die, type, cu);
4438 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4439 the user defined type vector. */
4442 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4444 struct objfile *objfile = cu->objfile;
4446 struct type *to_type;
4447 struct type *domain;
4454 type = alloc_type (objfile);
4455 to_type = die_type (die, cu);
4456 domain = die_containing_type (die, cu);
4457 smash_to_member_type (type, domain, to_type);
4459 set_die_type (die, type, cu);
4462 /* Extract all information from a DW_TAG_reference_type DIE and add to
4463 the user defined type vector. */
4466 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4468 struct comp_unit_head *cu_header = &cu->header;
4470 struct attribute *attr;
4477 type = lookup_reference_type (die_type (die, cu));
4478 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4481 TYPE_LENGTH (type) = DW_UNSND (attr);
4485 TYPE_LENGTH (type) = cu_header->addr_size;
4487 set_die_type (die, type, cu);
4491 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4493 struct type *base_type;
4500 base_type = die_type (die, cu);
4501 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4506 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4508 struct type *base_type;
4515 base_type = die_type (die, cu);
4516 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4520 /* Extract all information from a DW_TAG_string_type DIE and add to
4521 the user defined type vector. It isn't really a user defined type,
4522 but it behaves like one, with other DIE's using an AT_user_def_type
4523 attribute to reference it. */
4526 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4528 struct objfile *objfile = cu->objfile;
4529 struct type *type, *range_type, *index_type, *char_type;
4530 struct attribute *attr;
4531 unsigned int length;
4538 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4541 length = DW_UNSND (attr);
4545 /* check for the DW_AT_byte_size attribute */
4546 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4549 length = DW_UNSND (attr);
4556 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4557 range_type = create_range_type (NULL, index_type, 1, length);
4558 if (cu->language == language_fortran)
4560 /* Need to create a unique string type for bounds
4562 type = create_string_type (0, range_type);
4566 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4567 type = create_string_type (char_type, range_type);
4569 set_die_type (die, type, cu);
4572 /* Handle DIES due to C code like:
4576 int (*funcp)(int a, long l);
4580 ('funcp' generates a DW_TAG_subroutine_type DIE)
4584 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4586 struct type *type; /* Type that this function returns */
4587 struct type *ftype; /* Function that returns above type */
4588 struct attribute *attr;
4590 /* Decode the type that this subroutine returns */
4595 type = die_type (die, cu);
4596 ftype = make_function_type (type, (struct type **) 0);
4598 /* All functions in C++ and Java have prototypes. */
4599 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4600 if ((attr && (DW_UNSND (attr) != 0))
4601 || cu->language == language_cplus
4602 || cu->language == language_java)
4603 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4605 if (die->child != NULL)
4607 struct die_info *child_die;
4611 /* Count the number of parameters.
4612 FIXME: GDB currently ignores vararg functions, but knows about
4613 vararg member functions. */
4614 child_die = die->child;
4615 while (child_die && child_die->tag)
4617 if (child_die->tag == DW_TAG_formal_parameter)
4619 else if (child_die->tag == DW_TAG_unspecified_parameters)
4620 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4621 child_die = sibling_die (child_die);
4624 /* Allocate storage for parameters and fill them in. */
4625 TYPE_NFIELDS (ftype) = nparams;
4626 TYPE_FIELDS (ftype) = (struct field *)
4627 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
4629 child_die = die->child;
4630 while (child_die && child_die->tag)
4632 if (child_die->tag == DW_TAG_formal_parameter)
4634 /* Dwarf2 has no clean way to discern C++ static and non-static
4635 member functions. G++ helps GDB by marking the first
4636 parameter for non-static member functions (which is the
4637 this pointer) as artificial. We pass this information
4638 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4639 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4641 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4643 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4644 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4647 child_die = sibling_die (child_die);
4651 set_die_type (die, ftype, cu);
4655 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4657 struct objfile *objfile = cu->objfile;
4658 struct attribute *attr;
4663 attr = dwarf2_attr (die, DW_AT_name, cu);
4664 if (attr && DW_STRING (attr))
4666 name = DW_STRING (attr);
4668 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4669 TYPE_FLAG_TARGET_STUB, name, objfile),
4671 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4675 /* Find a representation of a given base type and install
4676 it in the TYPE field of the die. */
4679 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4681 struct objfile *objfile = cu->objfile;
4683 struct attribute *attr;
4684 int encoding = 0, size = 0;
4686 /* If we've already decoded this die, this is a no-op. */
4692 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4695 encoding = DW_UNSND (attr);
4697 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4700 size = DW_UNSND (attr);
4702 attr = dwarf2_attr (die, DW_AT_name, cu);
4703 if (attr && DW_STRING (attr))
4705 enum type_code code = TYPE_CODE_INT;
4710 case DW_ATE_address:
4711 /* Turn DW_ATE_address into a void * pointer. */
4712 code = TYPE_CODE_PTR;
4713 type_flags |= TYPE_FLAG_UNSIGNED;
4715 case DW_ATE_boolean:
4716 code = TYPE_CODE_BOOL;
4717 type_flags |= TYPE_FLAG_UNSIGNED;
4719 case DW_ATE_complex_float:
4720 code = TYPE_CODE_COMPLEX;
4723 code = TYPE_CODE_FLT;
4726 case DW_ATE_signed_char:
4728 case DW_ATE_unsigned:
4729 case DW_ATE_unsigned_char:
4730 type_flags |= TYPE_FLAG_UNSIGNED;
4733 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4734 dwarf_type_encoding_name (encoding));
4737 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4738 if (encoding == DW_ATE_address)
4739 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4741 else if (encoding == DW_ATE_complex_float)
4744 TYPE_TARGET_TYPE (type)
4745 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4746 else if (size == 16)
4747 TYPE_TARGET_TYPE (type)
4748 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4750 TYPE_TARGET_TYPE (type)
4751 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4756 type = dwarf_base_type (encoding, size, cu);
4758 set_die_type (die, type, cu);
4761 /* Read the given DW_AT_subrange DIE. */
4764 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4766 struct type *base_type;
4767 struct type *range_type;
4768 struct attribute *attr;
4772 /* If we have already decoded this die, then nothing more to do. */
4776 base_type = die_type (die, cu);
4777 if (base_type == NULL)
4779 complaint (&symfile_complaints,
4780 _("DW_AT_type missing from DW_TAG_subrange_type"));
4784 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4785 base_type = alloc_type (NULL);
4787 if (cu->language == language_fortran)
4789 /* FORTRAN implies a lower bound of 1, if not given. */
4793 /* FIXME: For variable sized arrays either of these could be
4794 a variable rather than a constant value. We'll allow it,
4795 but we don't know how to handle it. */
4796 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4798 low = dwarf2_get_attr_constant_value (attr, 0);
4800 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4803 if (attr->form == DW_FORM_block1)
4805 /* GCC encodes arrays with unspecified or dynamic length
4806 with a DW_FORM_block1 attribute.
4807 FIXME: GDB does not yet know how to handle dynamic
4808 arrays properly, treat them as arrays with unspecified
4811 FIXME: jimb/2003-09-22: GDB does not really know
4812 how to handle arrays of unspecified length
4813 either; we just represent them as zero-length
4814 arrays. Choose an appropriate upper bound given
4815 the lower bound we've computed above. */
4819 high = dwarf2_get_attr_constant_value (attr, 1);
4822 range_type = create_range_type (NULL, base_type, low, high);
4824 attr = dwarf2_attr (die, DW_AT_name, cu);
4825 if (attr && DW_STRING (attr))
4826 TYPE_NAME (range_type) = DW_STRING (attr);
4828 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4830 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4832 set_die_type (die, range_type, cu);
4836 /* Read a whole compilation unit into a linked list of dies. */
4838 static struct die_info *
4839 read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4841 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4844 /* Read a single die and all its descendents. Set the die's sibling
4845 field to NULL; set other fields in the die correctly, and set all
4846 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4847 location of the info_ptr after reading all of those dies. PARENT
4848 is the parent of the die in question. */
4850 static struct die_info *
4851 read_die_and_children (char *info_ptr, bfd *abfd,
4852 struct dwarf2_cu *cu,
4853 char **new_info_ptr,
4854 struct die_info *parent)
4856 struct die_info *die;
4860 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4861 store_in_ref_table (die->offset, die, cu);
4865 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4871 *new_info_ptr = cur_ptr;
4874 die->sibling = NULL;
4875 die->parent = parent;
4879 /* Read a die, all of its descendents, and all of its siblings; set
4880 all of the fields of all of the dies correctly. Arguments are as
4881 in read_die_and_children. */
4883 static struct die_info *
4884 read_die_and_siblings (char *info_ptr, bfd *abfd,
4885 struct dwarf2_cu *cu,
4886 char **new_info_ptr,
4887 struct die_info *parent)
4889 struct die_info *first_die, *last_sibling;
4893 first_die = last_sibling = NULL;
4897 struct die_info *die
4898 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
4906 last_sibling->sibling = die;
4911 *new_info_ptr = cur_ptr;
4921 /* Free a linked list of dies. */
4924 free_die_list (struct die_info *dies)
4926 struct die_info *die, *next;
4931 if (die->child != NULL)
4932 free_die_list (die->child);
4933 next = die->sibling;
4940 /* Read the contents of the section at OFFSET and of size SIZE from the
4941 object file specified by OBJFILE into the objfile_obstack and return it. */
4944 dwarf2_read_section (struct objfile *objfile, asection *sectp)
4946 bfd *abfd = objfile->obfd;
4948 bfd_size_type size = bfd_get_section_size (sectp);
4953 buf = (char *) obstack_alloc (&objfile->objfile_obstack, size);
4955 = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf);
4959 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
4960 || bfd_bread (buf, size, abfd) != size)
4961 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4962 bfd_get_filename (abfd));
4967 /* In DWARF version 2, the description of the debugging information is
4968 stored in a separate .debug_abbrev section. Before we read any
4969 dies from a section we read in all abbreviations and install them
4970 in a hash table. This function also sets flags in CU describing
4971 the data found in the abbrev table. */
4974 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
4976 struct comp_unit_head *cu_header = &cu->header;
4978 struct abbrev_info *cur_abbrev;
4979 unsigned int abbrev_number, bytes_read, abbrev_name;
4980 unsigned int abbrev_form, hash_number;
4981 struct attr_abbrev *cur_attrs;
4982 unsigned int allocated_attrs;
4984 /* Initialize dwarf2 abbrevs */
4985 obstack_init (&cu->abbrev_obstack);
4986 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
4988 * sizeof (struct abbrev_info *)));
4989 memset (cu->dwarf2_abbrevs, 0,
4990 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
4992 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
4993 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4994 abbrev_ptr += bytes_read;
4996 allocated_attrs = ATTR_ALLOC_CHUNK;
4997 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
4999 /* loop until we reach an abbrev number of 0 */
5000 while (abbrev_number)
5002 cur_abbrev = dwarf_alloc_abbrev (cu);
5004 /* read in abbrev header */
5005 cur_abbrev->number = abbrev_number;
5006 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5007 abbrev_ptr += bytes_read;
5008 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5011 if (cur_abbrev->tag == DW_TAG_namespace)
5012 cu->has_namespace_info = 1;
5014 /* now read in declarations */
5015 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5016 abbrev_ptr += bytes_read;
5017 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5018 abbrev_ptr += bytes_read;
5021 if (cur_abbrev->num_attrs == allocated_attrs)
5023 allocated_attrs += ATTR_ALLOC_CHUNK;
5025 = xrealloc (cur_attrs, (allocated_attrs
5026 * sizeof (struct attr_abbrev)));
5029 /* Record whether this compilation unit might have
5030 inter-compilation-unit references. If we don't know what form
5031 this attribute will have, then it might potentially be a
5032 DW_FORM_ref_addr, so we conservatively expect inter-CU
5035 if (abbrev_form == DW_FORM_ref_addr
5036 || abbrev_form == DW_FORM_indirect)
5037 cu->has_form_ref_addr = 1;
5039 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5040 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5041 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5042 abbrev_ptr += bytes_read;
5043 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5044 abbrev_ptr += bytes_read;
5047 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5048 (cur_abbrev->num_attrs
5049 * sizeof (struct attr_abbrev)));
5050 memcpy (cur_abbrev->attrs, cur_attrs,
5051 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5053 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5054 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5055 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5057 /* Get next abbreviation.
5058 Under Irix6 the abbreviations for a compilation unit are not
5059 always properly terminated with an abbrev number of 0.
5060 Exit loop if we encounter an abbreviation which we have
5061 already read (which means we are about to read the abbreviations
5062 for the next compile unit) or if the end of the abbreviation
5063 table is reached. */
5064 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5065 >= dwarf2_per_objfile->abbrev_size)
5067 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5068 abbrev_ptr += bytes_read;
5069 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5076 /* Release the memory used by the abbrev table for a compilation unit. */
5079 dwarf2_free_abbrev_table (void *ptr_to_cu)
5081 struct dwarf2_cu *cu = ptr_to_cu;
5083 obstack_free (&cu->abbrev_obstack, NULL);
5084 cu->dwarf2_abbrevs = NULL;
5087 /* Lookup an abbrev_info structure in the abbrev hash table. */
5089 static struct abbrev_info *
5090 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5092 unsigned int hash_number;
5093 struct abbrev_info *abbrev;
5095 hash_number = number % ABBREV_HASH_SIZE;
5096 abbrev = cu->dwarf2_abbrevs[hash_number];
5100 if (abbrev->number == number)
5103 abbrev = abbrev->next;
5108 /* Returns nonzero if TAG represents a type that we might generate a partial
5112 is_type_tag_for_partial (int tag)
5117 /* Some types that would be reasonable to generate partial symbols for,
5118 that we don't at present. */
5119 case DW_TAG_array_type:
5120 case DW_TAG_file_type:
5121 case DW_TAG_ptr_to_member_type:
5122 case DW_TAG_set_type:
5123 case DW_TAG_string_type:
5124 case DW_TAG_subroutine_type:
5126 case DW_TAG_base_type:
5127 case DW_TAG_class_type:
5128 case DW_TAG_enumeration_type:
5129 case DW_TAG_structure_type:
5130 case DW_TAG_subrange_type:
5131 case DW_TAG_typedef:
5132 case DW_TAG_union_type:
5139 /* Load all DIEs that are interesting for partial symbols into memory. */
5141 static struct partial_die_info *
5142 load_partial_dies (bfd *abfd, char *info_ptr, int building_psymtab,
5143 struct dwarf2_cu *cu)
5145 struct partial_die_info *part_die;
5146 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5147 struct abbrev_info *abbrev;
5148 unsigned int bytes_read;
5150 int nesting_level = 1;
5156 = htab_create_alloc_ex (cu->header.length / 12,
5160 &cu->comp_unit_obstack,
5161 hashtab_obstack_allocate,
5162 dummy_obstack_deallocate);
5164 part_die = obstack_alloc (&cu->comp_unit_obstack,
5165 sizeof (struct partial_die_info));
5169 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5171 /* A NULL abbrev means the end of a series of children. */
5174 if (--nesting_level == 0)
5176 /* PART_DIE was probably the last thing allocated on the
5177 comp_unit_obstack, so we could call obstack_free
5178 here. We don't do that because the waste is small,
5179 and will be cleaned up when we're done with this
5180 compilation unit. This way, we're also more robust
5181 against other users of the comp_unit_obstack. */
5184 info_ptr += bytes_read;
5185 last_die = parent_die;
5186 parent_die = parent_die->die_parent;
5190 /* Check whether this DIE is interesting enough to save. */
5191 if (!is_type_tag_for_partial (abbrev->tag)
5192 && abbrev->tag != DW_TAG_enumerator
5193 && abbrev->tag != DW_TAG_subprogram
5194 && abbrev->tag != DW_TAG_variable
5195 && abbrev->tag != DW_TAG_namespace)
5197 /* Otherwise we skip to the next sibling, if any. */
5198 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5202 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5203 abfd, info_ptr, cu);
5205 /* This two-pass algorithm for processing partial symbols has a
5206 high cost in cache pressure. Thus, handle some simple cases
5207 here which cover the majority of C partial symbols. DIEs
5208 which neither have specification tags in them, nor could have
5209 specification tags elsewhere pointing at them, can simply be
5210 processed and discarded.
5212 This segment is also optional; scan_partial_symbols and
5213 add_partial_symbol will handle these DIEs if we chain
5214 them in normally. When compilers which do not emit large
5215 quantities of duplicate debug information are more common,
5216 this code can probably be removed. */
5218 /* Any complete simple types at the top level (pretty much all
5219 of them, for a language without namespaces), can be processed
5221 if (parent_die == NULL
5222 && part_die->has_specification == 0
5223 && part_die->is_declaration == 0
5224 && (part_die->tag == DW_TAG_typedef
5225 || part_die->tag == DW_TAG_base_type
5226 || part_die->tag == DW_TAG_subrange_type))
5228 if (building_psymtab && part_die->name != NULL)
5229 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5230 VAR_DOMAIN, LOC_TYPEDEF,
5231 &cu->objfile->static_psymbols,
5232 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5233 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5237 /* If we're at the second level, and we're an enumerator, and
5238 our parent has no specification (meaning possibly lives in a
5239 namespace elsewhere), then we can add the partial symbol now
5240 instead of queueing it. */
5241 if (part_die->tag == DW_TAG_enumerator
5242 && parent_die != NULL
5243 && parent_die->die_parent == NULL
5244 && parent_die->tag == DW_TAG_enumeration_type
5245 && parent_die->has_specification == 0)
5247 if (part_die->name == NULL)
5248 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5249 else if (building_psymtab)
5250 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5251 VAR_DOMAIN, LOC_CONST,
5252 (cu->language == language_cplus
5253 || cu->language == language_java)
5254 ? &cu->objfile->global_psymbols
5255 : &cu->objfile->static_psymbols,
5256 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5258 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5262 /* We'll save this DIE so link it in. */
5263 part_die->die_parent = parent_die;
5264 part_die->die_sibling = NULL;
5265 part_die->die_child = NULL;
5267 if (last_die && last_die == parent_die)
5268 last_die->die_child = part_die;
5270 last_die->die_sibling = part_die;
5272 last_die = part_die;
5274 if (first_die == NULL)
5275 first_die = part_die;
5277 /* Maybe add the DIE to the hash table. Not all DIEs that we
5278 find interesting need to be in the hash table, because we
5279 also have the parent/sibling/child chains; only those that we
5280 might refer to by offset later during partial symbol reading.
5282 For now this means things that might have be the target of a
5283 DW_AT_specification, DW_AT_abstract_origin, or
5284 DW_AT_extension. DW_AT_extension will refer only to
5285 namespaces; DW_AT_abstract_origin refers to functions (and
5286 many things under the function DIE, but we do not recurse
5287 into function DIEs during partial symbol reading) and
5288 possibly variables as well; DW_AT_specification refers to
5289 declarations. Declarations ought to have the DW_AT_declaration
5290 flag. It happens that GCC forgets to put it in sometimes, but
5291 only for functions, not for types.
5293 Adding more things than necessary to the hash table is harmless
5294 except for the performance cost. Adding too few will result in
5295 internal errors in find_partial_die. */
5297 if (abbrev->tag == DW_TAG_subprogram
5298 || abbrev->tag == DW_TAG_variable
5299 || abbrev->tag == DW_TAG_namespace
5300 || part_die->is_declaration)
5304 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5305 part_die->offset, INSERT);
5309 part_die = obstack_alloc (&cu->comp_unit_obstack,
5310 sizeof (struct partial_die_info));
5312 /* For some DIEs we want to follow their children (if any). For C
5313 we have no reason to follow the children of structures; for other
5314 languages we have to, both so that we can get at method physnames
5315 to infer fully qualified class names, and for DW_AT_specification. */
5316 if (last_die->has_children
5317 && (last_die->tag == DW_TAG_namespace
5318 || last_die->tag == DW_TAG_enumeration_type
5319 || (cu->language != language_c
5320 && (last_die->tag == DW_TAG_class_type
5321 || last_die->tag == DW_TAG_structure_type
5322 || last_die->tag == DW_TAG_union_type))))
5325 parent_die = last_die;
5329 /* Otherwise we skip to the next sibling, if any. */
5330 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5332 /* Back to the top, do it again. */
5336 /* Read a minimal amount of information into the minimal die structure. */
5339 read_partial_die (struct partial_die_info *part_die,
5340 struct abbrev_info *abbrev,
5341 unsigned int abbrev_len, bfd *abfd,
5342 char *info_ptr, struct dwarf2_cu *cu)
5344 unsigned int bytes_read, i;
5345 struct attribute attr;
5346 int has_low_pc_attr = 0;
5347 int has_high_pc_attr = 0;
5349 memset (part_die, 0, sizeof (struct partial_die_info));
5351 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5353 info_ptr += abbrev_len;
5358 part_die->tag = abbrev->tag;
5359 part_die->has_children = abbrev->has_children;
5361 for (i = 0; i < abbrev->num_attrs; ++i)
5363 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5365 /* Store the data if it is of an attribute we want to keep in a
5366 partial symbol table. */
5371 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5372 if (part_die->name == NULL)
5373 part_die->name = DW_STRING (&attr);
5375 case DW_AT_comp_dir:
5376 if (part_die->dirname == NULL)
5377 part_die->dirname = DW_STRING (&attr);
5379 case DW_AT_MIPS_linkage_name:
5380 part_die->name = DW_STRING (&attr);
5383 has_low_pc_attr = 1;
5384 part_die->lowpc = DW_ADDR (&attr);
5387 has_high_pc_attr = 1;
5388 part_die->highpc = DW_ADDR (&attr);
5390 case DW_AT_location:
5391 /* Support the .debug_loc offsets */
5392 if (attr_form_is_block (&attr))
5394 part_die->locdesc = DW_BLOCK (&attr);
5396 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5398 dwarf2_complex_location_expr_complaint ();
5402 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5403 "partial symbol information");
5406 case DW_AT_language:
5407 part_die->language = DW_UNSND (&attr);
5409 case DW_AT_external:
5410 part_die->is_external = DW_UNSND (&attr);
5412 case DW_AT_declaration:
5413 part_die->is_declaration = DW_UNSND (&attr);
5416 part_die->has_type = 1;
5418 case DW_AT_abstract_origin:
5419 case DW_AT_specification:
5420 case DW_AT_extension:
5421 part_die->has_specification = 1;
5422 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5425 /* Ignore absolute siblings, they might point outside of
5426 the current compile unit. */
5427 if (attr.form == DW_FORM_ref_addr)
5428 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5430 part_die->sibling = dwarf2_per_objfile->info_buffer
5431 + dwarf2_get_ref_die_offset (&attr, cu);
5433 case DW_AT_stmt_list:
5434 part_die->has_stmt_list = 1;
5435 part_die->line_offset = DW_UNSND (&attr);
5442 /* When using the GNU linker, .gnu.linkonce. sections are used to
5443 eliminate duplicate copies of functions and vtables and such.
5444 The linker will arbitrarily choose one and discard the others.
5445 The AT_*_pc values for such functions refer to local labels in
5446 these sections. If the section from that file was discarded, the
5447 labels are not in the output, so the relocs get a value of 0.
5448 If this is a discarded function, mark the pc bounds as invalid,
5449 so that GDB will ignore it. */
5450 if (has_low_pc_attr && has_high_pc_attr
5451 && part_die->lowpc < part_die->highpc
5452 && (part_die->lowpc != 0
5453 || (bfd_get_file_flags (abfd) & HAS_RELOC)))
5454 part_die->has_pc_info = 1;
5458 /* Find a cached partial DIE at OFFSET in CU. */
5460 static struct partial_die_info *
5461 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5463 struct partial_die_info *lookup_die = NULL;
5464 struct partial_die_info part_die;
5466 part_die.offset = offset;
5467 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5469 if (lookup_die == NULL)
5470 internal_error (__FILE__, __LINE__,
5471 _("could not find partial DIE in cache\n"));
5476 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5478 static struct partial_die_info *
5479 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5481 struct dwarf2_per_cu_data *per_cu;
5483 if (offset >= cu->header.offset
5484 && offset < cu->header.offset + cu->header.length)
5485 return find_partial_die_in_comp_unit (offset, cu);
5487 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5489 if (per_cu->cu == NULL)
5491 load_comp_unit (per_cu, cu->objfile);
5492 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5493 dwarf2_per_objfile->read_in_chain = per_cu;
5496 per_cu->cu->last_used = 0;
5497 return find_partial_die_in_comp_unit (offset, per_cu->cu);
5500 /* Adjust PART_DIE before generating a symbol for it. This function
5501 may set the is_external flag or change the DIE's name. */
5504 fixup_partial_die (struct partial_die_info *part_die,
5505 struct dwarf2_cu *cu)
5507 /* If we found a reference attribute and the DIE has no name, try
5508 to find a name in the referred to DIE. */
5510 if (part_die->name == NULL && part_die->has_specification)
5512 struct partial_die_info *spec_die;
5514 spec_die = find_partial_die (part_die->spec_offset, cu);
5516 fixup_partial_die (spec_die, cu);
5520 part_die->name = spec_die->name;
5522 /* Copy DW_AT_external attribute if it is set. */
5523 if (spec_die->is_external)
5524 part_die->is_external = spec_die->is_external;
5528 /* Set default names for some unnamed DIEs. */
5529 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5530 || part_die->tag == DW_TAG_class_type))
5531 part_die->name = "(anonymous class)";
5533 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5534 part_die->name = "(anonymous namespace)";
5536 if (part_die->tag == DW_TAG_structure_type
5537 || part_die->tag == DW_TAG_class_type
5538 || part_die->tag == DW_TAG_union_type)
5539 guess_structure_name (part_die, cu);
5542 /* Read the die from the .debug_info section buffer. Set DIEP to
5543 point to a newly allocated die with its information, except for its
5544 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5545 whether the die has children or not. */
5548 read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr,
5549 struct dwarf2_cu *cu, int *has_children)
5551 unsigned int abbrev_number, bytes_read, i, offset;
5552 struct abbrev_info *abbrev;
5553 struct die_info *die;
5555 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5556 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5557 info_ptr += bytes_read;
5560 die = dwarf_alloc_die ();
5562 die->abbrev = abbrev_number;
5569 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5572 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5574 bfd_get_filename (abfd));
5576 die = dwarf_alloc_die ();
5577 die->offset = offset;
5578 die->tag = abbrev->tag;
5579 die->abbrev = abbrev_number;
5582 die->num_attrs = abbrev->num_attrs;
5583 die->attrs = (struct attribute *)
5584 xmalloc (die->num_attrs * sizeof (struct attribute));
5586 for (i = 0; i < abbrev->num_attrs; ++i)
5588 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5589 abfd, info_ptr, cu);
5591 /* If this attribute is an absolute reference to a different
5592 compilation unit, make sure that compilation unit is loaded
5594 if (die->attrs[i].form == DW_FORM_ref_addr
5595 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5596 || (DW_ADDR (&die->attrs[i])
5597 >= cu->header.offset + cu->header.length)))
5599 struct dwarf2_per_cu_data *per_cu;
5600 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5603 /* Mark the dependence relation so that we don't flush PER_CU
5605 dwarf2_add_dependence (cu, per_cu);
5607 /* If it's already on the queue, we have nothing to do. */
5611 /* If the compilation unit is already loaded, just mark it as
5613 if (per_cu->cu != NULL)
5615 per_cu->cu->last_used = 0;
5619 /* Add it to the queue. */
5620 queue_comp_unit (per_cu);
5625 *has_children = abbrev->has_children;
5629 /* Read an attribute value described by an attribute form. */
5632 read_attribute_value (struct attribute *attr, unsigned form,
5633 bfd *abfd, char *info_ptr,
5634 struct dwarf2_cu *cu)
5636 struct comp_unit_head *cu_header = &cu->header;
5637 unsigned int bytes_read;
5638 struct dwarf_block *blk;
5644 case DW_FORM_ref_addr:
5645 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5646 info_ptr += bytes_read;
5648 case DW_FORM_block2:
5649 blk = dwarf_alloc_block (cu);
5650 blk->size = read_2_bytes (abfd, info_ptr);
5652 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5653 info_ptr += blk->size;
5654 DW_BLOCK (attr) = blk;
5656 case DW_FORM_block4:
5657 blk = dwarf_alloc_block (cu);
5658 blk->size = read_4_bytes (abfd, info_ptr);
5660 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5661 info_ptr += blk->size;
5662 DW_BLOCK (attr) = blk;
5665 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5669 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5673 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5676 case DW_FORM_string:
5677 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5678 info_ptr += bytes_read;
5681 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5683 info_ptr += bytes_read;
5686 blk = dwarf_alloc_block (cu);
5687 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5688 info_ptr += bytes_read;
5689 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5690 info_ptr += blk->size;
5691 DW_BLOCK (attr) = blk;
5693 case DW_FORM_block1:
5694 blk = dwarf_alloc_block (cu);
5695 blk->size = read_1_byte (abfd, info_ptr);
5697 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5698 info_ptr += blk->size;
5699 DW_BLOCK (attr) = blk;
5702 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5706 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5710 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5711 info_ptr += bytes_read;
5714 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5715 info_ptr += bytes_read;
5718 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5722 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5726 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5730 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5733 case DW_FORM_ref_udata:
5734 DW_ADDR (attr) = (cu->header.offset
5735 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5736 info_ptr += bytes_read;
5738 case DW_FORM_indirect:
5739 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5740 info_ptr += bytes_read;
5741 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5744 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5745 dwarf_form_name (form),
5746 bfd_get_filename (abfd));
5751 /* Read an attribute described by an abbreviated attribute. */
5754 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5755 bfd *abfd, char *info_ptr, struct dwarf2_cu *cu)
5757 attr->name = abbrev->name;
5758 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5761 /* read dwarf information from a buffer */
5764 read_1_byte (bfd *abfd, char *buf)
5766 return bfd_get_8 (abfd, (bfd_byte *) buf);
5770 read_1_signed_byte (bfd *abfd, char *buf)
5772 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
5776 read_2_bytes (bfd *abfd, char *buf)
5778 return bfd_get_16 (abfd, (bfd_byte *) buf);
5782 read_2_signed_bytes (bfd *abfd, char *buf)
5784 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
5788 read_4_bytes (bfd *abfd, char *buf)
5790 return bfd_get_32 (abfd, (bfd_byte *) buf);
5794 read_4_signed_bytes (bfd *abfd, char *buf)
5796 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
5799 static unsigned long
5800 read_8_bytes (bfd *abfd, char *buf)
5802 return bfd_get_64 (abfd, (bfd_byte *) buf);
5806 read_address (bfd *abfd, char *buf, struct dwarf2_cu *cu,
5807 unsigned int *bytes_read)
5809 struct comp_unit_head *cu_header = &cu->header;
5810 CORE_ADDR retval = 0;
5812 if (cu_header->signed_addr_p)
5814 switch (cu_header->addr_size)
5817 retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf);
5820 retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf);
5823 retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf);
5826 internal_error (__FILE__, __LINE__,
5827 _("read_address: bad switch, signed [in module %s]"),
5828 bfd_get_filename (abfd));
5833 switch (cu_header->addr_size)
5836 retval = bfd_get_16 (abfd, (bfd_byte *) buf);
5839 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
5842 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
5845 internal_error (__FILE__, __LINE__,
5846 _("read_address: bad switch, unsigned [in module %s]"),
5847 bfd_get_filename (abfd));
5851 *bytes_read = cu_header->addr_size;
5855 /* Read the initial length from a section. The (draft) DWARF 3
5856 specification allows the initial length to take up either 4 bytes
5857 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5858 bytes describe the length and all offsets will be 8 bytes in length
5861 An older, non-standard 64-bit format is also handled by this
5862 function. The older format in question stores the initial length
5863 as an 8-byte quantity without an escape value. Lengths greater
5864 than 2^32 aren't very common which means that the initial 4 bytes
5865 is almost always zero. Since a length value of zero doesn't make
5866 sense for the 32-bit format, this initial zero can be considered to
5867 be an escape value which indicates the presence of the older 64-bit
5868 format. As written, the code can't detect (old format) lengths
5869 greater than 4GB. If it becomes necessary to handle lengths
5870 somewhat larger than 4GB, we could allow other small values (such
5871 as the non-sensical values of 1, 2, and 3) to also be used as
5872 escape values indicating the presence of the old format.
5874 The value returned via bytes_read should be used to increment the
5875 relevant pointer after calling read_initial_length().
5877 As a side effect, this function sets the fields initial_length_size
5878 and offset_size in cu_header to the values appropriate for the
5879 length field. (The format of the initial length field determines
5880 the width of file offsets to be fetched later with read_offset().)
5882 [ Note: read_initial_length() and read_offset() are based on the
5883 document entitled "DWARF Debugging Information Format", revision
5884 3, draft 8, dated November 19, 2001. This document was obtained
5887 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5889 This document is only a draft and is subject to change. (So beware.)
5891 Details regarding the older, non-standard 64-bit format were
5892 determined empirically by examining 64-bit ELF files produced by
5893 the SGI toolchain on an IRIX 6.5 machine.
5895 - Kevin, July 16, 2002
5899 read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header,
5900 unsigned int *bytes_read)
5902 LONGEST length = bfd_get_32 (abfd, (bfd_byte *) buf);
5904 if (length == 0xffffffff)
5906 length = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
5909 else if (length == 0)
5911 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5912 length = bfd_get_64 (abfd, (bfd_byte *) buf);
5922 gdb_assert (cu_header->initial_length_size == 0
5923 || cu_header->initial_length_size == 4
5924 || cu_header->initial_length_size == 8
5925 || cu_header->initial_length_size == 12);
5927 if (cu_header->initial_length_size != 0
5928 && cu_header->initial_length_size != *bytes_read)
5929 complaint (&symfile_complaints,
5930 _("intermixed 32-bit and 64-bit DWARF sections"));
5932 cu_header->initial_length_size = *bytes_read;
5933 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
5939 /* Read an offset from the data stream. The size of the offset is
5940 given by cu_header->offset_size. */
5943 read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
5944 unsigned int *bytes_read)
5948 switch (cu_header->offset_size)
5951 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
5955 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
5959 internal_error (__FILE__, __LINE__,
5960 _("read_offset: bad switch [in module %s]"),
5961 bfd_get_filename (abfd));
5968 read_n_bytes (bfd *abfd, char *buf, unsigned int size)
5970 /* If the size of a host char is 8 bits, we can return a pointer
5971 to the buffer, otherwise we have to copy the data to a buffer
5972 allocated on the temporary obstack. */
5973 gdb_assert (HOST_CHAR_BIT == 8);
5978 read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
5980 /* If the size of a host char is 8 bits, we can return a pointer
5981 to the string, otherwise we have to copy the string to a buffer
5982 allocated on the temporary obstack. */
5983 gdb_assert (HOST_CHAR_BIT == 8);
5986 *bytes_read_ptr = 1;
5989 *bytes_read_ptr = strlen (buf) + 1;
5994 read_indirect_string (bfd *abfd, char *buf,
5995 const struct comp_unit_head *cu_header,
5996 unsigned int *bytes_read_ptr)
5998 LONGEST str_offset = read_offset (abfd, buf, cu_header,
6001 if (dwarf2_per_objfile->str_buffer == NULL)
6003 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6004 bfd_get_filename (abfd));
6007 if (str_offset >= dwarf2_per_objfile->str_size)
6009 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6010 bfd_get_filename (abfd));
6013 gdb_assert (HOST_CHAR_BIT == 8);
6014 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6016 return dwarf2_per_objfile->str_buffer + str_offset;
6019 static unsigned long
6020 read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
6022 unsigned long result;
6023 unsigned int num_read;
6033 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
6036 result |= ((unsigned long)(byte & 127) << shift);
6037 if ((byte & 128) == 0)
6043 *bytes_read_ptr = num_read;
6048 read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
6051 int i, shift, num_read;
6060 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
6063 result |= ((long)(byte & 127) << shift);
6065 if ((byte & 128) == 0)
6070 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6071 result |= -(((long)1) << shift);
6072 *bytes_read_ptr = num_read;
6076 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6079 skip_leb128 (bfd *abfd, char *buf)
6085 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
6087 if ((byte & 128) == 0)
6093 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6099 cu->language = language_c;
6101 case DW_LANG_C_plus_plus:
6102 cu->language = language_cplus;
6104 case DW_LANG_Fortran77:
6105 case DW_LANG_Fortran90:
6106 case DW_LANG_Fortran95:
6107 cu->language = language_fortran;
6109 case DW_LANG_Mips_Assembler:
6110 cu->language = language_asm;
6113 cu->language = language_java;
6117 cu->language = language_ada;
6119 case DW_LANG_Cobol74:
6120 case DW_LANG_Cobol85:
6121 case DW_LANG_Pascal83:
6122 case DW_LANG_Modula2:
6124 cu->language = language_minimal;
6127 cu->language_defn = language_def (cu->language);
6130 /* Return the named attribute or NULL if not there. */
6132 static struct attribute *
6133 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6136 struct attribute *spec = NULL;
6138 for (i = 0; i < die->num_attrs; ++i)
6140 if (die->attrs[i].name == name)
6141 return &die->attrs[i];
6142 if (die->attrs[i].name == DW_AT_specification
6143 || die->attrs[i].name == DW_AT_abstract_origin)
6144 spec = &die->attrs[i];
6148 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6153 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6154 and holds a non-zero value. This function should only be used for
6155 DW_FORM_flag attributes. */
6158 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6160 struct attribute *attr = dwarf2_attr (die, name, cu);
6162 return (attr && DW_UNSND (attr));
6166 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6168 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6169 which value is non-zero. However, we have to be careful with
6170 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6171 (via dwarf2_flag_true_p) follows this attribute. So we may
6172 end up accidently finding a declaration attribute that belongs
6173 to a different DIE referenced by the specification attribute,
6174 even though the given DIE does not have a declaration attribute. */
6175 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6176 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6179 /* Return the die giving the specification for DIE, if there is
6182 static struct die_info *
6183 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6185 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6187 if (spec_attr == NULL)
6190 return follow_die_ref (die, spec_attr, cu);
6193 /* Free the line_header structure *LH, and any arrays and strings it
6196 free_line_header (struct line_header *lh)
6198 if (lh->standard_opcode_lengths)
6199 xfree (lh->standard_opcode_lengths);
6201 /* Remember that all the lh->file_names[i].name pointers are
6202 pointers into debug_line_buffer, and don't need to be freed. */
6204 xfree (lh->file_names);
6206 /* Similarly for the include directory names. */
6207 if (lh->include_dirs)
6208 xfree (lh->include_dirs);
6214 /* Add an entry to LH's include directory table. */
6216 add_include_dir (struct line_header *lh, char *include_dir)
6218 /* Grow the array if necessary. */
6219 if (lh->include_dirs_size == 0)
6221 lh->include_dirs_size = 1; /* for testing */
6222 lh->include_dirs = xmalloc (lh->include_dirs_size
6223 * sizeof (*lh->include_dirs));
6225 else if (lh->num_include_dirs >= lh->include_dirs_size)
6227 lh->include_dirs_size *= 2;
6228 lh->include_dirs = xrealloc (lh->include_dirs,
6229 (lh->include_dirs_size
6230 * sizeof (*lh->include_dirs)));
6233 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6237 /* Add an entry to LH's file name table. */
6239 add_file_name (struct line_header *lh,
6241 unsigned int dir_index,
6242 unsigned int mod_time,
6243 unsigned int length)
6245 struct file_entry *fe;
6247 /* Grow the array if necessary. */
6248 if (lh->file_names_size == 0)
6250 lh->file_names_size = 1; /* for testing */
6251 lh->file_names = xmalloc (lh->file_names_size
6252 * sizeof (*lh->file_names));
6254 else if (lh->num_file_names >= lh->file_names_size)
6256 lh->file_names_size *= 2;
6257 lh->file_names = xrealloc (lh->file_names,
6258 (lh->file_names_size
6259 * sizeof (*lh->file_names)));
6262 fe = &lh->file_names[lh->num_file_names++];
6264 fe->dir_index = dir_index;
6265 fe->mod_time = mod_time;
6266 fe->length = length;
6271 /* Read the statement program header starting at OFFSET in
6272 .debug_line, according to the endianness of ABFD. Return a pointer
6273 to a struct line_header, allocated using xmalloc.
6275 NOTE: the strings in the include directory and file name tables of
6276 the returned object point into debug_line_buffer, and must not be
6278 static struct line_header *
6279 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6280 struct dwarf2_cu *cu)
6282 struct cleanup *back_to;
6283 struct line_header *lh;
6285 unsigned int bytes_read;
6287 char *cur_dir, *cur_file;
6289 if (dwarf2_per_objfile->line_buffer == NULL)
6291 complaint (&symfile_complaints, _("missing .debug_line section"));
6295 /* Make sure that at least there's room for the total_length field.
6296 That could be 12 bytes long, but we're just going to fudge that. */
6297 if (offset + 4 >= dwarf2_per_objfile->line_size)
6299 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6303 lh = xmalloc (sizeof (*lh));
6304 memset (lh, 0, sizeof (*lh));
6305 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6308 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6310 /* Read in the header. */
6312 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6313 line_ptr += bytes_read;
6314 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6315 + dwarf2_per_objfile->line_size))
6317 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6320 lh->statement_program_end = line_ptr + lh->total_length;
6321 lh->version = read_2_bytes (abfd, line_ptr);
6323 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6324 line_ptr += bytes_read;
6325 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6327 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6329 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6331 lh->line_range = read_1_byte (abfd, line_ptr);
6333 lh->opcode_base = read_1_byte (abfd, line_ptr);
6335 lh->standard_opcode_lengths
6336 = (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char));
6338 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6339 for (i = 1; i < lh->opcode_base; ++i)
6341 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6345 /* Read directory table. */
6346 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6348 line_ptr += bytes_read;
6349 add_include_dir (lh, cur_dir);
6351 line_ptr += bytes_read;
6353 /* Read file name table. */
6354 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6356 unsigned int dir_index, mod_time, length;
6358 line_ptr += bytes_read;
6359 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6360 line_ptr += bytes_read;
6361 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6362 line_ptr += bytes_read;
6363 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6364 line_ptr += bytes_read;
6366 add_file_name (lh, cur_file, dir_index, mod_time, length);
6368 line_ptr += bytes_read;
6369 lh->statement_program_start = line_ptr;
6371 if (line_ptr > (dwarf2_per_objfile->line_buffer
6372 + dwarf2_per_objfile->line_size))
6373 complaint (&symfile_complaints,
6374 _("line number info header doesn't fit in `.debug_line' section"));
6376 discard_cleanups (back_to);
6380 /* This function exists to work around a bug in certain compilers
6381 (particularly GCC 2.95), in which the first line number marker of a
6382 function does not show up until after the prologue, right before
6383 the second line number marker. This function shifts ADDRESS down
6384 to the beginning of the function if necessary, and is called on
6385 addresses passed to record_line. */
6388 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6390 struct function_range *fn;
6392 /* Find the function_range containing address. */
6397 cu->cached_fn = cu->first_fn;
6401 if (fn->lowpc <= address && fn->highpc > address)
6407 while (fn && fn != cu->cached_fn)
6408 if (fn->lowpc <= address && fn->highpc > address)
6418 if (address != fn->lowpc)
6419 complaint (&symfile_complaints,
6420 _("misplaced first line number at 0x%lx for '%s'"),
6421 (unsigned long) address, fn->name);
6426 /* Decode the Line Number Program (LNP) for the given line_header
6427 structure and CU. The actual information extracted and the type
6428 of structures created from the LNP depends on the value of PST.
6430 1. If PST is NULL, then this procedure uses the data from the program
6431 to create all necessary symbol tables, and their linetables.
6432 The compilation directory of the file is passed in COMP_DIR,
6433 and must not be NULL.
6435 2. If PST is not NULL, this procedure reads the program to determine
6436 the list of files included by the unit represented by PST, and
6437 builds all the associated partial symbol tables. In this case,
6438 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6439 is not used to compute the full name of the symtab, and therefore
6440 omitting it when building the partial symtab does not introduce
6441 the potential for inconsistency - a partial symtab and its associated
6442 symbtab having a different fullname -). */
6445 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6446 struct dwarf2_cu *cu, struct partial_symtab *pst)
6450 unsigned int bytes_read;
6451 unsigned char op_code, extended_op, adj_opcode;
6453 struct objfile *objfile = cu->objfile;
6454 const int decode_for_pst_p = (pst != NULL);
6456 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6458 line_ptr = lh->statement_program_start;
6459 line_end = lh->statement_program_end;
6461 /* Read the statement sequences until there's nothing left. */
6462 while (line_ptr < line_end)
6464 /* state machine registers */
6465 CORE_ADDR address = 0;
6466 unsigned int file = 1;
6467 unsigned int line = 1;
6468 unsigned int column = 0;
6469 int is_stmt = lh->default_is_stmt;
6470 int basic_block = 0;
6471 int end_sequence = 0;
6473 if (!decode_for_pst_p && lh->num_file_names >= file)
6475 /* Start a subfile for the current file of the state machine. */
6476 /* lh->include_dirs and lh->file_names are 0-based, but the
6477 directory and file name numbers in the statement program
6479 struct file_entry *fe = &lh->file_names[file - 1];
6483 dir = lh->include_dirs[fe->dir_index - 1];
6486 dwarf2_start_subfile (fe->name, dir);
6489 /* Decode the table. */
6490 while (!end_sequence)
6492 op_code = read_1_byte (abfd, line_ptr);
6495 if (op_code >= lh->opcode_base)
6497 /* Special operand. */
6498 adj_opcode = op_code - lh->opcode_base;
6499 address += (adj_opcode / lh->line_range)
6500 * lh->minimum_instruction_length;
6501 line += lh->line_base + (adj_opcode % lh->line_range);
6502 lh->file_names[file - 1].included_p = 1;
6503 if (!decode_for_pst_p)
6505 /* Append row to matrix using current values. */
6506 record_line (current_subfile, line,
6507 check_cu_functions (address, cu));
6511 else switch (op_code)
6513 case DW_LNS_extended_op:
6514 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6515 line_ptr += bytes_read;
6516 extended_op = read_1_byte (abfd, line_ptr);
6518 switch (extended_op)
6520 case DW_LNE_end_sequence:
6522 lh->file_names[file - 1].included_p = 1;
6523 if (!decode_for_pst_p)
6524 record_line (current_subfile, 0, address);
6526 case DW_LNE_set_address:
6527 address = read_address (abfd, line_ptr, cu, &bytes_read);
6528 line_ptr += bytes_read;
6529 address += baseaddr;
6531 case DW_LNE_define_file:
6534 unsigned int dir_index, mod_time, length;
6536 cur_file = read_string (abfd, line_ptr, &bytes_read);
6537 line_ptr += bytes_read;
6539 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6540 line_ptr += bytes_read;
6542 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6543 line_ptr += bytes_read;
6545 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6546 line_ptr += bytes_read;
6547 add_file_name (lh, cur_file, dir_index, mod_time, length);
6551 complaint (&symfile_complaints,
6552 _("mangled .debug_line section"));
6557 lh->file_names[file - 1].included_p = 1;
6558 if (!decode_for_pst_p)
6559 record_line (current_subfile, line,
6560 check_cu_functions (address, cu));
6563 case DW_LNS_advance_pc:
6564 address += lh->minimum_instruction_length
6565 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6566 line_ptr += bytes_read;
6568 case DW_LNS_advance_line:
6569 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6570 line_ptr += bytes_read;
6572 case DW_LNS_set_file:
6574 /* The arrays lh->include_dirs and lh->file_names are
6575 0-based, but the directory and file name numbers in
6576 the statement program are 1-based. */
6577 struct file_entry *fe;
6580 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6581 line_ptr += bytes_read;
6582 fe = &lh->file_names[file - 1];
6584 dir = lh->include_dirs[fe->dir_index - 1];
6587 if (!decode_for_pst_p)
6588 dwarf2_start_subfile (fe->name, dir);
6591 case DW_LNS_set_column:
6592 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6593 line_ptr += bytes_read;
6595 case DW_LNS_negate_stmt:
6596 is_stmt = (!is_stmt);
6598 case DW_LNS_set_basic_block:
6601 /* Add to the address register of the state machine the
6602 address increment value corresponding to special opcode
6603 255. I.e., this value is scaled by the minimum
6604 instruction length since special opcode 255 would have
6605 scaled the the increment. */
6606 case DW_LNS_const_add_pc:
6607 address += (lh->minimum_instruction_length
6608 * ((255 - lh->opcode_base) / lh->line_range));
6610 case DW_LNS_fixed_advance_pc:
6611 address += read_2_bytes (abfd, line_ptr);
6616 /* Unknown standard opcode, ignore it. */
6619 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6621 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6622 line_ptr += bytes_read;
6629 if (decode_for_pst_p)
6633 /* Now that we're done scanning the Line Header Program, we can
6634 create the psymtab of each included file. */
6635 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6636 if (lh->file_names[file_index].included_p == 1)
6638 const struct file_entry fe = lh->file_names [file_index];
6639 char *include_name = fe.name;
6640 char *dir_name = NULL;
6641 char *pst_filename = pst->filename;
6644 dir_name = lh->include_dirs[fe.dir_index - 1];
6646 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6648 include_name = concat (dir_name, SLASH_STRING,
6649 include_name, (char *)NULL);
6650 make_cleanup (xfree, include_name);
6653 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6655 pst_filename = concat (pst->dirname, SLASH_STRING,
6656 pst_filename, (char *)NULL);
6657 make_cleanup (xfree, pst_filename);
6660 if (strcmp (include_name, pst_filename) != 0)
6661 dwarf2_create_include_psymtab (include_name, pst, objfile);
6666 /* Start a subfile for DWARF. FILENAME is the name of the file and
6667 DIRNAME the name of the source directory which contains FILENAME
6668 or NULL if not known.
6669 This routine tries to keep line numbers from identical absolute and
6670 relative file names in a common subfile.
6672 Using the `list' example from the GDB testsuite, which resides in
6673 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6674 of /srcdir/list0.c yields the following debugging information for list0.c:
6676 DW_AT_name: /srcdir/list0.c
6677 DW_AT_comp_dir: /compdir
6678 files.files[0].name: list0.h
6679 files.files[0].dir: /srcdir
6680 files.files[1].name: list0.c
6681 files.files[1].dir: /srcdir
6683 The line number information for list0.c has to end up in a single
6684 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6687 dwarf2_start_subfile (char *filename, char *dirname)
6689 /* If the filename isn't absolute, try to match an existing subfile
6690 with the full pathname. */
6692 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6694 struct subfile *subfile;
6695 char *fullname = concat (dirname, "/", filename, (char *)NULL);
6697 for (subfile = subfiles; subfile; subfile = subfile->next)
6699 if (FILENAME_CMP (subfile->name, fullname) == 0)
6701 current_subfile = subfile;
6708 start_subfile (filename, dirname);
6712 var_decode_location (struct attribute *attr, struct symbol *sym,
6713 struct dwarf2_cu *cu)
6715 struct objfile *objfile = cu->objfile;
6716 struct comp_unit_head *cu_header = &cu->header;
6718 /* NOTE drow/2003-01-30: There used to be a comment and some special
6719 code here to turn a symbol with DW_AT_external and a
6720 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6721 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6722 with some versions of binutils) where shared libraries could have
6723 relocations against symbols in their debug information - the
6724 minimal symbol would have the right address, but the debug info
6725 would not. It's no longer necessary, because we will explicitly
6726 apply relocations when we read in the debug information now. */
6728 /* A DW_AT_location attribute with no contents indicates that a
6729 variable has been optimized away. */
6730 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6732 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6736 /* Handle one degenerate form of location expression specially, to
6737 preserve GDB's previous behavior when section offsets are
6738 specified. If this is just a DW_OP_addr then mark this symbol
6741 if (attr_form_is_block (attr)
6742 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6743 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6747 SYMBOL_VALUE_ADDRESS (sym) =
6748 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6749 fixup_symbol_section (sym, objfile);
6750 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6751 SYMBOL_SECTION (sym));
6752 SYMBOL_CLASS (sym) = LOC_STATIC;
6756 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6757 expression evaluator, and use LOC_COMPUTED only when necessary
6758 (i.e. when the value of a register or memory location is
6759 referenced, or a thread-local block, etc.). Then again, it might
6760 not be worthwhile. I'm assuming that it isn't unless performance
6761 or memory numbers show me otherwise. */
6763 dwarf2_symbol_mark_computed (attr, sym, cu);
6764 SYMBOL_CLASS (sym) = LOC_COMPUTED;
6767 /* Given a pointer to a DWARF information entry, figure out if we need
6768 to make a symbol table entry for it, and if so, create a new entry
6769 and return a pointer to it.
6770 If TYPE is NULL, determine symbol type from the die, otherwise
6771 used the passed type. */
6773 static struct symbol *
6774 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6776 struct objfile *objfile = cu->objfile;
6777 struct symbol *sym = NULL;
6779 struct attribute *attr = NULL;
6780 struct attribute *attr2 = NULL;
6783 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6785 if (die->tag != DW_TAG_namespace)
6786 name = dwarf2_linkage_name (die, cu);
6788 name = TYPE_NAME (type);
6792 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6793 sizeof (struct symbol));
6794 OBJSTAT (objfile, n_syms++);
6795 memset (sym, 0, sizeof (struct symbol));
6797 /* Cache this symbol's name and the name's demangled form (if any). */
6798 SYMBOL_LANGUAGE (sym) = cu->language;
6799 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
6801 /* Default assumptions.
6802 Use the passed type or decode it from the die. */
6803 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6804 SYMBOL_CLASS (sym) = LOC_STATIC;
6806 SYMBOL_TYPE (sym) = type;
6808 SYMBOL_TYPE (sym) = die_type (die, cu);
6809 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
6812 SYMBOL_LINE (sym) = DW_UNSND (attr);
6817 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6820 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
6822 SYMBOL_CLASS (sym) = LOC_LABEL;
6824 case DW_TAG_subprogram:
6825 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6827 SYMBOL_CLASS (sym) = LOC_BLOCK;
6828 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6829 if (attr2 && (DW_UNSND (attr2) != 0))
6831 add_symbol_to_list (sym, &global_symbols);
6835 add_symbol_to_list (sym, cu->list_in_scope);
6838 case DW_TAG_variable:
6839 /* Compilation with minimal debug info may result in variables
6840 with missing type entries. Change the misleading `void' type
6841 to something sensible. */
6842 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
6843 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
6844 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
6845 "<variable, no debug info>",
6847 attr = dwarf2_attr (die, DW_AT_const_value, cu);
6850 dwarf2_const_value (attr, sym, cu);
6851 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6852 if (attr2 && (DW_UNSND (attr2) != 0))
6853 add_symbol_to_list (sym, &global_symbols);
6855 add_symbol_to_list (sym, cu->list_in_scope);
6858 attr = dwarf2_attr (die, DW_AT_location, cu);
6861 var_decode_location (attr, sym, cu);
6862 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6863 if (attr2 && (DW_UNSND (attr2) != 0))
6864 add_symbol_to_list (sym, &global_symbols);
6866 add_symbol_to_list (sym, cu->list_in_scope);
6870 /* We do not know the address of this symbol.
6871 If it is an external symbol and we have type information
6872 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6873 The address of the variable will then be determined from
6874 the minimal symbol table whenever the variable is
6876 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6877 if (attr2 && (DW_UNSND (attr2) != 0)
6878 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
6880 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
6881 add_symbol_to_list (sym, &global_symbols);
6885 case DW_TAG_formal_parameter:
6886 attr = dwarf2_attr (die, DW_AT_location, cu);
6889 var_decode_location (attr, sym, cu);
6890 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6891 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
6892 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
6894 attr = dwarf2_attr (die, DW_AT_const_value, cu);
6897 dwarf2_const_value (attr, sym, cu);
6899 add_symbol_to_list (sym, cu->list_in_scope);
6901 case DW_TAG_unspecified_parameters:
6902 /* From varargs functions; gdb doesn't seem to have any
6903 interest in this information, so just ignore it for now.
6906 case DW_TAG_class_type:
6907 case DW_TAG_structure_type:
6908 case DW_TAG_union_type:
6909 case DW_TAG_enumeration_type:
6910 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6911 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
6913 /* Make sure that the symbol includes appropriate enclosing
6914 classes/namespaces in its name. These are calculated in
6915 read_structure_type, and the correct name is saved in
6918 if (cu->language == language_cplus
6919 || cu->language == language_java)
6921 struct type *type = SYMBOL_TYPE (sym);
6923 if (TYPE_TAG_NAME (type) != NULL)
6925 /* FIXME: carlton/2003-11-10: Should this use
6926 SYMBOL_SET_NAMES instead? (The same problem also
6927 arises further down in this function.) */
6928 /* The type's name is already allocated along with
6929 this objfile, so we don't need to duplicate it
6931 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
6936 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6937 really ever be static objects: otherwise, if you try
6938 to, say, break of a class's method and you're in a file
6939 which doesn't mention that class, it won't work unless
6940 the check for all static symbols in lookup_symbol_aux
6941 saves you. See the OtherFileClass tests in
6942 gdb.c++/namespace.exp. */
6944 struct pending **list_to_add;
6946 list_to_add = (cu->list_in_scope == &file_symbols
6947 && (cu->language == language_cplus
6948 || cu->language == language_java)
6949 ? &global_symbols : cu->list_in_scope);
6951 add_symbol_to_list (sym, list_to_add);
6953 /* The semantics of C++ state that "struct foo { ... }" also
6954 defines a typedef for "foo". A Java class declaration also
6955 defines a typedef for the class. Synthesize a typedef symbol
6956 so that "ptype foo" works as expected. */
6957 if (cu->language == language_cplus
6958 || cu->language == language_java)
6960 struct symbol *typedef_sym = (struct symbol *)
6961 obstack_alloc (&objfile->objfile_obstack,
6962 sizeof (struct symbol));
6963 *typedef_sym = *sym;
6964 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
6965 /* The symbol's name is already allocated along with
6966 this objfile, so we don't need to duplicate it for
6968 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
6969 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
6970 add_symbol_to_list (typedef_sym, list_to_add);
6974 case DW_TAG_typedef:
6975 if (processing_has_namespace_info
6976 && processing_current_prefix[0] != '\0')
6978 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
6979 processing_current_prefix,
6982 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6983 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6984 add_symbol_to_list (sym, cu->list_in_scope);
6986 case DW_TAG_base_type:
6987 case DW_TAG_subrange_type:
6988 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6989 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6990 add_symbol_to_list (sym, cu->list_in_scope);
6992 case DW_TAG_enumerator:
6993 if (processing_has_namespace_info
6994 && processing_current_prefix[0] != '\0')
6996 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
6997 processing_current_prefix,
7000 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7003 dwarf2_const_value (attr, sym, cu);
7006 /* NOTE: carlton/2003-11-10: See comment above in the
7007 DW_TAG_class_type, etc. block. */
7009 struct pending **list_to_add;
7011 list_to_add = (cu->list_in_scope == &file_symbols
7012 && (cu->language == language_cplus
7013 || cu->language == language_java)
7014 ? &global_symbols : cu->list_in_scope);
7016 add_symbol_to_list (sym, list_to_add);
7019 case DW_TAG_namespace:
7020 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7021 add_symbol_to_list (sym, &global_symbols);
7024 /* Not a tag we recognize. Hopefully we aren't processing
7025 trash data, but since we must specifically ignore things
7026 we don't recognize, there is nothing else we should do at
7028 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7029 dwarf_tag_name (die->tag));
7036 /* Copy constant value from an attribute to a symbol. */
7039 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7040 struct dwarf2_cu *cu)
7042 struct objfile *objfile = cu->objfile;
7043 struct comp_unit_head *cu_header = &cu->header;
7044 struct dwarf_block *blk;
7049 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7050 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7051 cu_header->addr_size,
7052 TYPE_LENGTH (SYMBOL_TYPE
7054 SYMBOL_VALUE_BYTES (sym) = (char *)
7055 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7056 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7057 it's body - store_unsigned_integer. */
7058 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7060 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7062 case DW_FORM_block1:
7063 case DW_FORM_block2:
7064 case DW_FORM_block4:
7066 blk = DW_BLOCK (attr);
7067 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7068 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7070 TYPE_LENGTH (SYMBOL_TYPE
7072 SYMBOL_VALUE_BYTES (sym) = (char *)
7073 obstack_alloc (&objfile->objfile_obstack, blk->size);
7074 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7075 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7078 /* The DW_AT_const_value attributes are supposed to carry the
7079 symbol's value "represented as it would be on the target
7080 architecture." By the time we get here, it's already been
7081 converted to host endianness, so we just need to sign- or
7082 zero-extend it as appropriate. */
7084 dwarf2_const_value_data (attr, sym, 8);
7087 dwarf2_const_value_data (attr, sym, 16);
7090 dwarf2_const_value_data (attr, sym, 32);
7093 dwarf2_const_value_data (attr, sym, 64);
7097 SYMBOL_VALUE (sym) = DW_SND (attr);
7098 SYMBOL_CLASS (sym) = LOC_CONST;
7102 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7103 SYMBOL_CLASS (sym) = LOC_CONST;
7107 complaint (&symfile_complaints,
7108 _("unsupported const value attribute form: '%s'"),
7109 dwarf_form_name (attr->form));
7110 SYMBOL_VALUE (sym) = 0;
7111 SYMBOL_CLASS (sym) = LOC_CONST;
7117 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7118 or zero-extend it as appropriate for the symbol's type. */
7120 dwarf2_const_value_data (struct attribute *attr,
7124 LONGEST l = DW_UNSND (attr);
7126 if (bits < sizeof (l) * 8)
7128 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7129 l &= ((LONGEST) 1 << bits) - 1;
7131 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7134 SYMBOL_VALUE (sym) = l;
7135 SYMBOL_CLASS (sym) = LOC_CONST;
7139 /* Return the type of the die in question using its DW_AT_type attribute. */
7141 static struct type *
7142 die_type (struct die_info *die, struct dwarf2_cu *cu)
7145 struct attribute *type_attr;
7146 struct die_info *type_die;
7148 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7151 /* A missing DW_AT_type represents a void type. */
7152 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7155 type_die = follow_die_ref (die, type_attr, cu);
7157 type = tag_type_to_type (type_die, cu);
7160 dump_die (type_die);
7161 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7167 /* Return the containing type of the die in question using its
7168 DW_AT_containing_type attribute. */
7170 static struct type *
7171 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7173 struct type *type = NULL;
7174 struct attribute *type_attr;
7175 struct die_info *type_die = NULL;
7177 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7180 type_die = follow_die_ref (die, type_attr, cu);
7181 type = tag_type_to_type (type_die, cu);
7186 dump_die (type_die);
7187 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7193 static struct type *
7194 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7202 read_type_die (die, cu);
7206 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7214 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7216 char *prefix = determine_prefix (die, cu);
7217 const char *old_prefix = processing_current_prefix;
7218 struct cleanup *back_to = make_cleanup (xfree, prefix);
7219 processing_current_prefix = prefix;
7223 case DW_TAG_class_type:
7224 case DW_TAG_structure_type:
7225 case DW_TAG_union_type:
7226 read_structure_type (die, cu);
7228 case DW_TAG_enumeration_type:
7229 read_enumeration_type (die, cu);
7231 case DW_TAG_subprogram:
7232 case DW_TAG_subroutine_type:
7233 read_subroutine_type (die, cu);
7235 case DW_TAG_array_type:
7236 read_array_type (die, cu);
7238 case DW_TAG_pointer_type:
7239 read_tag_pointer_type (die, cu);
7241 case DW_TAG_ptr_to_member_type:
7242 read_tag_ptr_to_member_type (die, cu);
7244 case DW_TAG_reference_type:
7245 read_tag_reference_type (die, cu);
7247 case DW_TAG_const_type:
7248 read_tag_const_type (die, cu);
7250 case DW_TAG_volatile_type:
7251 read_tag_volatile_type (die, cu);
7253 case DW_TAG_string_type:
7254 read_tag_string_type (die, cu);
7256 case DW_TAG_typedef:
7257 read_typedef (die, cu);
7259 case DW_TAG_subrange_type:
7260 read_subrange_type (die, cu);
7262 case DW_TAG_base_type:
7263 read_base_type (die, cu);
7266 complaint (&symfile_complaints, _("unexepected tag in read_type_die: '%s'"),
7267 dwarf_tag_name (die->tag));
7271 processing_current_prefix = old_prefix;
7272 do_cleanups (back_to);
7275 /* Return the name of the namespace/class that DIE is defined within,
7276 or "" if we can't tell. The caller should xfree the result. */
7278 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7279 therein) for an example of how to use this function to deal with
7280 DW_AT_specification. */
7283 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7285 struct die_info *parent;
7287 if (cu->language != language_cplus
7288 && cu->language != language_java)
7291 parent = die->parent;
7295 return xstrdup ("");
7299 switch (parent->tag) {
7300 case DW_TAG_namespace:
7302 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7303 before doing this check? */
7304 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7306 return xstrdup (TYPE_TAG_NAME (parent->type));
7311 char *parent_prefix = determine_prefix (parent, cu);
7312 char *retval = typename_concat (NULL, parent_prefix,
7313 namespace_name (parent, &dummy,
7316 xfree (parent_prefix);
7321 case DW_TAG_class_type:
7322 case DW_TAG_structure_type:
7324 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7326 return xstrdup (TYPE_TAG_NAME (parent->type));
7330 const char *old_prefix = processing_current_prefix;
7331 char *new_prefix = determine_prefix (parent, cu);
7334 processing_current_prefix = new_prefix;
7335 retval = determine_class_name (parent, cu);
7336 processing_current_prefix = old_prefix;
7343 return determine_prefix (parent, cu);
7348 /* Return a newly-allocated string formed by concatenating PREFIX and
7349 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7350 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7351 perform an obconcat, otherwise allocate storage for the result. The CU argument
7352 is used to determine the language and hence, the appropriate separator. */
7354 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7357 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7358 struct dwarf2_cu *cu)
7362 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7364 else if (cu->language == language_java)
7371 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7376 strcpy (retval, prefix);
7377 strcat (retval, sep);
7380 strcat (retval, suffix);
7386 /* We have an obstack. */
7387 return obconcat (obs, prefix, sep, suffix);
7391 static struct type *
7392 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7394 struct objfile *objfile = cu->objfile;
7396 /* FIXME - this should not produce a new (struct type *)
7397 every time. It should cache base types. */
7401 case DW_ATE_address:
7402 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7404 case DW_ATE_boolean:
7405 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7407 case DW_ATE_complex_float:
7410 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7414 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7420 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7424 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7431 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7434 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7438 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7442 case DW_ATE_signed_char:
7443 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7445 case DW_ATE_unsigned:
7449 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7452 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7456 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7460 case DW_ATE_unsigned_char:
7461 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7464 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7471 copy_die (struct die_info *old_die)
7473 struct die_info *new_die;
7476 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7477 memset (new_die, 0, sizeof (struct die_info));
7479 new_die->tag = old_die->tag;
7480 new_die->has_children = old_die->has_children;
7481 new_die->abbrev = old_die->abbrev;
7482 new_die->offset = old_die->offset;
7483 new_die->type = NULL;
7485 num_attrs = old_die->num_attrs;
7486 new_die->num_attrs = num_attrs;
7487 new_die->attrs = (struct attribute *)
7488 xmalloc (num_attrs * sizeof (struct attribute));
7490 for (i = 0; i < old_die->num_attrs; ++i)
7492 new_die->attrs[i].name = old_die->attrs[i].name;
7493 new_die->attrs[i].form = old_die->attrs[i].form;
7494 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7497 new_die->next = NULL;
7502 /* Return sibling of die, NULL if no sibling. */
7504 static struct die_info *
7505 sibling_die (struct die_info *die)
7507 return die->sibling;
7510 /* Get linkage name of a die, return NULL if not found. */
7513 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7515 struct attribute *attr;
7517 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7518 if (attr && DW_STRING (attr))
7519 return DW_STRING (attr);
7520 attr = dwarf2_attr (die, DW_AT_name, cu);
7521 if (attr && DW_STRING (attr))
7522 return DW_STRING (attr);
7526 /* Get name of a die, return NULL if not found. */
7529 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7531 struct attribute *attr;
7533 attr = dwarf2_attr (die, DW_AT_name, cu);
7534 if (attr && DW_STRING (attr))
7535 return DW_STRING (attr);
7539 /* Return the die that this die in an extension of, or NULL if there
7542 static struct die_info *
7543 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7545 struct attribute *attr;
7547 attr = dwarf2_attr (die, DW_AT_extension, cu);
7551 return follow_die_ref (die, attr, cu);
7554 /* Convert a DIE tag into its string name. */
7557 dwarf_tag_name (unsigned tag)
7561 case DW_TAG_padding:
7562 return "DW_TAG_padding";
7563 case DW_TAG_array_type:
7564 return "DW_TAG_array_type";
7565 case DW_TAG_class_type:
7566 return "DW_TAG_class_type";
7567 case DW_TAG_entry_point:
7568 return "DW_TAG_entry_point";
7569 case DW_TAG_enumeration_type:
7570 return "DW_TAG_enumeration_type";
7571 case DW_TAG_formal_parameter:
7572 return "DW_TAG_formal_parameter";
7573 case DW_TAG_imported_declaration:
7574 return "DW_TAG_imported_declaration";
7576 return "DW_TAG_label";
7577 case DW_TAG_lexical_block:
7578 return "DW_TAG_lexical_block";
7580 return "DW_TAG_member";
7581 case DW_TAG_pointer_type:
7582 return "DW_TAG_pointer_type";
7583 case DW_TAG_reference_type:
7584 return "DW_TAG_reference_type";
7585 case DW_TAG_compile_unit:
7586 return "DW_TAG_compile_unit";
7587 case DW_TAG_string_type:
7588 return "DW_TAG_string_type";
7589 case DW_TAG_structure_type:
7590 return "DW_TAG_structure_type";
7591 case DW_TAG_subroutine_type:
7592 return "DW_TAG_subroutine_type";
7593 case DW_TAG_typedef:
7594 return "DW_TAG_typedef";
7595 case DW_TAG_union_type:
7596 return "DW_TAG_union_type";
7597 case DW_TAG_unspecified_parameters:
7598 return "DW_TAG_unspecified_parameters";
7599 case DW_TAG_variant:
7600 return "DW_TAG_variant";
7601 case DW_TAG_common_block:
7602 return "DW_TAG_common_block";
7603 case DW_TAG_common_inclusion:
7604 return "DW_TAG_common_inclusion";
7605 case DW_TAG_inheritance:
7606 return "DW_TAG_inheritance";
7607 case DW_TAG_inlined_subroutine:
7608 return "DW_TAG_inlined_subroutine";
7610 return "DW_TAG_module";
7611 case DW_TAG_ptr_to_member_type:
7612 return "DW_TAG_ptr_to_member_type";
7613 case DW_TAG_set_type:
7614 return "DW_TAG_set_type";
7615 case DW_TAG_subrange_type:
7616 return "DW_TAG_subrange_type";
7617 case DW_TAG_with_stmt:
7618 return "DW_TAG_with_stmt";
7619 case DW_TAG_access_declaration:
7620 return "DW_TAG_access_declaration";
7621 case DW_TAG_base_type:
7622 return "DW_TAG_base_type";
7623 case DW_TAG_catch_block:
7624 return "DW_TAG_catch_block";
7625 case DW_TAG_const_type:
7626 return "DW_TAG_const_type";
7627 case DW_TAG_constant:
7628 return "DW_TAG_constant";
7629 case DW_TAG_enumerator:
7630 return "DW_TAG_enumerator";
7631 case DW_TAG_file_type:
7632 return "DW_TAG_file_type";
7634 return "DW_TAG_friend";
7635 case DW_TAG_namelist:
7636 return "DW_TAG_namelist";
7637 case DW_TAG_namelist_item:
7638 return "DW_TAG_namelist_item";
7639 case DW_TAG_packed_type:
7640 return "DW_TAG_packed_type";
7641 case DW_TAG_subprogram:
7642 return "DW_TAG_subprogram";
7643 case DW_TAG_template_type_param:
7644 return "DW_TAG_template_type_param";
7645 case DW_TAG_template_value_param:
7646 return "DW_TAG_template_value_param";
7647 case DW_TAG_thrown_type:
7648 return "DW_TAG_thrown_type";
7649 case DW_TAG_try_block:
7650 return "DW_TAG_try_block";
7651 case DW_TAG_variant_part:
7652 return "DW_TAG_variant_part";
7653 case DW_TAG_variable:
7654 return "DW_TAG_variable";
7655 case DW_TAG_volatile_type:
7656 return "DW_TAG_volatile_type";
7657 case DW_TAG_dwarf_procedure:
7658 return "DW_TAG_dwarf_procedure";
7659 case DW_TAG_restrict_type:
7660 return "DW_TAG_restrict_type";
7661 case DW_TAG_interface_type:
7662 return "DW_TAG_interface_type";
7663 case DW_TAG_namespace:
7664 return "DW_TAG_namespace";
7665 case DW_TAG_imported_module:
7666 return "DW_TAG_imported_module";
7667 case DW_TAG_unspecified_type:
7668 return "DW_TAG_unspecified_type";
7669 case DW_TAG_partial_unit:
7670 return "DW_TAG_partial_unit";
7671 case DW_TAG_imported_unit:
7672 return "DW_TAG_imported_unit";
7673 case DW_TAG_MIPS_loop:
7674 return "DW_TAG_MIPS_loop";
7675 case DW_TAG_format_label:
7676 return "DW_TAG_format_label";
7677 case DW_TAG_function_template:
7678 return "DW_TAG_function_template";
7679 case DW_TAG_class_template:
7680 return "DW_TAG_class_template";
7682 return "DW_TAG_<unknown>";
7686 /* Convert a DWARF attribute code into its string name. */
7689 dwarf_attr_name (unsigned attr)
7694 return "DW_AT_sibling";
7695 case DW_AT_location:
7696 return "DW_AT_location";
7698 return "DW_AT_name";
7699 case DW_AT_ordering:
7700 return "DW_AT_ordering";
7701 case DW_AT_subscr_data:
7702 return "DW_AT_subscr_data";
7703 case DW_AT_byte_size:
7704 return "DW_AT_byte_size";
7705 case DW_AT_bit_offset:
7706 return "DW_AT_bit_offset";
7707 case DW_AT_bit_size:
7708 return "DW_AT_bit_size";
7709 case DW_AT_element_list:
7710 return "DW_AT_element_list";
7711 case DW_AT_stmt_list:
7712 return "DW_AT_stmt_list";
7714 return "DW_AT_low_pc";
7716 return "DW_AT_high_pc";
7717 case DW_AT_language:
7718 return "DW_AT_language";
7720 return "DW_AT_member";
7722 return "DW_AT_discr";
7723 case DW_AT_discr_value:
7724 return "DW_AT_discr_value";
7725 case DW_AT_visibility:
7726 return "DW_AT_visibility";
7728 return "DW_AT_import";
7729 case DW_AT_string_length:
7730 return "DW_AT_string_length";
7731 case DW_AT_common_reference:
7732 return "DW_AT_common_reference";
7733 case DW_AT_comp_dir:
7734 return "DW_AT_comp_dir";
7735 case DW_AT_const_value:
7736 return "DW_AT_const_value";
7737 case DW_AT_containing_type:
7738 return "DW_AT_containing_type";
7739 case DW_AT_default_value:
7740 return "DW_AT_default_value";
7742 return "DW_AT_inline";
7743 case DW_AT_is_optional:
7744 return "DW_AT_is_optional";
7745 case DW_AT_lower_bound:
7746 return "DW_AT_lower_bound";
7747 case DW_AT_producer:
7748 return "DW_AT_producer";
7749 case DW_AT_prototyped:
7750 return "DW_AT_prototyped";
7751 case DW_AT_return_addr:
7752 return "DW_AT_return_addr";
7753 case DW_AT_start_scope:
7754 return "DW_AT_start_scope";
7755 case DW_AT_stride_size:
7756 return "DW_AT_stride_size";
7757 case DW_AT_upper_bound:
7758 return "DW_AT_upper_bound";
7759 case DW_AT_abstract_origin:
7760 return "DW_AT_abstract_origin";
7761 case DW_AT_accessibility:
7762 return "DW_AT_accessibility";
7763 case DW_AT_address_class:
7764 return "DW_AT_address_class";
7765 case DW_AT_artificial:
7766 return "DW_AT_artificial";
7767 case DW_AT_base_types:
7768 return "DW_AT_base_types";
7769 case DW_AT_calling_convention:
7770 return "DW_AT_calling_convention";
7772 return "DW_AT_count";
7773 case DW_AT_data_member_location:
7774 return "DW_AT_data_member_location";
7775 case DW_AT_decl_column:
7776 return "DW_AT_decl_column";
7777 case DW_AT_decl_file:
7778 return "DW_AT_decl_file";
7779 case DW_AT_decl_line:
7780 return "DW_AT_decl_line";
7781 case DW_AT_declaration:
7782 return "DW_AT_declaration";
7783 case DW_AT_discr_list:
7784 return "DW_AT_discr_list";
7785 case DW_AT_encoding:
7786 return "DW_AT_encoding";
7787 case DW_AT_external:
7788 return "DW_AT_external";
7789 case DW_AT_frame_base:
7790 return "DW_AT_frame_base";
7792 return "DW_AT_friend";
7793 case DW_AT_identifier_case:
7794 return "DW_AT_identifier_case";
7795 case DW_AT_macro_info:
7796 return "DW_AT_macro_info";
7797 case DW_AT_namelist_items:
7798 return "DW_AT_namelist_items";
7799 case DW_AT_priority:
7800 return "DW_AT_priority";
7802 return "DW_AT_segment";
7803 case DW_AT_specification:
7804 return "DW_AT_specification";
7805 case DW_AT_static_link:
7806 return "DW_AT_static_link";
7808 return "DW_AT_type";
7809 case DW_AT_use_location:
7810 return "DW_AT_use_location";
7811 case DW_AT_variable_parameter:
7812 return "DW_AT_variable_parameter";
7813 case DW_AT_virtuality:
7814 return "DW_AT_virtuality";
7815 case DW_AT_vtable_elem_location:
7816 return "DW_AT_vtable_elem_location";
7817 case DW_AT_allocated:
7818 return "DW_AT_allocated";
7819 case DW_AT_associated:
7820 return "DW_AT_associated";
7821 case DW_AT_data_location:
7822 return "DW_AT_data_location";
7824 return "DW_AT_stride";
7825 case DW_AT_entry_pc:
7826 return "DW_AT_entry_pc";
7827 case DW_AT_use_UTF8:
7828 return "DW_AT_use_UTF8";
7829 case DW_AT_extension:
7830 return "DW_AT_extension";
7832 return "DW_AT_ranges";
7833 case DW_AT_trampoline:
7834 return "DW_AT_trampoline";
7835 case DW_AT_call_column:
7836 return "DW_AT_call_column";
7837 case DW_AT_call_file:
7838 return "DW_AT_call_file";
7839 case DW_AT_call_line:
7840 return "DW_AT_call_line";
7842 case DW_AT_MIPS_fde:
7843 return "DW_AT_MIPS_fde";
7844 case DW_AT_MIPS_loop_begin:
7845 return "DW_AT_MIPS_loop_begin";
7846 case DW_AT_MIPS_tail_loop_begin:
7847 return "DW_AT_MIPS_tail_loop_begin";
7848 case DW_AT_MIPS_epilog_begin:
7849 return "DW_AT_MIPS_epilog_begin";
7850 case DW_AT_MIPS_loop_unroll_factor:
7851 return "DW_AT_MIPS_loop_unroll_factor";
7852 case DW_AT_MIPS_software_pipeline_depth:
7853 return "DW_AT_MIPS_software_pipeline_depth";
7855 case DW_AT_MIPS_linkage_name:
7856 return "DW_AT_MIPS_linkage_name";
7858 case DW_AT_sf_names:
7859 return "DW_AT_sf_names";
7860 case DW_AT_src_info:
7861 return "DW_AT_src_info";
7862 case DW_AT_mac_info:
7863 return "DW_AT_mac_info";
7864 case DW_AT_src_coords:
7865 return "DW_AT_src_coords";
7866 case DW_AT_body_begin:
7867 return "DW_AT_body_begin";
7868 case DW_AT_body_end:
7869 return "DW_AT_body_end";
7870 case DW_AT_GNU_vector:
7871 return "DW_AT_GNU_vector";
7873 return "DW_AT_<unknown>";
7877 /* Convert a DWARF value form code into its string name. */
7880 dwarf_form_name (unsigned form)
7885 return "DW_FORM_addr";
7886 case DW_FORM_block2:
7887 return "DW_FORM_block2";
7888 case DW_FORM_block4:
7889 return "DW_FORM_block4";
7891 return "DW_FORM_data2";
7893 return "DW_FORM_data4";
7895 return "DW_FORM_data8";
7896 case DW_FORM_string:
7897 return "DW_FORM_string";
7899 return "DW_FORM_block";
7900 case DW_FORM_block1:
7901 return "DW_FORM_block1";
7903 return "DW_FORM_data1";
7905 return "DW_FORM_flag";
7907 return "DW_FORM_sdata";
7909 return "DW_FORM_strp";
7911 return "DW_FORM_udata";
7912 case DW_FORM_ref_addr:
7913 return "DW_FORM_ref_addr";
7915 return "DW_FORM_ref1";
7917 return "DW_FORM_ref2";
7919 return "DW_FORM_ref4";
7921 return "DW_FORM_ref8";
7922 case DW_FORM_ref_udata:
7923 return "DW_FORM_ref_udata";
7924 case DW_FORM_indirect:
7925 return "DW_FORM_indirect";
7927 return "DW_FORM_<unknown>";
7931 /* Convert a DWARF stack opcode into its string name. */
7934 dwarf_stack_op_name (unsigned op)
7939 return "DW_OP_addr";
7941 return "DW_OP_deref";
7943 return "DW_OP_const1u";
7945 return "DW_OP_const1s";
7947 return "DW_OP_const2u";
7949 return "DW_OP_const2s";
7951 return "DW_OP_const4u";
7953 return "DW_OP_const4s";
7955 return "DW_OP_const8u";
7957 return "DW_OP_const8s";
7959 return "DW_OP_constu";
7961 return "DW_OP_consts";
7965 return "DW_OP_drop";
7967 return "DW_OP_over";
7969 return "DW_OP_pick";
7971 return "DW_OP_swap";
7975 return "DW_OP_xderef";
7983 return "DW_OP_minus";
7995 return "DW_OP_plus";
7996 case DW_OP_plus_uconst:
7997 return "DW_OP_plus_uconst";
8003 return "DW_OP_shra";
8021 return "DW_OP_skip";
8023 return "DW_OP_lit0";
8025 return "DW_OP_lit1";
8027 return "DW_OP_lit2";
8029 return "DW_OP_lit3";
8031 return "DW_OP_lit4";
8033 return "DW_OP_lit5";
8035 return "DW_OP_lit6";
8037 return "DW_OP_lit7";
8039 return "DW_OP_lit8";
8041 return "DW_OP_lit9";
8043 return "DW_OP_lit10";
8045 return "DW_OP_lit11";
8047 return "DW_OP_lit12";
8049 return "DW_OP_lit13";
8051 return "DW_OP_lit14";
8053 return "DW_OP_lit15";
8055 return "DW_OP_lit16";
8057 return "DW_OP_lit17";
8059 return "DW_OP_lit18";
8061 return "DW_OP_lit19";
8063 return "DW_OP_lit20";
8065 return "DW_OP_lit21";
8067 return "DW_OP_lit22";
8069 return "DW_OP_lit23";
8071 return "DW_OP_lit24";
8073 return "DW_OP_lit25";
8075 return "DW_OP_lit26";
8077 return "DW_OP_lit27";
8079 return "DW_OP_lit28";
8081 return "DW_OP_lit29";
8083 return "DW_OP_lit30";
8085 return "DW_OP_lit31";
8087 return "DW_OP_reg0";
8089 return "DW_OP_reg1";
8091 return "DW_OP_reg2";
8093 return "DW_OP_reg3";
8095 return "DW_OP_reg4";
8097 return "DW_OP_reg5";
8099 return "DW_OP_reg6";
8101 return "DW_OP_reg7";
8103 return "DW_OP_reg8";
8105 return "DW_OP_reg9";
8107 return "DW_OP_reg10";
8109 return "DW_OP_reg11";
8111 return "DW_OP_reg12";
8113 return "DW_OP_reg13";
8115 return "DW_OP_reg14";
8117 return "DW_OP_reg15";
8119 return "DW_OP_reg16";
8121 return "DW_OP_reg17";
8123 return "DW_OP_reg18";
8125 return "DW_OP_reg19";
8127 return "DW_OP_reg20";
8129 return "DW_OP_reg21";
8131 return "DW_OP_reg22";
8133 return "DW_OP_reg23";
8135 return "DW_OP_reg24";
8137 return "DW_OP_reg25";
8139 return "DW_OP_reg26";
8141 return "DW_OP_reg27";
8143 return "DW_OP_reg28";
8145 return "DW_OP_reg29";
8147 return "DW_OP_reg30";
8149 return "DW_OP_reg31";
8151 return "DW_OP_breg0";
8153 return "DW_OP_breg1";
8155 return "DW_OP_breg2";
8157 return "DW_OP_breg3";
8159 return "DW_OP_breg4";
8161 return "DW_OP_breg5";
8163 return "DW_OP_breg6";
8165 return "DW_OP_breg7";
8167 return "DW_OP_breg8";
8169 return "DW_OP_breg9";
8171 return "DW_OP_breg10";
8173 return "DW_OP_breg11";
8175 return "DW_OP_breg12";
8177 return "DW_OP_breg13";
8179 return "DW_OP_breg14";
8181 return "DW_OP_breg15";
8183 return "DW_OP_breg16";
8185 return "DW_OP_breg17";
8187 return "DW_OP_breg18";
8189 return "DW_OP_breg19";
8191 return "DW_OP_breg20";
8193 return "DW_OP_breg21";
8195 return "DW_OP_breg22";
8197 return "DW_OP_breg23";
8199 return "DW_OP_breg24";
8201 return "DW_OP_breg25";
8203 return "DW_OP_breg26";
8205 return "DW_OP_breg27";
8207 return "DW_OP_breg28";
8209 return "DW_OP_breg29";
8211 return "DW_OP_breg30";
8213 return "DW_OP_breg31";
8215 return "DW_OP_regx";
8217 return "DW_OP_fbreg";
8219 return "DW_OP_bregx";
8221 return "DW_OP_piece";
8222 case DW_OP_deref_size:
8223 return "DW_OP_deref_size";
8224 case DW_OP_xderef_size:
8225 return "DW_OP_xderef_size";
8228 /* DWARF 3 extensions. */
8229 case DW_OP_push_object_address:
8230 return "DW_OP_push_object_address";
8232 return "DW_OP_call2";
8234 return "DW_OP_call4";
8235 case DW_OP_call_ref:
8236 return "DW_OP_call_ref";
8237 /* GNU extensions. */
8238 case DW_OP_GNU_push_tls_address:
8239 return "DW_OP_GNU_push_tls_address";
8241 return "OP_<unknown>";
8246 dwarf_bool_name (unsigned mybool)
8254 /* Convert a DWARF type code into its string name. */
8257 dwarf_type_encoding_name (unsigned enc)
8261 case DW_ATE_address:
8262 return "DW_ATE_address";
8263 case DW_ATE_boolean:
8264 return "DW_ATE_boolean";
8265 case DW_ATE_complex_float:
8266 return "DW_ATE_complex_float";
8268 return "DW_ATE_float";
8270 return "DW_ATE_signed";
8271 case DW_ATE_signed_char:
8272 return "DW_ATE_signed_char";
8273 case DW_ATE_unsigned:
8274 return "DW_ATE_unsigned";
8275 case DW_ATE_unsigned_char:
8276 return "DW_ATE_unsigned_char";
8277 case DW_ATE_imaginary_float:
8278 return "DW_ATE_imaginary_float";
8280 return "DW_ATE_<unknown>";
8284 /* Convert a DWARF call frame info operation to its string name. */
8288 dwarf_cfi_name (unsigned cfi_opc)
8292 case DW_CFA_advance_loc:
8293 return "DW_CFA_advance_loc";
8295 return "DW_CFA_offset";
8296 case DW_CFA_restore:
8297 return "DW_CFA_restore";
8299 return "DW_CFA_nop";
8300 case DW_CFA_set_loc:
8301 return "DW_CFA_set_loc";
8302 case DW_CFA_advance_loc1:
8303 return "DW_CFA_advance_loc1";
8304 case DW_CFA_advance_loc2:
8305 return "DW_CFA_advance_loc2";
8306 case DW_CFA_advance_loc4:
8307 return "DW_CFA_advance_loc4";
8308 case DW_CFA_offset_extended:
8309 return "DW_CFA_offset_extended";
8310 case DW_CFA_restore_extended:
8311 return "DW_CFA_restore_extended";
8312 case DW_CFA_undefined:
8313 return "DW_CFA_undefined";
8314 case DW_CFA_same_value:
8315 return "DW_CFA_same_value";
8316 case DW_CFA_register:
8317 return "DW_CFA_register";
8318 case DW_CFA_remember_state:
8319 return "DW_CFA_remember_state";
8320 case DW_CFA_restore_state:
8321 return "DW_CFA_restore_state";
8322 case DW_CFA_def_cfa:
8323 return "DW_CFA_def_cfa";
8324 case DW_CFA_def_cfa_register:
8325 return "DW_CFA_def_cfa_register";
8326 case DW_CFA_def_cfa_offset:
8327 return "DW_CFA_def_cfa_offset";
8330 case DW_CFA_def_cfa_expression:
8331 return "DW_CFA_def_cfa_expression";
8332 case DW_CFA_expression:
8333 return "DW_CFA_expression";
8334 case DW_CFA_offset_extended_sf:
8335 return "DW_CFA_offset_extended_sf";
8336 case DW_CFA_def_cfa_sf:
8337 return "DW_CFA_def_cfa_sf";
8338 case DW_CFA_def_cfa_offset_sf:
8339 return "DW_CFA_def_cfa_offset_sf";
8341 /* SGI/MIPS specific */
8342 case DW_CFA_MIPS_advance_loc8:
8343 return "DW_CFA_MIPS_advance_loc8";
8345 /* GNU extensions */
8346 case DW_CFA_GNU_window_save:
8347 return "DW_CFA_GNU_window_save";
8348 case DW_CFA_GNU_args_size:
8349 return "DW_CFA_GNU_args_size";
8350 case DW_CFA_GNU_negative_offset_extended:
8351 return "DW_CFA_GNU_negative_offset_extended";
8354 return "DW_CFA_<unknown>";
8360 dump_die (struct die_info *die)
8364 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8365 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8366 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8367 dwarf_bool_name (die->child != NULL));
8369 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8370 for (i = 0; i < die->num_attrs; ++i)
8372 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8373 dwarf_attr_name (die->attrs[i].name),
8374 dwarf_form_name (die->attrs[i].form));
8375 switch (die->attrs[i].form)
8377 case DW_FORM_ref_addr:
8379 fprintf_unfiltered (gdb_stderr, "address: ");
8380 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8382 case DW_FORM_block2:
8383 case DW_FORM_block4:
8385 case DW_FORM_block1:
8386 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8391 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8392 (long) (DW_ADDR (&die->attrs[i])));
8400 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8402 case DW_FORM_string:
8404 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8405 DW_STRING (&die->attrs[i])
8406 ? DW_STRING (&die->attrs[i]) : "");
8409 if (DW_UNSND (&die->attrs[i]))
8410 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8412 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8414 case DW_FORM_indirect:
8415 /* the reader will have reduced the indirect form to
8416 the "base form" so this form should not occur */
8417 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8420 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8421 die->attrs[i].form);
8423 fprintf_unfiltered (gdb_stderr, "\n");
8428 dump_die_list (struct die_info *die)
8433 if (die->child != NULL)
8434 dump_die_list (die->child);
8435 if (die->sibling != NULL)
8436 dump_die_list (die->sibling);
8441 store_in_ref_table (unsigned int offset, struct die_info *die,
8442 struct dwarf2_cu *cu)
8445 struct die_info *old;
8447 h = (offset % REF_HASH_SIZE);
8448 old = cu->die_ref_table[h];
8449 die->next_ref = old;
8450 cu->die_ref_table[h] = die;
8454 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8456 unsigned int result = 0;
8460 case DW_FORM_ref_addr:
8465 case DW_FORM_ref_udata:
8466 result = DW_ADDR (attr);
8469 complaint (&symfile_complaints,
8470 _("unsupported die ref attribute form: '%s'"),
8471 dwarf_form_name (attr->form));
8476 /* Return the constant value held by the given attribute. Return -1
8477 if the value held by the attribute is not constant. */
8480 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8482 if (attr->form == DW_FORM_sdata)
8483 return DW_SND (attr);
8484 else if (attr->form == DW_FORM_udata
8485 || attr->form == DW_FORM_data1
8486 || attr->form == DW_FORM_data2
8487 || attr->form == DW_FORM_data4
8488 || attr->form == DW_FORM_data8)
8489 return DW_UNSND (attr);
8492 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8493 dwarf_form_name (attr->form));
8494 return default_value;
8498 static struct die_info *
8499 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8500 struct dwarf2_cu *cu)
8502 struct die_info *die;
8503 unsigned int offset;
8505 struct die_info temp_die;
8506 struct dwarf2_cu *target_cu;
8508 offset = dwarf2_get_ref_die_offset (attr, cu);
8510 if (DW_ADDR (attr) < cu->header.offset
8511 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
8513 struct dwarf2_per_cu_data *per_cu;
8514 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
8516 target_cu = per_cu->cu;
8521 h = (offset % REF_HASH_SIZE);
8522 die = target_cu->die_ref_table[h];
8525 if (die->offset == offset)
8527 die = die->next_ref;
8530 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8531 "at 0x%lx [in module %s]"),
8532 (long) src_die->offset, (long) offset, cu->objfile->name);
8537 static struct type *
8538 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
8539 struct dwarf2_cu *cu)
8541 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
8543 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8544 typeid, objfile->name);
8547 /* Look for this particular type in the fundamental type vector. If
8548 one is not found, create and install one appropriate for the
8549 current language and the current target machine. */
8551 if (cu->ftypes[typeid] == NULL)
8553 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8556 return (cu->ftypes[typeid]);
8559 /* Decode simple location descriptions.
8560 Given a pointer to a dwarf block that defines a location, compute
8561 the location and return the value.
8563 NOTE drow/2003-11-18: This function is called in two situations
8564 now: for the address of static or global variables (partial symbols
8565 only) and for offsets into structures which are expected to be
8566 (more or less) constant. The partial symbol case should go away,
8567 and only the constant case should remain. That will let this
8568 function complain more accurately. A few special modes are allowed
8569 without complaint for global variables (for instance, global
8570 register values and thread-local values).
8572 A location description containing no operations indicates that the
8573 object is optimized out. The return value is 0 for that case.
8574 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8575 callers will only want a very basic result and this can become a
8578 Note that stack[0] is unused except as a default error return.
8579 Note that stack overflow is not yet handled. */
8582 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8584 struct objfile *objfile = cu->objfile;
8585 struct comp_unit_head *cu_header = &cu->header;
8587 int size = blk->size;
8588 char *data = blk->data;
8589 CORE_ADDR stack[64];
8591 unsigned int bytes_read, unsnd;
8635 stack[++stacki] = op - DW_OP_lit0;
8670 stack[++stacki] = op - DW_OP_reg0;
8672 dwarf2_complex_location_expr_complaint ();
8676 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8678 stack[++stacki] = unsnd;
8680 dwarf2_complex_location_expr_complaint ();
8684 stack[++stacki] = read_address (objfile->obfd, &data[i],
8690 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8695 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8700 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8705 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8710 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8715 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8720 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8726 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8731 stack[stacki + 1] = stack[stacki];
8736 stack[stacki - 1] += stack[stacki];
8740 case DW_OP_plus_uconst:
8741 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8746 stack[stacki - 1] -= stack[stacki];
8751 /* If we're not the last op, then we definitely can't encode
8752 this using GDB's address_class enum. This is valid for partial
8753 global symbols, although the variable's address will be bogus
8756 dwarf2_complex_location_expr_complaint ();
8759 case DW_OP_GNU_push_tls_address:
8760 /* The top of the stack has the offset from the beginning
8761 of the thread control block at which the variable is located. */
8762 /* Nothing should follow this operator, so the top of stack would
8764 /* This is valid for partial global symbols, but the variable's
8765 address will be bogus in the psymtab. */
8767 dwarf2_complex_location_expr_complaint ();
8771 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
8772 dwarf_stack_op_name (op));
8773 return (stack[stacki]);
8776 return (stack[stacki]);
8779 /* memory allocation interface */
8781 static struct dwarf_block *
8782 dwarf_alloc_block (struct dwarf2_cu *cu)
8784 struct dwarf_block *blk;
8786 blk = (struct dwarf_block *)
8787 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8791 static struct abbrev_info *
8792 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8794 struct abbrev_info *abbrev;
8796 abbrev = (struct abbrev_info *)
8797 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
8798 memset (abbrev, 0, sizeof (struct abbrev_info));
8802 static struct die_info *
8803 dwarf_alloc_die (void)
8805 struct die_info *die;
8807 die = (struct die_info *) xmalloc (sizeof (struct die_info));
8808 memset (die, 0, sizeof (struct die_info));
8813 /* Macro support. */
8816 /* Return the full name of file number I in *LH's file name table.
8817 Use COMP_DIR as the name of the current directory of the
8818 compilation. The result is allocated using xmalloc; the caller is
8819 responsible for freeing it. */
8821 file_full_name (int file, struct line_header *lh, const char *comp_dir)
8823 /* Is the file number a valid index into the line header's file name
8824 table? Remember that file numbers start with one, not zero. */
8825 if (1 <= file && file <= lh->num_file_names)
8827 struct file_entry *fe = &lh->file_names[file - 1];
8829 if (IS_ABSOLUTE_PATH (fe->name))
8830 return xstrdup (fe->name);
8838 dir = lh->include_dirs[fe->dir_index - 1];
8844 dir_len = strlen (dir);
8845 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
8846 strcpy (full_name, dir);
8847 full_name[dir_len] = '/';
8848 strcpy (full_name + dir_len + 1, fe->name);
8852 return xstrdup (fe->name);
8857 /* The compiler produced a bogus file number. We can at least
8858 record the macro definitions made in the file, even if we
8859 won't be able to find the file by name. */
8861 sprintf (fake_name, "<bad macro file number %d>", file);
8863 complaint (&symfile_complaints,
8864 _("bad file number in macro information (%d)"),
8867 return xstrdup (fake_name);
8872 static struct macro_source_file *
8873 macro_start_file (int file, int line,
8874 struct macro_source_file *current_file,
8875 const char *comp_dir,
8876 struct line_header *lh, struct objfile *objfile)
8878 /* The full name of this source file. */
8879 char *full_name = file_full_name (file, lh, comp_dir);
8881 /* We don't create a macro table for this compilation unit
8882 at all until we actually get a filename. */
8883 if (! pending_macros)
8884 pending_macros = new_macro_table (&objfile->objfile_obstack,
8885 objfile->macro_cache);
8888 /* If we have no current file, then this must be the start_file
8889 directive for the compilation unit's main source file. */
8890 current_file = macro_set_main (pending_macros, full_name);
8892 current_file = macro_include (current_file, line, full_name);
8896 return current_file;
8900 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8901 followed by a null byte. */
8903 copy_string (const char *buf, int len)
8905 char *s = xmalloc (len + 1);
8906 memcpy (s, buf, len);
8914 consume_improper_spaces (const char *p, const char *body)
8918 complaint (&symfile_complaints,
8919 _("macro definition contains spaces in formal argument list:\n`%s'"),
8931 parse_macro_definition (struct macro_source_file *file, int line,
8936 /* The body string takes one of two forms. For object-like macro
8937 definitions, it should be:
8939 <macro name> " " <definition>
8941 For function-like macro definitions, it should be:
8943 <macro name> "() " <definition>
8945 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8947 Spaces may appear only where explicitly indicated, and in the
8950 The Dwarf 2 spec says that an object-like macro's name is always
8951 followed by a space, but versions of GCC around March 2002 omit
8952 the space when the macro's definition is the empty string.
8954 The Dwarf 2 spec says that there should be no spaces between the
8955 formal arguments in a function-like macro's formal argument list,
8956 but versions of GCC around March 2002 include spaces after the
8960 /* Find the extent of the macro name. The macro name is terminated
8961 by either a space or null character (for an object-like macro) or
8962 an opening paren (for a function-like macro). */
8963 for (p = body; *p; p++)
8964 if (*p == ' ' || *p == '(')
8967 if (*p == ' ' || *p == '\0')
8969 /* It's an object-like macro. */
8970 int name_len = p - body;
8971 char *name = copy_string (body, name_len);
8972 const char *replacement;
8975 replacement = body + name_len + 1;
8978 dwarf2_macro_malformed_definition_complaint (body);
8979 replacement = body + name_len;
8982 macro_define_object (file, line, name, replacement);
8988 /* It's a function-like macro. */
8989 char *name = copy_string (body, p - body);
8992 char **argv = xmalloc (argv_size * sizeof (*argv));
8996 p = consume_improper_spaces (p, body);
8998 /* Parse the formal argument list. */
8999 while (*p && *p != ')')
9001 /* Find the extent of the current argument name. */
9002 const char *arg_start = p;
9004 while (*p && *p != ',' && *p != ')' && *p != ' ')
9007 if (! *p || p == arg_start)
9008 dwarf2_macro_malformed_definition_complaint (body);
9011 /* Make sure argv has room for the new argument. */
9012 if (argc >= argv_size)
9015 argv = xrealloc (argv, argv_size * sizeof (*argv));
9018 argv[argc++] = copy_string (arg_start, p - arg_start);
9021 p = consume_improper_spaces (p, body);
9023 /* Consume the comma, if present. */
9028 p = consume_improper_spaces (p, body);
9037 /* Perfectly formed definition, no complaints. */
9038 macro_define_function (file, line, name,
9039 argc, (const char **) argv,
9041 else if (*p == '\0')
9043 /* Complain, but do define it. */
9044 dwarf2_macro_malformed_definition_complaint (body);
9045 macro_define_function (file, line, name,
9046 argc, (const char **) argv,
9050 /* Just complain. */
9051 dwarf2_macro_malformed_definition_complaint (body);
9054 /* Just complain. */
9055 dwarf2_macro_malformed_definition_complaint (body);
9061 for (i = 0; i < argc; i++)
9067 dwarf2_macro_malformed_definition_complaint (body);
9072 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9073 char *comp_dir, bfd *abfd,
9074 struct dwarf2_cu *cu)
9076 char *mac_ptr, *mac_end;
9077 struct macro_source_file *current_file = 0;
9079 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9081 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9085 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9086 mac_end = dwarf2_per_objfile->macinfo_buffer
9087 + dwarf2_per_objfile->macinfo_size;
9091 enum dwarf_macinfo_record_type macinfo_type;
9093 /* Do we at least have room for a macinfo type byte? */
9094 if (mac_ptr >= mac_end)
9096 dwarf2_macros_too_long_complaint ();
9100 macinfo_type = read_1_byte (abfd, mac_ptr);
9103 switch (macinfo_type)
9105 /* A zero macinfo type indicates the end of the macro
9110 case DW_MACINFO_define:
9111 case DW_MACINFO_undef:
9113 unsigned int bytes_read;
9117 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9118 mac_ptr += bytes_read;
9119 body = read_string (abfd, mac_ptr, &bytes_read);
9120 mac_ptr += bytes_read;
9123 complaint (&symfile_complaints,
9124 _("debug info gives macro %s outside of any file: %s"),
9126 DW_MACINFO_define ? "definition" : macinfo_type ==
9127 DW_MACINFO_undef ? "undefinition" :
9128 "something-or-other", body);
9131 if (macinfo_type == DW_MACINFO_define)
9132 parse_macro_definition (current_file, line, body);
9133 else if (macinfo_type == DW_MACINFO_undef)
9134 macro_undef (current_file, line, body);
9139 case DW_MACINFO_start_file:
9141 unsigned int bytes_read;
9144 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9145 mac_ptr += bytes_read;
9146 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9147 mac_ptr += bytes_read;
9149 current_file = macro_start_file (file, line,
9150 current_file, comp_dir,
9155 case DW_MACINFO_end_file:
9157 complaint (&symfile_complaints,
9158 _("macro debug info has an unmatched `close_file' directive"));
9161 current_file = current_file->included_by;
9164 enum dwarf_macinfo_record_type next_type;
9166 /* GCC circa March 2002 doesn't produce the zero
9167 type byte marking the end of the compilation
9168 unit. Complain if it's not there, but exit no
9171 /* Do we at least have room for a macinfo type byte? */
9172 if (mac_ptr >= mac_end)
9174 dwarf2_macros_too_long_complaint ();
9178 /* We don't increment mac_ptr here, so this is just
9180 next_type = read_1_byte (abfd, mac_ptr);
9182 complaint (&symfile_complaints,
9183 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9190 case DW_MACINFO_vendor_ext:
9192 unsigned int bytes_read;
9196 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9197 mac_ptr += bytes_read;
9198 string = read_string (abfd, mac_ptr, &bytes_read);
9199 mac_ptr += bytes_read;
9201 /* We don't recognize any vendor extensions. */
9208 /* Check if the attribute's form is a DW_FORM_block*
9209 if so return true else false. */
9211 attr_form_is_block (struct attribute *attr)
9213 return (attr == NULL ? 0 :
9214 attr->form == DW_FORM_block1
9215 || attr->form == DW_FORM_block2
9216 || attr->form == DW_FORM_block4
9217 || attr->form == DW_FORM_block);
9221 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9222 struct dwarf2_cu *cu)
9224 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9226 struct dwarf2_loclist_baton *baton;
9228 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9229 sizeof (struct dwarf2_loclist_baton));
9230 baton->objfile = cu->objfile;
9232 /* We don't know how long the location list is, but make sure we
9233 don't run off the edge of the section. */
9234 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9235 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9236 baton->base_address = cu->header.base_address;
9237 if (cu->header.base_known == 0)
9238 complaint (&symfile_complaints,
9239 _("Location list used without specifying the CU base address."));
9241 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9242 SYMBOL_LOCATION_BATON (sym) = baton;
9246 struct dwarf2_locexpr_baton *baton;
9248 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9249 sizeof (struct dwarf2_locexpr_baton));
9250 baton->objfile = cu->objfile;
9252 if (attr_form_is_block (attr))
9254 /* Note that we're just copying the block's data pointer
9255 here, not the actual data. We're still pointing into the
9256 info_buffer for SYM's objfile; right now we never release
9257 that buffer, but when we do clean up properly this may
9259 baton->size = DW_BLOCK (attr)->size;
9260 baton->data = DW_BLOCK (attr)->data;
9264 dwarf2_invalid_attrib_class_complaint ("location description",
9265 SYMBOL_NATURAL_NAME (sym));
9270 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9271 SYMBOL_LOCATION_BATON (sym) = baton;
9275 /* Locate the compilation unit from CU's objfile which contains the
9276 DIE at OFFSET. Raises an error on failure. */
9278 static struct dwarf2_per_cu_data *
9279 dwarf2_find_containing_comp_unit (unsigned long offset,
9280 struct objfile *objfile)
9282 struct dwarf2_per_cu_data *this_cu;
9286 high = dwarf2_per_objfile->n_comp_units - 1;
9289 int mid = low + (high - low) / 2;
9290 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9295 gdb_assert (low == high);
9296 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9299 error (_("Dwarf Error: could not find partial DIE containing "
9300 "offset 0x%lx [in module %s]"),
9301 (long) offset, bfd_get_filename (objfile->obfd));
9303 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9304 return dwarf2_per_objfile->all_comp_units[low-1];
9308 this_cu = dwarf2_per_objfile->all_comp_units[low];
9309 if (low == dwarf2_per_objfile->n_comp_units - 1
9310 && offset >= this_cu->offset + this_cu->length)
9311 error (_("invalid dwarf2 offset %ld"), offset);
9312 gdb_assert (offset < this_cu->offset + this_cu->length);
9317 /* Locate the compilation unit from OBJFILE which is located at exactly
9318 OFFSET. Raises an error on failure. */
9320 static struct dwarf2_per_cu_data *
9321 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9323 struct dwarf2_per_cu_data *this_cu;
9324 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9325 if (this_cu->offset != offset)
9326 error (_("no compilation unit with offset %ld."), offset);
9330 /* Release one cached compilation unit, CU. We unlink it from the tree
9331 of compilation units, but we don't remove it from the read_in_chain;
9332 the caller is responsible for that. */
9335 free_one_comp_unit (void *data)
9337 struct dwarf2_cu *cu = data;
9339 if (cu->per_cu != NULL)
9340 cu->per_cu->cu = NULL;
9343 obstack_free (&cu->comp_unit_obstack, NULL);
9345 free_die_list (cu->dies);
9350 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9351 when we're finished with it. We can't free the pointer itself, but be
9352 sure to unlink it from the cache. Also release any associated storage
9353 and perform cache maintenance.
9355 Only used during partial symbol parsing. */
9358 free_stack_comp_unit (void *data)
9360 struct dwarf2_cu *cu = data;
9362 obstack_free (&cu->comp_unit_obstack, NULL);
9363 cu->partial_dies = NULL;
9365 if (cu->per_cu != NULL)
9367 /* This compilation unit is on the stack in our caller, so we
9368 should not xfree it. Just unlink it. */
9369 cu->per_cu->cu = NULL;
9372 /* If we had a per-cu pointer, then we may have other compilation
9373 units loaded, so age them now. */
9374 age_cached_comp_units ();
9378 /* Free all cached compilation units. */
9381 free_cached_comp_units (void *data)
9383 struct dwarf2_per_cu_data *per_cu, **last_chain;
9385 per_cu = dwarf2_per_objfile->read_in_chain;
9386 last_chain = &dwarf2_per_objfile->read_in_chain;
9387 while (per_cu != NULL)
9389 struct dwarf2_per_cu_data *next_cu;
9391 next_cu = per_cu->cu->read_in_chain;
9393 free_one_comp_unit (per_cu->cu);
9394 *last_chain = next_cu;
9400 /* Increase the age counter on each cached compilation unit, and free
9401 any that are too old. */
9404 age_cached_comp_units (void)
9406 struct dwarf2_per_cu_data *per_cu, **last_chain;
9408 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9409 per_cu = dwarf2_per_objfile->read_in_chain;
9410 while (per_cu != NULL)
9412 per_cu->cu->last_used ++;
9413 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9414 dwarf2_mark (per_cu->cu);
9415 per_cu = per_cu->cu->read_in_chain;
9418 per_cu = dwarf2_per_objfile->read_in_chain;
9419 last_chain = &dwarf2_per_objfile->read_in_chain;
9420 while (per_cu != NULL)
9422 struct dwarf2_per_cu_data *next_cu;
9424 next_cu = per_cu->cu->read_in_chain;
9426 if (!per_cu->cu->mark)
9428 free_one_comp_unit (per_cu->cu);
9429 *last_chain = next_cu;
9432 last_chain = &per_cu->cu->read_in_chain;
9438 /* Remove a single compilation unit from the cache. */
9441 free_one_cached_comp_unit (void *target_cu)
9443 struct dwarf2_per_cu_data *per_cu, **last_chain;
9445 per_cu = dwarf2_per_objfile->read_in_chain;
9446 last_chain = &dwarf2_per_objfile->read_in_chain;
9447 while (per_cu != NULL)
9449 struct dwarf2_per_cu_data *next_cu;
9451 next_cu = per_cu->cu->read_in_chain;
9453 if (per_cu->cu == target_cu)
9455 free_one_comp_unit (per_cu->cu);
9456 *last_chain = next_cu;
9460 last_chain = &per_cu->cu->read_in_chain;
9466 /* A pair of DIE offset and GDB type pointer. We store these
9467 in a hash table separate from the DIEs, and preserve them
9468 when the DIEs are flushed out of cache. */
9470 struct dwarf2_offset_and_type
9472 unsigned int offset;
9476 /* Hash function for a dwarf2_offset_and_type. */
9479 offset_and_type_hash (const void *item)
9481 const struct dwarf2_offset_and_type *ofs = item;
9485 /* Equality function for a dwarf2_offset_and_type. */
9488 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9490 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9491 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9492 return ofs_lhs->offset == ofs_rhs->offset;
9495 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9496 table if necessary. */
9499 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
9501 struct dwarf2_offset_and_type **slot, ofs;
9505 if (cu->per_cu == NULL)
9508 if (cu->per_cu->type_hash == NULL)
9509 cu->per_cu->type_hash
9510 = htab_create_alloc_ex (cu->header.length / 24,
9511 offset_and_type_hash,
9514 &cu->objfile->objfile_obstack,
9515 hashtab_obstack_allocate,
9516 dummy_obstack_deallocate);
9518 ofs.offset = die->offset;
9520 slot = (struct dwarf2_offset_and_type **)
9521 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
9522 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
9526 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9527 have a saved type. */
9529 static struct type *
9530 get_die_type (struct die_info *die, htab_t type_hash)
9532 struct dwarf2_offset_and_type *slot, ofs;
9534 ofs.offset = die->offset;
9535 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
9542 /* Restore the types of the DIE tree starting at START_DIE from the hash
9543 table saved in CU. */
9546 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
9548 struct die_info *die;
9550 if (cu->per_cu->type_hash == NULL)
9553 for (die = start_die; die != NULL; die = die->sibling)
9555 die->type = get_die_type (die, cu->per_cu->type_hash);
9556 if (die->child != NULL)
9557 reset_die_and_siblings_types (die->child, cu);
9561 /* Set the mark field in CU and in every other compilation unit in the
9562 cache that we must keep because we are keeping CU. */
9564 /* Add a dependence relationship from CU to REF_PER_CU. */
9567 dwarf2_add_dependence (struct dwarf2_cu *cu,
9568 struct dwarf2_per_cu_data *ref_per_cu)
9572 if (cu->dependencies == NULL)
9574 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
9575 NULL, &cu->comp_unit_obstack,
9576 hashtab_obstack_allocate,
9577 dummy_obstack_deallocate);
9579 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
9584 /* Set the mark field in CU and in every other compilation unit in the
9585 cache that we must keep because we are keeping CU. */
9588 dwarf2_mark_helper (void **slot, void *data)
9590 struct dwarf2_per_cu_data *per_cu;
9592 per_cu = (struct dwarf2_per_cu_data *) *slot;
9593 if (per_cu->cu->mark)
9595 per_cu->cu->mark = 1;
9597 if (per_cu->cu->dependencies != NULL)
9598 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
9604 dwarf2_mark (struct dwarf2_cu *cu)
9609 if (cu->dependencies != NULL)
9610 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
9614 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
9618 per_cu->cu->mark = 0;
9619 per_cu = per_cu->cu->read_in_chain;
9623 /* Allocation function for the libiberty hash table which uses an
9627 hashtab_obstack_allocate (void *data, size_t size, size_t count)
9629 unsigned int total = size * count;
9630 void *ptr = obstack_alloc ((struct obstack *) data, total);
9631 memset (ptr, 0, total);
9635 /* Trivial deallocation function for the libiberty splay tree and hash
9636 table - don't deallocate anything. Rely on later deletion of the
9640 dummy_obstack_deallocate (void *object, void *data)
9645 /* Trivial hash function for partial_die_info: the hash value of a DIE
9646 is its offset in .debug_info for this objfile. */
9649 partial_die_hash (const void *item)
9651 const struct partial_die_info *part_die = item;
9652 return part_die->offset;
9655 /* Trivial comparison function for partial_die_info structures: two DIEs
9656 are equal if they have the same offset. */
9659 partial_die_eq (const void *item_lhs, const void *item_rhs)
9661 const struct partial_die_info *part_die_lhs = item_lhs;
9662 const struct partial_die_info *part_die_rhs = item_rhs;
9663 return part_die_lhs->offset == part_die_rhs->offset;
9666 static struct cmd_list_element *set_dwarf2_cmdlist;
9667 static struct cmd_list_element *show_dwarf2_cmdlist;
9670 set_dwarf2_cmd (char *args, int from_tty)
9672 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
9676 show_dwarf2_cmd (char *args, int from_tty)
9678 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
9681 void _initialize_dwarf2_read (void);
9684 _initialize_dwarf2_read (void)
9686 dwarf2_objfile_data_key = register_objfile_data ();
9688 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
9689 Set DWARF 2 specific variables.\n\
9690 Configure DWARF 2 variables such as the cache size"),
9691 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
9692 0/*allow-unknown*/, &maintenance_set_cmdlist);
9694 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
9695 Show DWARF 2 specific variables\n\
9696 Show DWARF 2 variables such as the cache size"),
9697 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
9698 0/*allow-unknown*/, &maintenance_show_cmdlist);
9700 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
9701 &dwarf2_max_cache_age, _("\
9702 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9703 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9704 A higher limit means that cached compilation units will be stored\n\
9705 in memory longer, and more total memory will be used. Zero disables\n\
9706 caching, which can slow down startup."),
9708 show_dwarf2_max_cache_age,
9709 &set_dwarf2_cmdlist,
9710 &show_dwarf2_cmdlist);