1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006
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. */
165 gdb_byte *info_buffer;
166 gdb_byte *abbrev_buffer;
167 gdb_byte *line_buffer;
168 gdb_byte *str_buffer;
169 gdb_byte *macinfo_buffer;
170 gdb_byte *ranges_buffer;
171 gdb_byte *loc_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;
184 /* A flag indicating wether this objfile has a section loaded at a
186 int has_section_at_zero;
189 static struct dwarf2_per_objfile *dwarf2_per_objfile;
191 static asection *dwarf_info_section;
192 static asection *dwarf_abbrev_section;
193 static asection *dwarf_line_section;
194 static asection *dwarf_pubnames_section;
195 static asection *dwarf_aranges_section;
196 static asection *dwarf_loc_section;
197 static asection *dwarf_macinfo_section;
198 static asection *dwarf_str_section;
199 static asection *dwarf_ranges_section;
200 asection *dwarf_frame_section;
201 asection *dwarf_eh_frame_section;
203 /* names of the debugging sections */
205 #define INFO_SECTION ".debug_info"
206 #define ABBREV_SECTION ".debug_abbrev"
207 #define LINE_SECTION ".debug_line"
208 #define PUBNAMES_SECTION ".debug_pubnames"
209 #define ARANGES_SECTION ".debug_aranges"
210 #define LOC_SECTION ".debug_loc"
211 #define MACINFO_SECTION ".debug_macinfo"
212 #define STR_SECTION ".debug_str"
213 #define RANGES_SECTION ".debug_ranges"
214 #define FRAME_SECTION ".debug_frame"
215 #define EH_FRAME_SECTION ".eh_frame"
217 /* local data types */
219 /* We hold several abbreviation tables in memory at the same time. */
220 #ifndef ABBREV_HASH_SIZE
221 #define ABBREV_HASH_SIZE 121
224 /* The data in a compilation unit header, after target2host
225 translation, looks like this. */
226 struct comp_unit_head
228 unsigned long length;
230 unsigned int abbrev_offset;
231 unsigned char addr_size;
232 unsigned char signed_addr_p;
234 /* Size of file offsets; either 4 or 8. */
235 unsigned int offset_size;
237 /* Size of the length field; either 4 or 12. */
238 unsigned int initial_length_size;
240 /* Offset to the first byte of this compilation unit header in the
241 .debug_info section, for resolving relative reference dies. */
244 /* Pointer to this compilation unit header in the .debug_info
246 gdb_byte *cu_head_ptr;
248 /* Pointer to the first die of this compilation unit. This will be
249 the first byte following the compilation unit header. */
250 gdb_byte *first_die_ptr;
252 /* Pointer to the next compilation unit header in the program. */
253 struct comp_unit_head *next;
255 /* Base address of this compilation unit. */
256 CORE_ADDR base_address;
258 /* Non-zero if base_address has been set. */
262 /* Fixed size for the DIE hash table. */
263 #ifndef REF_HASH_SIZE
264 #define REF_HASH_SIZE 1021
267 /* Internal state when decoding a particular compilation unit. */
270 /* The objfile containing this compilation unit. */
271 struct objfile *objfile;
273 /* The header of the compilation unit.
275 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
276 should logically be moved to the dwarf2_cu structure. */
277 struct comp_unit_head header;
279 struct function_range *first_fn, *last_fn, *cached_fn;
281 /* The language we are debugging. */
282 enum language language;
283 const struct language_defn *language_defn;
285 const char *producer;
287 /* The generic symbol table building routines have separate lists for
288 file scope symbols and all all other scopes (local scopes). So
289 we need to select the right one to pass to add_symbol_to_list().
290 We do it by keeping a pointer to the correct list in list_in_scope.
292 FIXME: The original dwarf code just treated the file scope as the
293 first local scope, and all other local scopes as nested local
294 scopes, and worked fine. Check to see if we really need to
295 distinguish these in buildsym.c. */
296 struct pending **list_in_scope;
298 /* Maintain an array of referenced fundamental types for the current
299 compilation unit being read. For DWARF version 1, we have to construct
300 the fundamental types on the fly, since no information about the
301 fundamental types is supplied. Each such fundamental type is created by
302 calling a language dependent routine to create the type, and then a
303 pointer to that type is then placed in the array at the index specified
304 by it's FT_<TYPENAME> value. The array has a fixed size set by the
305 FT_NUM_MEMBERS compile time constant, which is the number of predefined
306 fundamental types gdb knows how to construct. */
307 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
309 /* DWARF abbreviation table associated with this compilation unit. */
310 struct abbrev_info **dwarf2_abbrevs;
312 /* Storage for the abbrev table. */
313 struct obstack abbrev_obstack;
315 /* Hash table holding all the loaded partial DIEs. */
318 /* Storage for things with the same lifetime as this read-in compilation
319 unit, including partial DIEs. */
320 struct obstack comp_unit_obstack;
322 /* When multiple dwarf2_cu structures are living in memory, this field
323 chains them all together, so that they can be released efficiently.
324 We will probably also want a generation counter so that most-recently-used
325 compilation units are cached... */
326 struct dwarf2_per_cu_data *read_in_chain;
328 /* Backchain to our per_cu entry if the tree has been built. */
329 struct dwarf2_per_cu_data *per_cu;
331 /* How many compilation units ago was this CU last referenced? */
334 /* A hash table of die offsets for following references. */
335 struct die_info *die_ref_table[REF_HASH_SIZE];
337 /* Full DIEs if read in. */
338 struct die_info *dies;
340 /* A set of pointers to dwarf2_per_cu_data objects for compilation
341 units referenced by this one. Only set during full symbol processing;
342 partial symbol tables do not have dependencies. */
345 /* Mark used when releasing cached dies. */
346 unsigned int mark : 1;
348 /* This flag will be set if this compilation unit might include
349 inter-compilation-unit references. */
350 unsigned int has_form_ref_addr : 1;
352 /* This flag will be set if this compilation unit includes any
353 DW_TAG_namespace DIEs. If we know that there are explicit
354 DIEs for namespaces, we don't need to try to infer them
355 from mangled names. */
356 unsigned int has_namespace_info : 1;
359 /* Persistent data held for a compilation unit, even when not
360 processing it. We put a pointer to this structure in the
361 read_symtab_private field of the psymtab. If we encounter
362 inter-compilation-unit references, we also maintain a sorted
363 list of all compilation units. */
365 struct dwarf2_per_cu_data
367 /* The start offset and length of this compilation unit. 2**30-1
368 bytes should suffice to store the length of any compilation unit
369 - if it doesn't, GDB will fall over anyway. */
370 unsigned long offset;
371 unsigned long length : 30;
373 /* Flag indicating this compilation unit will be read in before
374 any of the current compilation units are processed. */
375 unsigned long queued : 1;
377 /* This flag will be set if we need to load absolutely all DIEs
378 for this compilation unit, instead of just the ones we think
379 are interesting. It gets set if we look for a DIE in the
380 hash table and don't find it. */
381 unsigned int load_all_dies : 1;
383 /* Set iff currently read in. */
384 struct dwarf2_cu *cu;
386 /* If full symbols for this CU have been read in, then this field
387 holds a map of DIE offsets to types. It isn't always possible
388 to reconstruct this information later, so we have to preserve
392 /* The partial symbol table associated with this compilation unit. */
393 struct partial_symtab *psymtab;
396 /* The line number information for a compilation unit (found in the
397 .debug_line section) begins with a "statement program header",
398 which contains the following information. */
401 unsigned int total_length;
402 unsigned short version;
403 unsigned int header_length;
404 unsigned char minimum_instruction_length;
405 unsigned char default_is_stmt;
407 unsigned char line_range;
408 unsigned char opcode_base;
410 /* standard_opcode_lengths[i] is the number of operands for the
411 standard opcode whose value is i. This means that
412 standard_opcode_lengths[0] is unused, and the last meaningful
413 element is standard_opcode_lengths[opcode_base - 1]. */
414 unsigned char *standard_opcode_lengths;
416 /* The include_directories table. NOTE! These strings are not
417 allocated with xmalloc; instead, they are pointers into
418 debug_line_buffer. If you try to free them, `free' will get
420 unsigned int num_include_dirs, include_dirs_size;
423 /* The file_names table. NOTE! These strings are not allocated
424 with xmalloc; instead, they are pointers into debug_line_buffer.
425 Don't try to free them directly. */
426 unsigned int num_file_names, file_names_size;
430 unsigned int dir_index;
431 unsigned int mod_time;
433 int included_p; /* Non-zero if referenced by the Line Number Program. */
436 /* The start and end of the statement program following this
437 header. These point into dwarf2_per_objfile->line_buffer. */
438 gdb_byte *statement_program_start, *statement_program_end;
441 /* When we construct a partial symbol table entry we only
442 need this much information. */
443 struct partial_die_info
445 /* Offset of this DIE. */
448 /* DWARF-2 tag for this DIE. */
449 ENUM_BITFIELD(dwarf_tag) tag : 16;
451 /* Language code associated with this DIE. This is only used
452 for the compilation unit DIE. */
453 unsigned int language : 8;
455 /* Assorted flags describing the data found in this DIE. */
456 unsigned int has_children : 1;
457 unsigned int is_external : 1;
458 unsigned int is_declaration : 1;
459 unsigned int has_type : 1;
460 unsigned int has_specification : 1;
461 unsigned int has_stmt_list : 1;
462 unsigned int has_pc_info : 1;
464 /* Flag set if the SCOPE field of this structure has been
466 unsigned int scope_set : 1;
468 /* The name of this DIE. Normally the value of DW_AT_name, but
469 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
474 /* The scope to prepend to our children. This is generally
475 allocated on the comp_unit_obstack, so will disappear
476 when this compilation unit leaves the cache. */
479 /* The location description associated with this DIE, if any. */
480 struct dwarf_block *locdesc;
482 /* If HAS_PC_INFO, the PC range associated with this DIE. */
486 /* Pointer into the info_buffer pointing at the target of
487 DW_AT_sibling, if any. */
490 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
491 DW_AT_specification (or DW_AT_abstract_origin or
493 unsigned int spec_offset;
495 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
496 unsigned int line_offset;
498 /* Pointers to this DIE's parent, first child, and next sibling,
500 struct partial_die_info *die_parent, *die_child, *die_sibling;
503 /* This data structure holds the information of an abbrev. */
506 unsigned int number; /* number identifying abbrev */
507 enum dwarf_tag tag; /* dwarf tag */
508 unsigned short has_children; /* boolean */
509 unsigned short num_attrs; /* number of attributes */
510 struct attr_abbrev *attrs; /* an array of attribute descriptions */
511 struct abbrev_info *next; /* next in chain */
516 enum dwarf_attribute name;
517 enum dwarf_form form;
520 /* This data structure holds a complete die structure. */
523 enum dwarf_tag tag; /* Tag indicating type of die */
524 unsigned int abbrev; /* Abbrev number */
525 unsigned int offset; /* Offset in .debug_info section */
526 unsigned int num_attrs; /* Number of attributes */
527 struct attribute *attrs; /* An array of attributes */
528 struct die_info *next_ref; /* Next die in ref hash table */
530 /* The dies in a compilation unit form an n-ary tree. PARENT
531 points to this die's parent; CHILD points to the first child of
532 this node; and all the children of a given node are chained
533 together via their SIBLING fields, terminated by a die whose
535 struct die_info *child; /* Its first child, if any. */
536 struct die_info *sibling; /* Its next sibling, if any. */
537 struct die_info *parent; /* Its parent, if any. */
539 struct type *type; /* Cached type information */
542 /* Attributes have a name and a value */
545 enum dwarf_attribute name;
546 enum dwarf_form form;
550 struct dwarf_block *blk;
558 struct function_range
561 CORE_ADDR lowpc, highpc;
563 struct function_range *next;
566 /* Get at parts of an attribute structure */
568 #define DW_STRING(attr) ((attr)->u.str)
569 #define DW_UNSND(attr) ((attr)->u.unsnd)
570 #define DW_BLOCK(attr) ((attr)->u.blk)
571 #define DW_SND(attr) ((attr)->u.snd)
572 #define DW_ADDR(attr) ((attr)->u.addr)
574 /* Blocks are a bunch of untyped bytes. */
581 #ifndef ATTR_ALLOC_CHUNK
582 #define ATTR_ALLOC_CHUNK 4
585 /* Allocate fields for structs, unions and enums in this size. */
586 #ifndef DW_FIELD_ALLOC_CHUNK
587 #define DW_FIELD_ALLOC_CHUNK 4
590 /* A zeroed version of a partial die for initialization purposes. */
591 static struct partial_die_info zeroed_partial_die;
593 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
594 but this would require a corresponding change in unpack_field_as_long
596 static int bits_per_byte = 8;
598 /* The routines that read and process dies for a C struct or C++ class
599 pass lists of data member fields and lists of member function fields
600 in an instance of a field_info structure, as defined below. */
603 /* List of data member and baseclasses fields. */
606 struct nextfield *next;
613 /* Number of fields. */
616 /* Number of baseclasses. */
619 /* Set if the accesibility of one of the fields is not public. */
620 int non_public_fields;
622 /* Member function fields array, entries are allocated in the order they
623 are encountered in the object file. */
626 struct nextfnfield *next;
627 struct fn_field fnfield;
631 /* Member function fieldlist array, contains name of possibly overloaded
632 member function, number of overloaded member functions and a pointer
633 to the head of the member function field chain. */
638 struct nextfnfield *head;
642 /* Number of entries in the fnfieldlists array. */
646 /* One item on the queue of compilation units to read in full symbols
648 struct dwarf2_queue_item
650 struct dwarf2_per_cu_data *per_cu;
651 struct dwarf2_queue_item *next;
654 /* The current queue. */
655 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
657 /* Loaded secondary compilation units are kept in memory until they
658 have not been referenced for the processing of this many
659 compilation units. Set this to zero to disable caching. Cache
660 sizes of up to at least twenty will improve startup time for
661 typical inter-CU-reference binaries, at an obvious memory cost. */
662 static int dwarf2_max_cache_age = 5;
664 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
665 struct cmd_list_element *c, const char *value)
667 fprintf_filtered (file, _("\
668 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
673 /* Various complaints about symbol reading that don't abort the process */
676 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
678 complaint (&symfile_complaints,
679 _("statement list doesn't fit in .debug_line section"));
683 dwarf2_complex_location_expr_complaint (void)
685 complaint (&symfile_complaints, _("location expression too complex"));
689 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
692 complaint (&symfile_complaints,
693 _("const value length mismatch for '%s', got %d, expected %d"), arg1,
698 dwarf2_macros_too_long_complaint (void)
700 complaint (&symfile_complaints,
701 _("macro info runs off end of `.debug_macinfo' section"));
705 dwarf2_macro_malformed_definition_complaint (const char *arg1)
707 complaint (&symfile_complaints,
708 _("macro debug info contains a malformed macro definition:\n`%s'"),
713 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
715 complaint (&symfile_complaints,
716 _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
719 /* local function prototypes */
721 static void dwarf2_locate_sections (bfd *, asection *, void *);
724 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
727 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
730 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
731 struct partial_die_info *,
732 struct partial_symtab *);
734 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
736 static void scan_partial_symbols (struct partial_die_info *,
737 CORE_ADDR *, CORE_ADDR *,
740 static void add_partial_symbol (struct partial_die_info *,
743 static int pdi_needs_namespace (enum dwarf_tag tag);
745 static void add_partial_namespace (struct partial_die_info *pdi,
746 CORE_ADDR *lowpc, CORE_ADDR *highpc,
747 struct dwarf2_cu *cu);
749 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
750 struct dwarf2_cu *cu);
752 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
755 struct dwarf2_cu *cu);
757 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
759 static void psymtab_to_symtab_1 (struct partial_symtab *);
761 gdb_byte *dwarf2_read_section (struct objfile *, asection *);
763 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
765 static void dwarf2_free_abbrev_table (void *);
767 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
770 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
773 static struct partial_die_info *load_partial_dies (bfd *, gdb_byte *, int,
776 static gdb_byte *read_partial_die (struct partial_die_info *,
777 struct abbrev_info *abbrev, unsigned int,
778 bfd *, gdb_byte *, struct dwarf2_cu *);
780 static struct partial_die_info *find_partial_die (unsigned long,
783 static void fixup_partial_die (struct partial_die_info *,
786 static gdb_byte *read_full_die (struct die_info **, bfd *, gdb_byte *,
787 struct dwarf2_cu *, int *);
789 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
790 bfd *, gdb_byte *, struct dwarf2_cu *);
792 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
793 bfd *, gdb_byte *, struct dwarf2_cu *);
795 static unsigned int read_1_byte (bfd *, gdb_byte *);
797 static int read_1_signed_byte (bfd *, gdb_byte *);
799 static unsigned int read_2_bytes (bfd *, gdb_byte *);
801 static unsigned int read_4_bytes (bfd *, gdb_byte *);
803 static unsigned long read_8_bytes (bfd *, gdb_byte *);
805 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
808 static LONGEST read_initial_length (bfd *, gdb_byte *,
809 struct comp_unit_head *, unsigned int *);
811 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
814 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
816 static char *read_string (bfd *, gdb_byte *, unsigned int *);
818 static char *read_indirect_string (bfd *, gdb_byte *,
819 const struct comp_unit_head *,
822 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
824 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
826 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
828 static void set_cu_language (unsigned int, struct dwarf2_cu *);
830 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
833 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
834 struct dwarf2_cu *cu);
836 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
838 static struct die_info *die_specification (struct die_info *die,
841 static void free_line_header (struct line_header *lh);
843 static void add_file_name (struct line_header *, char *, unsigned int,
844 unsigned int, unsigned int);
846 static struct line_header *(dwarf_decode_line_header
847 (unsigned int offset,
848 bfd *abfd, struct dwarf2_cu *cu));
850 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
851 struct dwarf2_cu *, struct partial_symtab *);
853 static void dwarf2_start_subfile (char *, char *, char *);
855 static struct symbol *new_symbol (struct die_info *, struct type *,
858 static void dwarf2_const_value (struct attribute *, struct symbol *,
861 static void dwarf2_const_value_data (struct attribute *attr,
865 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
867 static struct type *die_containing_type (struct die_info *,
870 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
872 static void read_type_die (struct die_info *, struct dwarf2_cu *);
874 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
876 static char *typename_concat (struct obstack *,
881 static void read_typedef (struct die_info *, struct dwarf2_cu *);
883 static void read_base_type (struct die_info *, struct dwarf2_cu *);
885 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
887 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
889 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
891 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
893 static int dwarf2_get_pc_bounds (struct die_info *,
894 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
896 static void get_scope_pc_bounds (struct die_info *,
897 CORE_ADDR *, CORE_ADDR *,
900 static void dwarf2_add_field (struct field_info *, struct die_info *,
903 static void dwarf2_attach_fields_to_type (struct field_info *,
904 struct type *, struct dwarf2_cu *);
906 static void dwarf2_add_member_fn (struct field_info *,
907 struct die_info *, struct type *,
910 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
911 struct type *, struct dwarf2_cu *);
913 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
915 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
917 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
919 static void read_common_block (struct die_info *, struct dwarf2_cu *);
921 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
923 static const char *namespace_name (struct die_info *die,
924 int *is_anonymous, struct dwarf2_cu *);
926 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
928 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
930 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
932 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
934 static void read_array_type (struct die_info *, struct dwarf2_cu *);
936 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
939 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
941 static void read_tag_ptr_to_member_type (struct die_info *,
944 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
946 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
948 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
950 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
952 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
954 static struct die_info *read_comp_unit (gdb_byte *, bfd *, struct dwarf2_cu *);
956 static struct die_info *read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
958 gdb_byte **new_info_ptr,
959 struct die_info *parent);
961 static struct die_info *read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
963 gdb_byte **new_info_ptr,
964 struct die_info *parent);
966 static void free_die_list (struct die_info *);
968 static void process_die (struct die_info *, struct dwarf2_cu *);
970 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
972 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
974 static struct die_info *dwarf2_extension (struct die_info *die,
977 static char *dwarf_tag_name (unsigned int);
979 static char *dwarf_attr_name (unsigned int);
981 static char *dwarf_form_name (unsigned int);
983 static char *dwarf_stack_op_name (unsigned int);
985 static char *dwarf_bool_name (unsigned int);
987 static char *dwarf_type_encoding_name (unsigned int);
990 static char *dwarf_cfi_name (unsigned int);
992 struct die_info *copy_die (struct die_info *);
995 static struct die_info *sibling_die (struct die_info *);
997 static void dump_die (struct die_info *);
999 static void dump_die_list (struct die_info *);
1001 static void store_in_ref_table (unsigned int, struct die_info *,
1002 struct dwarf2_cu *);
1004 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
1005 struct dwarf2_cu *);
1007 static int dwarf2_get_attr_constant_value (struct attribute *, int);
1009 static struct die_info *follow_die_ref (struct die_info *,
1011 struct dwarf2_cu *);
1013 static struct type *dwarf2_fundamental_type (struct objfile *, int,
1014 struct dwarf2_cu *);
1016 /* memory allocation interface */
1018 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1020 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1022 static struct die_info *dwarf_alloc_die (void);
1024 static void initialize_cu_func_list (struct dwarf2_cu *);
1026 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1027 struct dwarf2_cu *);
1029 static void dwarf_decode_macros (struct line_header *, unsigned int,
1030 char *, bfd *, struct dwarf2_cu *);
1032 static int attr_form_is_block (struct attribute *);
1035 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
1036 struct dwarf2_cu *cu);
1038 static gdb_byte *skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
1039 struct dwarf2_cu *cu);
1041 static void free_stack_comp_unit (void *);
1043 static hashval_t partial_die_hash (const void *item);
1045 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1047 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1048 (unsigned long offset, struct objfile *objfile);
1050 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1051 (unsigned long offset, struct objfile *objfile);
1053 static void free_one_comp_unit (void *);
1055 static void free_cached_comp_units (void *);
1057 static void age_cached_comp_units (void);
1059 static void free_one_cached_comp_unit (void *);
1061 static void set_die_type (struct die_info *, struct type *,
1062 struct dwarf2_cu *);
1064 static void reset_die_and_siblings_types (struct die_info *,
1065 struct dwarf2_cu *);
1067 static void create_all_comp_units (struct objfile *);
1069 static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *);
1071 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1073 static void dwarf2_add_dependence (struct dwarf2_cu *,
1074 struct dwarf2_per_cu_data *);
1076 static void dwarf2_mark (struct dwarf2_cu *);
1078 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1080 static void read_set_type (struct die_info *, struct dwarf2_cu *);
1083 /* Try to locate the sections we need for DWARF 2 debugging
1084 information and return true if we have enough to do something. */
1087 dwarf2_has_info (struct objfile *objfile)
1089 struct dwarf2_per_objfile *data;
1091 /* Initialize per-objfile state. */
1092 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1093 memset (data, 0, sizeof (*data));
1094 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1095 dwarf2_per_objfile = data;
1097 dwarf_info_section = 0;
1098 dwarf_abbrev_section = 0;
1099 dwarf_line_section = 0;
1100 dwarf_str_section = 0;
1101 dwarf_macinfo_section = 0;
1102 dwarf_frame_section = 0;
1103 dwarf_eh_frame_section = 0;
1104 dwarf_ranges_section = 0;
1105 dwarf_loc_section = 0;
1107 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1108 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
1111 /* This function is mapped across the sections and remembers the
1112 offset and size of each of the debugging sections we are interested
1116 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *ignore_ptr)
1118 if (strcmp (sectp->name, INFO_SECTION) == 0)
1120 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1121 dwarf_info_section = sectp;
1123 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1125 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1126 dwarf_abbrev_section = sectp;
1128 else if (strcmp (sectp->name, LINE_SECTION) == 0)
1130 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1131 dwarf_line_section = sectp;
1133 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1135 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1136 dwarf_pubnames_section = sectp;
1138 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1140 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1141 dwarf_aranges_section = sectp;
1143 else if (strcmp (sectp->name, LOC_SECTION) == 0)
1145 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1146 dwarf_loc_section = sectp;
1148 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1150 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1151 dwarf_macinfo_section = sectp;
1153 else if (strcmp (sectp->name, STR_SECTION) == 0)
1155 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1156 dwarf_str_section = sectp;
1158 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1160 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1161 dwarf_frame_section = sectp;
1163 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1165 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1166 if (aflag & SEC_HAS_CONTENTS)
1168 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1169 dwarf_eh_frame_section = sectp;
1172 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1174 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1175 dwarf_ranges_section = sectp;
1178 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1179 && bfd_section_vma (abfd, sectp) == 0)
1180 dwarf2_per_objfile->has_section_at_zero = 1;
1183 /* Build a partial symbol table. */
1186 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1188 /* We definitely need the .debug_info and .debug_abbrev sections */
1190 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1191 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1193 if (dwarf_line_section)
1194 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1196 dwarf2_per_objfile->line_buffer = NULL;
1198 if (dwarf_str_section)
1199 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1201 dwarf2_per_objfile->str_buffer = NULL;
1203 if (dwarf_macinfo_section)
1204 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1205 dwarf_macinfo_section);
1207 dwarf2_per_objfile->macinfo_buffer = NULL;
1209 if (dwarf_ranges_section)
1210 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1212 dwarf2_per_objfile->ranges_buffer = NULL;
1214 if (dwarf_loc_section)
1215 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1217 dwarf2_per_objfile->loc_buffer = NULL;
1220 || (objfile->global_psymbols.size == 0
1221 && objfile->static_psymbols.size == 0))
1223 init_psymbol_list (objfile, 1024);
1227 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1229 /* Things are significantly easier if we have .debug_aranges and
1230 .debug_pubnames sections */
1232 dwarf2_build_psymtabs_easy (objfile, mainline);
1236 /* only test this case for now */
1238 /* In this case we have to work a bit harder */
1239 dwarf2_build_psymtabs_hard (objfile, mainline);
1244 /* Build the partial symbol table from the information in the
1245 .debug_pubnames and .debug_aranges sections. */
1248 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1250 bfd *abfd = objfile->obfd;
1251 char *aranges_buffer, *pubnames_buffer;
1252 char *aranges_ptr, *pubnames_ptr;
1253 unsigned int entry_length, version, info_offset, info_size;
1255 pubnames_buffer = dwarf2_read_section (objfile,
1256 dwarf_pubnames_section);
1257 pubnames_ptr = pubnames_buffer;
1258 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1260 struct comp_unit_head cu_header;
1261 unsigned int bytes_read;
1263 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1265 pubnames_ptr += bytes_read;
1266 version = read_1_byte (abfd, pubnames_ptr);
1268 info_offset = read_4_bytes (abfd, pubnames_ptr);
1270 info_size = read_4_bytes (abfd, pubnames_ptr);
1274 aranges_buffer = dwarf2_read_section (objfile,
1275 dwarf_aranges_section);
1280 /* Read in the comp unit header information from the debug_info at
1284 read_comp_unit_head (struct comp_unit_head *cu_header,
1285 gdb_byte *info_ptr, bfd *abfd)
1288 unsigned int bytes_read;
1289 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1291 info_ptr += bytes_read;
1292 cu_header->version = read_2_bytes (abfd, info_ptr);
1294 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1296 info_ptr += bytes_read;
1297 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1299 signed_addr = bfd_get_sign_extend_vma (abfd);
1300 if (signed_addr < 0)
1301 internal_error (__FILE__, __LINE__,
1302 _("read_comp_unit_head: dwarf from non elf file"));
1303 cu_header->signed_addr_p = signed_addr;
1308 partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
1311 gdb_byte *beg_of_comp_unit = info_ptr;
1313 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1315 if (header->version != 2 && header->version != 3)
1316 error (_("Dwarf Error: wrong version in compilation unit header "
1317 "(is %d, should be %d) [in module %s]"), header->version,
1318 2, bfd_get_filename (abfd));
1320 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1321 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1322 "(offset 0x%lx + 6) [in module %s]"),
1323 (long) header->abbrev_offset,
1324 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1325 bfd_get_filename (abfd));
1327 if (beg_of_comp_unit + header->length + header->initial_length_size
1328 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1329 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1330 "(offset 0x%lx + 0) [in module %s]"),
1331 (long) header->length,
1332 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1333 bfd_get_filename (abfd));
1338 /* Allocate a new partial symtab for file named NAME and mark this new
1339 partial symtab as being an include of PST. */
1342 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1343 struct objfile *objfile)
1345 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1347 subpst->section_offsets = pst->section_offsets;
1348 subpst->textlow = 0;
1349 subpst->texthigh = 0;
1351 subpst->dependencies = (struct partial_symtab **)
1352 obstack_alloc (&objfile->objfile_obstack,
1353 sizeof (struct partial_symtab *));
1354 subpst->dependencies[0] = pst;
1355 subpst->number_of_dependencies = 1;
1357 subpst->globals_offset = 0;
1358 subpst->n_global_syms = 0;
1359 subpst->statics_offset = 0;
1360 subpst->n_static_syms = 0;
1361 subpst->symtab = NULL;
1362 subpst->read_symtab = pst->read_symtab;
1365 /* No private part is necessary for include psymtabs. This property
1366 can be used to differentiate between such include psymtabs and
1367 the regular ones. */
1368 subpst->read_symtab_private = NULL;
1371 /* Read the Line Number Program data and extract the list of files
1372 included by the source file represented by PST. Build an include
1373 partial symtab for each of these included files.
1375 This procedure assumes that there *is* a Line Number Program in
1376 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1377 before calling this procedure. */
1380 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1381 struct partial_die_info *pdi,
1382 struct partial_symtab *pst)
1384 struct objfile *objfile = cu->objfile;
1385 bfd *abfd = objfile->obfd;
1386 struct line_header *lh;
1388 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1390 return; /* No linetable, so no includes. */
1392 dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1394 free_line_header (lh);
1398 /* Build the partial symbol table by doing a quick pass through the
1399 .debug_info and .debug_abbrev sections. */
1402 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1404 /* Instead of reading this into a big buffer, we should probably use
1405 mmap() on architectures that support it. (FIXME) */
1406 bfd *abfd = objfile->obfd;
1408 gdb_byte *beg_of_comp_unit;
1409 struct partial_die_info comp_unit_die;
1410 struct partial_symtab *pst;
1411 struct cleanup *back_to;
1412 CORE_ADDR lowpc, highpc, baseaddr;
1414 info_ptr = dwarf2_per_objfile->info_buffer;
1416 /* Any cached compilation units will be linked by the per-objfile
1417 read_in_chain. Make sure to free them when we're done. */
1418 back_to = make_cleanup (free_cached_comp_units, NULL);
1420 create_all_comp_units (objfile);
1422 /* Since the objects we're extracting from .debug_info vary in
1423 length, only the individual functions to extract them (like
1424 read_comp_unit_head and load_partial_die) can really know whether
1425 the buffer is large enough to hold another complete object.
1427 At the moment, they don't actually check that. If .debug_info
1428 holds just one extra byte after the last compilation unit's dies,
1429 then read_comp_unit_head will happily read off the end of the
1430 buffer. read_partial_die is similarly casual. Those functions
1433 For this loop condition, simply checking whether there's any data
1434 left at all should be sufficient. */
1435 while (info_ptr < (dwarf2_per_objfile->info_buffer
1436 + dwarf2_per_objfile->info_size))
1438 struct cleanup *back_to_inner;
1439 struct dwarf2_cu cu;
1440 struct abbrev_info *abbrev;
1441 unsigned int bytes_read;
1442 struct dwarf2_per_cu_data *this_cu;
1444 beg_of_comp_unit = info_ptr;
1446 memset (&cu, 0, sizeof (cu));
1448 obstack_init (&cu.comp_unit_obstack);
1450 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1452 cu.objfile = objfile;
1453 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1455 /* Complete the cu_header */
1456 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1457 cu.header.first_die_ptr = info_ptr;
1458 cu.header.cu_head_ptr = beg_of_comp_unit;
1460 cu.list_in_scope = &file_symbols;
1462 /* Read the abbrevs for this compilation unit into a table */
1463 dwarf2_read_abbrevs (abfd, &cu);
1464 make_cleanup (dwarf2_free_abbrev_table, &cu);
1466 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile);
1468 /* Read the compilation unit die */
1469 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1470 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1471 abfd, info_ptr, &cu);
1473 /* Set the language we're debugging */
1474 set_cu_language (comp_unit_die.language, &cu);
1476 /* Allocate a new partial symbol table structure */
1477 pst = start_psymtab_common (objfile, objfile->section_offsets,
1478 comp_unit_die.name ? comp_unit_die.name : "",
1479 comp_unit_die.lowpc,
1480 objfile->global_psymbols.next,
1481 objfile->static_psymbols.next);
1483 if (comp_unit_die.dirname)
1484 pst->dirname = xstrdup (comp_unit_die.dirname);
1486 pst->read_symtab_private = (char *) this_cu;
1488 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1490 /* Store the function that reads in the rest of the symbol table */
1491 pst->read_symtab = dwarf2_psymtab_to_symtab;
1493 /* If this compilation unit was already read in, free the
1494 cached copy in order to read it in again. This is
1495 necessary because we skipped some symbols when we first
1496 read in the compilation unit (see load_partial_dies).
1497 This problem could be avoided, but the benefit is
1499 if (this_cu->cu != NULL)
1500 free_one_cached_comp_unit (this_cu->cu);
1502 cu.per_cu = this_cu;
1504 /* Note that this is a pointer to our stack frame, being
1505 added to a global data structure. It will be cleaned up
1506 in free_stack_comp_unit when we finish with this
1507 compilation unit. */
1510 this_cu->psymtab = pst;
1512 /* Check if comp unit has_children.
1513 If so, read the rest of the partial symbols from this comp unit.
1514 If not, there's no more debug_info for this comp unit. */
1515 if (comp_unit_die.has_children)
1517 struct partial_die_info *first_die;
1519 lowpc = ((CORE_ADDR) -1);
1520 highpc = ((CORE_ADDR) 0);
1522 first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1524 scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1526 /* If we didn't find a lowpc, set it to highpc to avoid
1527 complaints from `maint check'. */
1528 if (lowpc == ((CORE_ADDR) -1))
1531 /* If the compilation unit didn't have an explicit address range,
1532 then use the information extracted from its child dies. */
1533 if (! comp_unit_die.has_pc_info)
1535 comp_unit_die.lowpc = lowpc;
1536 comp_unit_die.highpc = highpc;
1539 pst->textlow = comp_unit_die.lowpc + baseaddr;
1540 pst->texthigh = comp_unit_die.highpc + baseaddr;
1542 pst->n_global_syms = objfile->global_psymbols.next -
1543 (objfile->global_psymbols.list + pst->globals_offset);
1544 pst->n_static_syms = objfile->static_psymbols.next -
1545 (objfile->static_psymbols.list + pst->statics_offset);
1546 sort_pst_symbols (pst);
1548 /* If there is already a psymtab or symtab for a file of this
1549 name, remove it. (If there is a symtab, more drastic things
1550 also happen.) This happens in VxWorks. */
1551 free_named_symtabs (pst->filename);
1553 info_ptr = beg_of_comp_unit + cu.header.length
1554 + cu.header.initial_length_size;
1556 if (comp_unit_die.has_stmt_list)
1558 /* Get the list of files included in the current compilation unit,
1559 and build a psymtab for each of them. */
1560 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1563 do_cleanups (back_to_inner);
1565 do_cleanups (back_to);
1568 /* Load the DIEs for a secondary CU into memory. */
1571 load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile)
1573 bfd *abfd = objfile->obfd;
1574 gdb_byte *info_ptr, *beg_of_comp_unit;
1575 struct partial_die_info comp_unit_die;
1576 struct dwarf2_cu *cu;
1577 struct abbrev_info *abbrev;
1578 unsigned int bytes_read;
1579 struct cleanup *back_to;
1581 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset;
1582 beg_of_comp_unit = info_ptr;
1584 cu = xmalloc (sizeof (struct dwarf2_cu));
1585 memset (cu, 0, sizeof (struct dwarf2_cu));
1587 obstack_init (&cu->comp_unit_obstack);
1589 cu->objfile = objfile;
1590 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd);
1592 /* Complete the cu_header. */
1593 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1594 cu->header.first_die_ptr = info_ptr;
1595 cu->header.cu_head_ptr = beg_of_comp_unit;
1597 /* Read the abbrevs for this compilation unit into a table. */
1598 dwarf2_read_abbrevs (abfd, cu);
1599 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
1601 /* Read the compilation unit die. */
1602 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1603 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1604 abfd, info_ptr, cu);
1606 /* Set the language we're debugging. */
1607 set_cu_language (comp_unit_die.language, cu);
1609 /* Link this compilation unit into the compilation unit tree. */
1611 cu->per_cu = this_cu;
1613 /* Check if comp unit has_children.
1614 If so, read the rest of the partial symbols from this comp unit.
1615 If not, there's no more debug_info for this comp unit. */
1616 if (comp_unit_die.has_children)
1617 load_partial_dies (abfd, info_ptr, 0, cu);
1619 do_cleanups (back_to);
1622 /* Create a list of all compilation units in OBJFILE. We do this only
1623 if an inter-comp-unit reference is found; presumably if there is one,
1624 there will be many, and one will occur early in the .debug_info section.
1625 So there's no point in building this list incrementally. */
1628 create_all_comp_units (struct objfile *objfile)
1632 struct dwarf2_per_cu_data **all_comp_units;
1633 gdb_byte *info_ptr = dwarf2_per_objfile->info_buffer;
1637 all_comp_units = xmalloc (n_allocated
1638 * sizeof (struct dwarf2_per_cu_data *));
1640 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1642 struct comp_unit_head cu_header;
1643 gdb_byte *beg_of_comp_unit;
1644 struct dwarf2_per_cu_data *this_cu;
1645 unsigned long offset;
1646 unsigned int bytes_read;
1648 offset = info_ptr - dwarf2_per_objfile->info_buffer;
1650 /* Read just enough information to find out where the next
1651 compilation unit is. */
1652 cu_header.initial_length_size = 0;
1653 cu_header.length = read_initial_length (objfile->obfd, info_ptr,
1654 &cu_header, &bytes_read);
1656 /* Save the compilation unit for later lookup. */
1657 this_cu = obstack_alloc (&objfile->objfile_obstack,
1658 sizeof (struct dwarf2_per_cu_data));
1659 memset (this_cu, 0, sizeof (*this_cu));
1660 this_cu->offset = offset;
1661 this_cu->length = cu_header.length + cu_header.initial_length_size;
1663 if (n_comp_units == n_allocated)
1666 all_comp_units = xrealloc (all_comp_units,
1668 * sizeof (struct dwarf2_per_cu_data *));
1670 all_comp_units[n_comp_units++] = this_cu;
1672 info_ptr = info_ptr + this_cu->length;
1675 dwarf2_per_objfile->all_comp_units
1676 = obstack_alloc (&objfile->objfile_obstack,
1677 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1678 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
1679 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1680 xfree (all_comp_units);
1681 dwarf2_per_objfile->n_comp_units = n_comp_units;
1684 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1685 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1689 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1690 CORE_ADDR *highpc, struct dwarf2_cu *cu)
1692 struct objfile *objfile = cu->objfile;
1693 bfd *abfd = objfile->obfd;
1694 struct partial_die_info *pdi;
1696 /* Now, march along the PDI's, descending into ones which have
1697 interesting children but skipping the children of the other ones,
1698 until we reach the end of the compilation unit. */
1704 fixup_partial_die (pdi, cu);
1706 /* Anonymous namespaces have no name but have interesting
1707 children, so we need to look at them. Ditto for anonymous
1710 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1711 || pdi->tag == DW_TAG_enumeration_type)
1715 case DW_TAG_subprogram:
1716 if (pdi->has_pc_info)
1718 if (pdi->lowpc < *lowpc)
1720 *lowpc = pdi->lowpc;
1722 if (pdi->highpc > *highpc)
1724 *highpc = pdi->highpc;
1726 if (!pdi->is_declaration)
1728 add_partial_symbol (pdi, cu);
1732 case DW_TAG_variable:
1733 case DW_TAG_typedef:
1734 case DW_TAG_union_type:
1735 if (!pdi->is_declaration)
1737 add_partial_symbol (pdi, cu);
1740 case DW_TAG_class_type:
1741 case DW_TAG_structure_type:
1742 if (!pdi->is_declaration)
1744 add_partial_symbol (pdi, cu);
1747 case DW_TAG_enumeration_type:
1748 if (!pdi->is_declaration)
1749 add_partial_enumeration (pdi, cu);
1751 case DW_TAG_base_type:
1752 case DW_TAG_subrange_type:
1753 /* File scope base type definitions are added to the partial
1755 add_partial_symbol (pdi, cu);
1757 case DW_TAG_namespace:
1758 add_partial_namespace (pdi, lowpc, highpc, cu);
1765 /* If the die has a sibling, skip to the sibling. */
1767 pdi = pdi->die_sibling;
1771 /* Functions used to compute the fully scoped name of a partial DIE.
1773 Normally, this is simple. For C++, the parent DIE's fully scoped
1774 name is concatenated with "::" and the partial DIE's name. For
1775 Java, the same thing occurs except that "." is used instead of "::".
1776 Enumerators are an exception; they use the scope of their parent
1777 enumeration type, i.e. the name of the enumeration type is not
1778 prepended to the enumerator.
1780 There are two complexities. One is DW_AT_specification; in this
1781 case "parent" means the parent of the target of the specification,
1782 instead of the direct parent of the DIE. The other is compilers
1783 which do not emit DW_TAG_namespace; in this case we try to guess
1784 the fully qualified name of structure types from their members'
1785 linkage names. This must be done using the DIE's children rather
1786 than the children of any DW_AT_specification target. We only need
1787 to do this for structures at the top level, i.e. if the target of
1788 any DW_AT_specification (if any; otherwise the DIE itself) does not
1791 /* Compute the scope prefix associated with PDI's parent, in
1792 compilation unit CU. The result will be allocated on CU's
1793 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1794 field. NULL is returned if no prefix is necessary. */
1796 partial_die_parent_scope (struct partial_die_info *pdi,
1797 struct dwarf2_cu *cu)
1799 char *grandparent_scope;
1800 struct partial_die_info *parent, *real_pdi;
1802 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1803 then this means the parent of the specification DIE. */
1806 while (real_pdi->has_specification)
1807 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
1809 parent = real_pdi->die_parent;
1813 if (parent->scope_set)
1814 return parent->scope;
1816 fixup_partial_die (parent, cu);
1818 grandparent_scope = partial_die_parent_scope (parent, cu);
1820 if (parent->tag == DW_TAG_namespace
1821 || parent->tag == DW_TAG_structure_type
1822 || parent->tag == DW_TAG_class_type
1823 || parent->tag == DW_TAG_union_type)
1825 if (grandparent_scope == NULL)
1826 parent->scope = parent->name;
1828 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
1831 else if (parent->tag == DW_TAG_enumeration_type)
1832 /* Enumerators should not get the name of the enumeration as a prefix. */
1833 parent->scope = grandparent_scope;
1836 /* FIXME drow/2004-04-01: What should we be doing with
1837 function-local names? For partial symbols, we should probably be
1839 complaint (&symfile_complaints,
1840 _("unhandled containing DIE tag %d for DIE at %d"),
1841 parent->tag, pdi->offset);
1842 parent->scope = grandparent_scope;
1845 parent->scope_set = 1;
1846 return parent->scope;
1849 /* Return the fully scoped name associated with PDI, from compilation unit
1850 CU. The result will be allocated with malloc. */
1852 partial_die_full_name (struct partial_die_info *pdi,
1853 struct dwarf2_cu *cu)
1857 parent_scope = partial_die_parent_scope (pdi, cu);
1858 if (parent_scope == NULL)
1861 return typename_concat (NULL, parent_scope, pdi->name, cu);
1865 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1867 struct objfile *objfile = cu->objfile;
1870 const char *my_prefix;
1871 const struct partial_symbol *psym = NULL;
1873 int built_actual_name = 0;
1875 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1879 if (pdi_needs_namespace (pdi->tag))
1881 actual_name = partial_die_full_name (pdi, cu);
1883 built_actual_name = 1;
1886 if (actual_name == NULL)
1887 actual_name = pdi->name;
1891 case DW_TAG_subprogram:
1892 if (pdi->is_external)
1894 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1895 mst_text, objfile); */
1896 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1897 VAR_DOMAIN, LOC_BLOCK,
1898 &objfile->global_psymbols,
1899 0, pdi->lowpc + baseaddr,
1900 cu->language, objfile);
1904 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1905 mst_file_text, objfile); */
1906 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1907 VAR_DOMAIN, LOC_BLOCK,
1908 &objfile->static_psymbols,
1909 0, pdi->lowpc + baseaddr,
1910 cu->language, objfile);
1913 case DW_TAG_variable:
1914 if (pdi->is_external)
1917 Don't enter into the minimal symbol tables as there is
1918 a minimal symbol table entry from the ELF symbols already.
1919 Enter into partial symbol table if it has a location
1920 descriptor or a type.
1921 If the location descriptor is missing, new_symbol will create
1922 a LOC_UNRESOLVED symbol, the address of the variable will then
1923 be determined from the minimal symbol table whenever the variable
1925 The address for the partial symbol table entry is not
1926 used by GDB, but it comes in handy for debugging partial symbol
1930 addr = decode_locdesc (pdi->locdesc, cu);
1931 if (pdi->locdesc || pdi->has_type)
1932 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1933 VAR_DOMAIN, LOC_STATIC,
1934 &objfile->global_psymbols,
1936 cu->language, objfile);
1940 /* Static Variable. Skip symbols without location descriptors. */
1941 if (pdi->locdesc == NULL)
1943 addr = decode_locdesc (pdi->locdesc, cu);
1944 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1945 mst_file_data, objfile); */
1946 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1947 VAR_DOMAIN, LOC_STATIC,
1948 &objfile->static_psymbols,
1950 cu->language, objfile);
1953 case DW_TAG_typedef:
1954 case DW_TAG_base_type:
1955 case DW_TAG_subrange_type:
1956 add_psymbol_to_list (actual_name, strlen (actual_name),
1957 VAR_DOMAIN, LOC_TYPEDEF,
1958 &objfile->static_psymbols,
1959 0, (CORE_ADDR) 0, cu->language, objfile);
1961 case DW_TAG_namespace:
1962 add_psymbol_to_list (actual_name, strlen (actual_name),
1963 VAR_DOMAIN, LOC_TYPEDEF,
1964 &objfile->global_psymbols,
1965 0, (CORE_ADDR) 0, cu->language, objfile);
1967 case DW_TAG_class_type:
1968 case DW_TAG_structure_type:
1969 case DW_TAG_union_type:
1970 case DW_TAG_enumeration_type:
1971 /* Skip aggregate types without children, these are external
1973 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1974 static vs. global. */
1975 if (pdi->has_children == 0)
1977 add_psymbol_to_list (actual_name, strlen (actual_name),
1978 STRUCT_DOMAIN, LOC_TYPEDEF,
1979 (cu->language == language_cplus
1980 || cu->language == language_java)
1981 ? &objfile->global_psymbols
1982 : &objfile->static_psymbols,
1983 0, (CORE_ADDR) 0, cu->language, objfile);
1985 if (cu->language == language_cplus
1986 || cu->language == language_java)
1988 /* For C++ and Java, these implicitly act as typedefs as well. */
1989 add_psymbol_to_list (actual_name, strlen (actual_name),
1990 VAR_DOMAIN, LOC_TYPEDEF,
1991 &objfile->global_psymbols,
1992 0, (CORE_ADDR) 0, cu->language, objfile);
1995 case DW_TAG_enumerator:
1996 add_psymbol_to_list (actual_name, strlen (actual_name),
1997 VAR_DOMAIN, LOC_CONST,
1998 (cu->language == language_cplus
1999 || cu->language == language_java)
2000 ? &objfile->global_psymbols
2001 : &objfile->static_psymbols,
2002 0, (CORE_ADDR) 0, cu->language, objfile);
2008 /* Check to see if we should scan the name for possible namespace
2009 info. Only do this if this is C++, if we don't have namespace
2010 debugging info in the file, if the psym is of an appropriate type
2011 (otherwise we'll have psym == NULL), and if we actually had a
2012 mangled name to begin with. */
2014 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2015 cases which do not set PSYM above? */
2017 if (cu->language == language_cplus
2018 && cu->has_namespace_info == 0
2020 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2021 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2024 if (built_actual_name)
2025 xfree (actual_name);
2028 /* Determine whether a die of type TAG living in a C++ class or
2029 namespace needs to have the name of the scope prepended to the
2030 name listed in the die. */
2033 pdi_needs_namespace (enum dwarf_tag tag)
2037 case DW_TAG_namespace:
2038 case DW_TAG_typedef:
2039 case DW_TAG_class_type:
2040 case DW_TAG_structure_type:
2041 case DW_TAG_union_type:
2042 case DW_TAG_enumeration_type:
2043 case DW_TAG_enumerator:
2050 /* Read a partial die corresponding to a namespace; also, add a symbol
2051 corresponding to that namespace to the symbol table. NAMESPACE is
2052 the name of the enclosing namespace. */
2055 add_partial_namespace (struct partial_die_info *pdi,
2056 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2057 struct dwarf2_cu *cu)
2059 struct objfile *objfile = cu->objfile;
2061 /* Add a symbol for the namespace. */
2063 add_partial_symbol (pdi, cu);
2065 /* Now scan partial symbols in that namespace. */
2067 if (pdi->has_children)
2068 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
2071 /* See if we can figure out if the class lives in a namespace. We do
2072 this by looking for a member function; its demangled name will
2073 contain namespace info, if there is any. */
2076 guess_structure_name (struct partial_die_info *struct_pdi,
2077 struct dwarf2_cu *cu)
2079 if ((cu->language == language_cplus
2080 || cu->language == language_java)
2081 && cu->has_namespace_info == 0
2082 && struct_pdi->has_children)
2084 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2085 what template types look like, because the demangler
2086 frequently doesn't give the same name as the debug info. We
2087 could fix this by only using the demangled name to get the
2088 prefix (but see comment in read_structure_type). */
2090 struct partial_die_info *child_pdi = struct_pdi->die_child;
2091 struct partial_die_info *real_pdi;
2093 /* If this DIE (this DIE's specification, if any) has a parent, then
2094 we should not do this. We'll prepend the parent's fully qualified
2095 name when we create the partial symbol. */
2097 real_pdi = struct_pdi;
2098 while (real_pdi->has_specification)
2099 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2101 if (real_pdi->die_parent != NULL)
2104 while (child_pdi != NULL)
2106 if (child_pdi->tag == DW_TAG_subprogram)
2108 char *actual_class_name
2109 = language_class_name_from_physname (cu->language_defn,
2111 if (actual_class_name != NULL)
2114 = obsavestring (actual_class_name,
2115 strlen (actual_class_name),
2116 &cu->comp_unit_obstack);
2117 xfree (actual_class_name);
2122 child_pdi = child_pdi->die_sibling;
2127 /* Read a partial die corresponding to an enumeration type. */
2130 add_partial_enumeration (struct partial_die_info *enum_pdi,
2131 struct dwarf2_cu *cu)
2133 struct objfile *objfile = cu->objfile;
2134 bfd *abfd = objfile->obfd;
2135 struct partial_die_info *pdi;
2137 if (enum_pdi->name != NULL)
2138 add_partial_symbol (enum_pdi, cu);
2140 pdi = enum_pdi->die_child;
2143 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2144 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2146 add_partial_symbol (pdi, cu);
2147 pdi = pdi->die_sibling;
2151 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2152 Return the corresponding abbrev, or NULL if the number is zero (indicating
2153 an empty DIE). In either case *BYTES_READ will be set to the length of
2154 the initial number. */
2156 static struct abbrev_info *
2157 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
2158 struct dwarf2_cu *cu)
2160 bfd *abfd = cu->objfile->obfd;
2161 unsigned int abbrev_number;
2162 struct abbrev_info *abbrev;
2164 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2166 if (abbrev_number == 0)
2169 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2172 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2173 bfd_get_filename (abfd));
2179 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2180 pointer to the end of a series of DIEs, terminated by an empty
2181 DIE. Any children of the skipped DIEs will also be skipped. */
2184 skip_children (gdb_byte *info_ptr, struct dwarf2_cu *cu)
2186 struct abbrev_info *abbrev;
2187 unsigned int bytes_read;
2191 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2193 return info_ptr + bytes_read;
2195 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
2199 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2200 should point just after the initial uleb128 of a DIE, and the
2201 abbrev corresponding to that skipped uleb128 should be passed in
2202 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2206 skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
2207 struct dwarf2_cu *cu)
2209 unsigned int bytes_read;
2210 struct attribute attr;
2211 bfd *abfd = cu->objfile->obfd;
2212 unsigned int form, i;
2214 for (i = 0; i < abbrev->num_attrs; i++)
2216 /* The only abbrev we care about is DW_AT_sibling. */
2217 if (abbrev->attrs[i].name == DW_AT_sibling)
2219 read_attribute (&attr, &abbrev->attrs[i],
2220 abfd, info_ptr, cu);
2221 if (attr.form == DW_FORM_ref_addr)
2222 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2224 return dwarf2_per_objfile->info_buffer
2225 + dwarf2_get_ref_die_offset (&attr, cu);
2228 /* If it isn't DW_AT_sibling, skip this attribute. */
2229 form = abbrev->attrs[i].form;
2234 case DW_FORM_ref_addr:
2235 info_ptr += cu->header.addr_size;
2254 case DW_FORM_string:
2255 read_string (abfd, info_ptr, &bytes_read);
2256 info_ptr += bytes_read;
2259 info_ptr += cu->header.offset_size;
2262 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2263 info_ptr += bytes_read;
2265 case DW_FORM_block1:
2266 info_ptr += 1 + read_1_byte (abfd, info_ptr);
2268 case DW_FORM_block2:
2269 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2271 case DW_FORM_block4:
2272 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2276 case DW_FORM_ref_udata:
2277 info_ptr = skip_leb128 (abfd, info_ptr);
2279 case DW_FORM_indirect:
2280 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2281 info_ptr += bytes_read;
2282 /* We need to continue parsing from here, so just go back to
2284 goto skip_attribute;
2287 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2288 dwarf_form_name (form),
2289 bfd_get_filename (abfd));
2293 if (abbrev->has_children)
2294 return skip_children (info_ptr, cu);
2299 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2300 the next DIE after ORIG_PDI. */
2303 locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr,
2304 bfd *abfd, struct dwarf2_cu *cu)
2306 /* Do we know the sibling already? */
2308 if (orig_pdi->sibling)
2309 return orig_pdi->sibling;
2311 /* Are there any children to deal with? */
2313 if (!orig_pdi->has_children)
2316 /* Skip the children the long way. */
2318 return skip_children (info_ptr, cu);
2321 /* Expand this partial symbol table into a full symbol table. */
2324 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2326 /* FIXME: This is barely more than a stub. */
2331 warning (_("bug: psymtab for %s is already read in."), pst->filename);
2337 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
2338 gdb_flush (gdb_stdout);
2341 /* Restore our global data. */
2342 dwarf2_per_objfile = objfile_data (pst->objfile,
2343 dwarf2_objfile_data_key);
2345 psymtab_to_symtab_1 (pst);
2347 /* Finish up the debug error message. */
2349 printf_filtered (_("done.\n"));
2354 /* Add PER_CU to the queue. */
2357 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
2359 struct dwarf2_queue_item *item;
2362 item = xmalloc (sizeof (*item));
2363 item->per_cu = per_cu;
2366 if (dwarf2_queue == NULL)
2367 dwarf2_queue = item;
2369 dwarf2_queue_tail->next = item;
2371 dwarf2_queue_tail = item;
2374 /* Process the queue. */
2377 process_queue (struct objfile *objfile)
2379 struct dwarf2_queue_item *item, *next_item;
2381 /* Initially, there is just one item on the queue. Load its DIEs,
2382 and the DIEs of any other compilation units it requires,
2385 for (item = dwarf2_queue; item != NULL; item = item->next)
2387 /* Read in this compilation unit. This may add new items to
2388 the end of the queue. */
2389 load_full_comp_unit (item->per_cu);
2391 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
2392 dwarf2_per_objfile->read_in_chain = item->per_cu;
2394 /* If this compilation unit has already had full symbols created,
2395 reset the TYPE fields in each DIE. */
2396 if (item->per_cu->psymtab->readin)
2397 reset_die_and_siblings_types (item->per_cu->cu->dies,
2401 /* Now everything left on the queue needs to be read in. Process
2402 them, one at a time, removing from the queue as we finish. */
2403 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
2405 if (!item->per_cu->psymtab->readin)
2406 process_full_comp_unit (item->per_cu);
2408 item->per_cu->queued = 0;
2409 next_item = item->next;
2413 dwarf2_queue_tail = NULL;
2416 /* Free all allocated queue entries. This function only releases anything if
2417 an error was thrown; if the queue was processed then it would have been
2418 freed as we went along. */
2421 dwarf2_release_queue (void *dummy)
2423 struct dwarf2_queue_item *item, *last;
2425 item = dwarf2_queue;
2428 /* Anything still marked queued is likely to be in an
2429 inconsistent state, so discard it. */
2430 if (item->per_cu->queued)
2432 if (item->per_cu->cu != NULL)
2433 free_one_cached_comp_unit (item->per_cu->cu);
2434 item->per_cu->queued = 0;
2442 dwarf2_queue = dwarf2_queue_tail = NULL;
2445 /* Read in full symbols for PST, and anything it depends on. */
2448 psymtab_to_symtab_1 (struct partial_symtab *pst)
2450 struct dwarf2_per_cu_data *per_cu;
2451 struct cleanup *back_to;
2454 for (i = 0; i < pst->number_of_dependencies; i++)
2455 if (!pst->dependencies[i]->readin)
2457 /* Inform about additional files that need to be read in. */
2460 /* FIXME: i18n: Need to make this a single string. */
2461 fputs_filtered (" ", gdb_stdout);
2463 fputs_filtered ("and ", gdb_stdout);
2465 printf_filtered ("%s...", pst->dependencies[i]->filename);
2466 wrap_here (""); /* Flush output */
2467 gdb_flush (gdb_stdout);
2469 psymtab_to_symtab_1 (pst->dependencies[i]);
2472 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
2476 /* It's an include file, no symbols to read for it.
2477 Everything is in the parent symtab. */
2482 back_to = make_cleanup (dwarf2_release_queue, NULL);
2484 queue_comp_unit (per_cu);
2486 process_queue (pst->objfile);
2488 /* Age the cache, releasing compilation units that have not
2489 been used recently. */
2490 age_cached_comp_units ();
2492 do_cleanups (back_to);
2495 /* Load the DIEs associated with PST and PER_CU into memory. */
2497 static struct dwarf2_cu *
2498 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2500 struct partial_symtab *pst = per_cu->psymtab;
2501 bfd *abfd = pst->objfile->obfd;
2502 struct dwarf2_cu *cu;
2503 unsigned long offset;
2505 struct cleanup *back_to, *free_cu_cleanup;
2506 struct attribute *attr;
2509 /* Set local variables from the partial symbol table info. */
2510 offset = per_cu->offset;
2512 info_ptr = dwarf2_per_objfile->info_buffer + offset;
2514 cu = xmalloc (sizeof (struct dwarf2_cu));
2515 memset (cu, 0, sizeof (struct dwarf2_cu));
2517 /* If an error occurs while loading, release our storage. */
2518 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
2520 cu->objfile = pst->objfile;
2522 /* read in the comp_unit header */
2523 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
2525 /* Read the abbrevs for this compilation unit */
2526 dwarf2_read_abbrevs (abfd, cu);
2527 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2529 cu->header.offset = offset;
2531 cu->per_cu = per_cu;
2534 /* We use this obstack for block values in dwarf_alloc_block. */
2535 obstack_init (&cu->comp_unit_obstack);
2537 cu->dies = read_comp_unit (info_ptr, abfd, cu);
2539 /* We try not to read any attributes in this function, because not
2540 all objfiles needed for references have been loaded yet, and symbol
2541 table processing isn't initialized. But we have to set the CU language,
2542 or we won't be able to build types correctly. */
2543 attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
2545 set_cu_language (DW_UNSND (attr), cu);
2547 set_cu_language (language_minimal, cu);
2549 do_cleanups (back_to);
2551 /* We've successfully allocated this compilation unit. Let our caller
2552 clean it up when finished with it. */
2553 discard_cleanups (free_cu_cleanup);
2558 /* Generate full symbol information for PST and CU, whose DIEs have
2559 already been loaded into memory. */
2562 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2564 struct partial_symtab *pst = per_cu->psymtab;
2565 struct dwarf2_cu *cu = per_cu->cu;
2566 struct objfile *objfile = pst->objfile;
2567 bfd *abfd = objfile->obfd;
2568 CORE_ADDR lowpc, highpc;
2569 struct symtab *symtab;
2570 struct cleanup *back_to;
2571 struct attribute *attr;
2574 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2576 /* We're in the global namespace. */
2577 processing_current_prefix = "";
2580 back_to = make_cleanup (really_free_pendings, NULL);
2582 cu->list_in_scope = &file_symbols;
2584 /* Find the base address of the compilation unit for range lists and
2585 location lists. It will normally be specified by DW_AT_low_pc.
2586 In DWARF-3 draft 4, the base address could be overridden by
2587 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2588 compilation units with discontinuous ranges. */
2590 cu->header.base_known = 0;
2591 cu->header.base_address = 0;
2593 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
2596 cu->header.base_address = DW_ADDR (attr);
2597 cu->header.base_known = 1;
2601 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
2604 cu->header.base_address = DW_ADDR (attr);
2605 cu->header.base_known = 1;
2609 /* Do line number decoding in read_file_scope () */
2610 process_die (cu->dies, cu);
2612 /* Some compilers don't define a DW_AT_high_pc attribute for the
2613 compilation unit. If the DW_AT_high_pc is missing, synthesize
2614 it, by scanning the DIE's below the compilation unit. */
2615 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
2617 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2619 /* Set symtab language to language from DW_AT_language.
2620 If the compilation is from a C file generated by language preprocessors,
2621 do not set the language if it was already deduced by start_subfile. */
2623 && !(cu->language == language_c && symtab->language != language_c))
2625 symtab->language = cu->language;
2627 pst->symtab = symtab;
2630 do_cleanups (back_to);
2633 /* Process a die and its children. */
2636 process_die (struct die_info *die, struct dwarf2_cu *cu)
2640 case DW_TAG_padding:
2642 case DW_TAG_compile_unit:
2643 read_file_scope (die, cu);
2645 case DW_TAG_subprogram:
2646 read_subroutine_type (die, cu);
2647 read_func_scope (die, cu);
2649 case DW_TAG_inlined_subroutine:
2650 /* FIXME: These are ignored for now.
2651 They could be used to set breakpoints on all inlined instances
2652 of a function and make GDB `next' properly over inlined functions. */
2654 case DW_TAG_lexical_block:
2655 case DW_TAG_try_block:
2656 case DW_TAG_catch_block:
2657 read_lexical_block_scope (die, cu);
2659 case DW_TAG_class_type:
2660 case DW_TAG_structure_type:
2661 case DW_TAG_union_type:
2662 read_structure_type (die, cu);
2663 process_structure_scope (die, cu);
2665 case DW_TAG_enumeration_type:
2666 read_enumeration_type (die, cu);
2667 process_enumeration_scope (die, cu);
2670 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2671 a symbol or process any children. Therefore it doesn't do anything
2672 that won't be done on-demand by read_type_die. */
2673 case DW_TAG_subroutine_type:
2674 read_subroutine_type (die, cu);
2676 case DW_TAG_set_type:
2677 read_set_type (die, cu);
2679 case DW_TAG_array_type:
2680 read_array_type (die, cu);
2682 case DW_TAG_pointer_type:
2683 read_tag_pointer_type (die, cu);
2685 case DW_TAG_ptr_to_member_type:
2686 read_tag_ptr_to_member_type (die, cu);
2688 case DW_TAG_reference_type:
2689 read_tag_reference_type (die, cu);
2691 case DW_TAG_string_type:
2692 read_tag_string_type (die, cu);
2696 case DW_TAG_base_type:
2697 read_base_type (die, cu);
2698 /* Add a typedef symbol for the type definition, if it has a
2700 new_symbol (die, die->type, cu);
2702 case DW_TAG_subrange_type:
2703 read_subrange_type (die, cu);
2704 /* Add a typedef symbol for the type definition, if it has a
2706 new_symbol (die, die->type, cu);
2708 case DW_TAG_common_block:
2709 read_common_block (die, cu);
2711 case DW_TAG_common_inclusion:
2713 case DW_TAG_namespace:
2714 processing_has_namespace_info = 1;
2715 read_namespace (die, cu);
2717 case DW_TAG_imported_declaration:
2718 case DW_TAG_imported_module:
2719 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2720 information contained in these. DW_TAG_imported_declaration
2721 dies shouldn't have children; DW_TAG_imported_module dies
2722 shouldn't in the C++ case, but conceivably could in the
2723 Fortran case, so we'll have to replace this gdb_assert if
2724 Fortran compilers start generating that info. */
2725 processing_has_namespace_info = 1;
2726 gdb_assert (die->child == NULL);
2729 new_symbol (die, NULL, cu);
2735 initialize_cu_func_list (struct dwarf2_cu *cu)
2737 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2741 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2743 struct objfile *objfile = cu->objfile;
2744 struct comp_unit_head *cu_header = &cu->header;
2745 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2746 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2747 CORE_ADDR highpc = ((CORE_ADDR) 0);
2748 struct attribute *attr;
2749 char *name = "<unknown>";
2750 char *comp_dir = NULL;
2751 struct die_info *child_die;
2752 bfd *abfd = objfile->obfd;
2753 struct line_header *line_header = 0;
2756 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2758 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2760 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2761 from finish_block. */
2762 if (lowpc == ((CORE_ADDR) -1))
2767 attr = dwarf2_attr (die, DW_AT_name, cu);
2770 name = DW_STRING (attr);
2772 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2775 comp_dir = DW_STRING (attr);
2778 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2779 directory, get rid of it. */
2780 char *cp = strchr (comp_dir, ':');
2782 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2787 attr = dwarf2_attr (die, DW_AT_language, cu);
2790 set_cu_language (DW_UNSND (attr), cu);
2793 attr = dwarf2_attr (die, DW_AT_producer, cu);
2795 cu->producer = DW_STRING (attr);
2797 /* We assume that we're processing GCC output. */
2798 processing_gcc_compilation = 2;
2800 /* FIXME:Do something here. */
2801 if (dip->at_producer != NULL)
2803 handle_producer (dip->at_producer);
2807 /* The compilation unit may be in a different language or objfile,
2808 zero out all remembered fundamental types. */
2809 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2811 start_symtab (name, comp_dir, lowpc);
2812 record_debugformat ("DWARF 2");
2814 initialize_cu_func_list (cu);
2816 /* Process all dies in compilation unit. */
2817 if (die->child != NULL)
2819 child_die = die->child;
2820 while (child_die && child_die->tag)
2822 process_die (child_die, cu);
2823 child_die = sibling_die (child_die);
2827 /* Decode line number information if present. */
2828 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2831 unsigned int line_offset = DW_UNSND (attr);
2832 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2835 make_cleanup ((make_cleanup_ftype *) free_line_header,
2836 (void *) line_header);
2837 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2841 /* Decode macro information, if present. Dwarf 2 macro information
2842 refers to information in the line number info statement program
2843 header, so we can only read it if we've read the header
2845 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2846 if (attr && line_header)
2848 unsigned int macro_offset = DW_UNSND (attr);
2849 dwarf_decode_macros (line_header, macro_offset,
2850 comp_dir, abfd, cu);
2852 do_cleanups (back_to);
2856 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2857 struct dwarf2_cu *cu)
2859 struct function_range *thisfn;
2861 thisfn = (struct function_range *)
2862 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2863 thisfn->name = name;
2864 thisfn->lowpc = lowpc;
2865 thisfn->highpc = highpc;
2866 thisfn->seen_line = 0;
2867 thisfn->next = NULL;
2869 if (cu->last_fn == NULL)
2870 cu->first_fn = thisfn;
2872 cu->last_fn->next = thisfn;
2874 cu->last_fn = thisfn;
2878 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2880 struct objfile *objfile = cu->objfile;
2881 struct context_stack *new;
2884 struct die_info *child_die;
2885 struct attribute *attr;
2887 const char *previous_prefix = processing_current_prefix;
2888 struct cleanup *back_to = NULL;
2891 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2893 name = dwarf2_linkage_name (die, cu);
2895 /* Ignore functions with missing or empty names and functions with
2896 missing or invalid low and high pc attributes. */
2897 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2900 if (cu->language == language_cplus
2901 || cu->language == language_java)
2903 struct die_info *spec_die = die_specification (die, cu);
2905 /* NOTE: carlton/2004-01-23: We have to be careful in the
2906 presence of DW_AT_specification. For example, with GCC 3.4,
2911 // Definition of N::foo.
2915 then we'll have a tree of DIEs like this:
2917 1: DW_TAG_compile_unit
2918 2: DW_TAG_namespace // N
2919 3: DW_TAG_subprogram // declaration of N::foo
2920 4: DW_TAG_subprogram // definition of N::foo
2921 DW_AT_specification // refers to die #3
2923 Thus, when processing die #4, we have to pretend that we're
2924 in the context of its DW_AT_specification, namely the contex
2927 if (spec_die != NULL)
2929 char *specification_prefix = determine_prefix (spec_die, cu);
2930 processing_current_prefix = specification_prefix;
2931 back_to = make_cleanup (xfree, specification_prefix);
2938 /* Record the function range for dwarf_decode_lines. */
2939 add_to_cu_func_list (name, lowpc, highpc, cu);
2941 new = push_context (0, lowpc);
2942 new->name = new_symbol (die, die->type, cu);
2944 /* If there is a location expression for DW_AT_frame_base, record
2946 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2948 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2949 expression is being recorded directly in the function's symbol
2950 and not in a separate frame-base object. I guess this hack is
2951 to avoid adding some sort of frame-base adjunct/annex to the
2952 function's symbol :-(. The problem with doing this is that it
2953 results in a function symbol with a location expression that
2954 has nothing to do with the location of the function, ouch! The
2955 relationship should be: a function's symbol has-a frame base; a
2956 frame-base has-a location expression. */
2957 dwarf2_symbol_mark_computed (attr, new->name, cu);
2959 cu->list_in_scope = &local_symbols;
2961 if (die->child != NULL)
2963 child_die = die->child;
2964 while (child_die && child_die->tag)
2966 process_die (child_die, cu);
2967 child_die = sibling_die (child_die);
2971 new = pop_context ();
2972 /* Make a block for the local symbols within. */
2973 finish_block (new->name, &local_symbols, new->old_blocks,
2974 lowpc, highpc, objfile);
2976 /* In C++, we can have functions nested inside functions (e.g., when
2977 a function declares a class that has methods). This means that
2978 when we finish processing a function scope, we may need to go
2979 back to building a containing block's symbol lists. */
2980 local_symbols = new->locals;
2981 param_symbols = new->params;
2983 /* If we've finished processing a top-level function, subsequent
2984 symbols go in the file symbol list. */
2985 if (outermost_context_p ())
2986 cu->list_in_scope = &file_symbols;
2988 processing_current_prefix = previous_prefix;
2989 if (back_to != NULL)
2990 do_cleanups (back_to);
2993 /* Process all the DIES contained within a lexical block scope. Start
2994 a new scope, process the dies, and then close the scope. */
2997 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2999 struct objfile *objfile = cu->objfile;
3000 struct context_stack *new;
3001 CORE_ADDR lowpc, highpc;
3002 struct die_info *child_die;
3005 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3007 /* Ignore blocks with missing or invalid low and high pc attributes. */
3008 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3009 as multiple lexical blocks? Handling children in a sane way would
3010 be nasty. Might be easier to properly extend generic blocks to
3012 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
3017 push_context (0, lowpc);
3018 if (die->child != NULL)
3020 child_die = die->child;
3021 while (child_die && child_die->tag)
3023 process_die (child_die, cu);
3024 child_die = sibling_die (child_die);
3027 new = pop_context ();
3029 if (local_symbols != NULL)
3031 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3034 local_symbols = new->locals;
3037 /* Get low and high pc attributes from a die. Return 1 if the attributes
3038 are present and valid, otherwise, return 0. Return -1 if the range is
3039 discontinuous, i.e. derived from DW_AT_ranges information. */
3041 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
3042 CORE_ADDR *highpc, struct dwarf2_cu *cu)
3044 struct objfile *objfile = cu->objfile;
3045 struct comp_unit_head *cu_header = &cu->header;
3046 struct attribute *attr;
3047 bfd *obfd = objfile->obfd;
3052 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
3055 high = DW_ADDR (attr);
3056 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3058 low = DW_ADDR (attr);
3060 /* Found high w/o low attribute. */
3063 /* Found consecutive range of addresses. */
3068 attr = dwarf2_attr (die, DW_AT_ranges, cu);
3071 unsigned int addr_size = cu_header->addr_size;
3072 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3073 /* Value of the DW_AT_ranges attribute is the offset in the
3074 .debug_ranges section. */
3075 unsigned int offset = DW_UNSND (attr);
3076 /* Base address selection entry. */
3084 found_base = cu_header->base_known;
3085 base = cu_header->base_address;
3087 if (offset >= dwarf2_per_objfile->ranges_size)
3089 complaint (&symfile_complaints,
3090 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3094 buffer = dwarf2_per_objfile->ranges_buffer + offset;
3096 /* Read in the largest possible address. */
3097 marker = read_address (obfd, buffer, cu, &dummy);
3098 if ((marker & mask) == mask)
3100 /* If we found the largest possible address, then
3101 read the base address. */
3102 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3103 buffer += 2 * addr_size;
3104 offset += 2 * addr_size;
3112 CORE_ADDR range_beginning, range_end;
3114 range_beginning = read_address (obfd, buffer, cu, &dummy);
3115 buffer += addr_size;
3116 range_end = read_address (obfd, buffer, cu, &dummy);
3117 buffer += addr_size;
3118 offset += 2 * addr_size;
3120 /* An end of list marker is a pair of zero addresses. */
3121 if (range_beginning == 0 && range_end == 0)
3122 /* Found the end of list entry. */
3125 /* Each base address selection entry is a pair of 2 values.
3126 The first is the largest possible address, the second is
3127 the base address. Check for a base address here. */
3128 if ((range_beginning & mask) == mask)
3130 /* If we found the largest possible address, then
3131 read the base address. */
3132 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3139 /* We have no valid base address for the ranges
3141 complaint (&symfile_complaints,
3142 _("Invalid .debug_ranges data (no base address)"));
3146 range_beginning += base;
3149 /* FIXME: This is recording everything as a low-high
3150 segment of consecutive addresses. We should have a
3151 data structure for discontiguous block ranges
3155 low = range_beginning;
3161 if (range_beginning < low)
3162 low = range_beginning;
3163 if (range_end > high)
3169 /* If the first entry is an end-of-list marker, the range
3170 describes an empty scope, i.e. no instructions. */
3180 /* When using the GNU linker, .gnu.linkonce. sections are used to
3181 eliminate duplicate copies of functions and vtables and such.
3182 The linker will arbitrarily choose one and discard the others.
3183 The AT_*_pc values for such functions refer to local labels in
3184 these sections. If the section from that file was discarded, the
3185 labels are not in the output, so the relocs get a value of 0.
3186 If this is a discarded function, mark the pc bounds as invalid,
3187 so that GDB will ignore it. */
3188 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
3196 /* Get the low and high pc's represented by the scope DIE, and store
3197 them in *LOWPC and *HIGHPC. If the correct values can't be
3198 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3201 get_scope_pc_bounds (struct die_info *die,
3202 CORE_ADDR *lowpc, CORE_ADDR *highpc,
3203 struct dwarf2_cu *cu)
3205 CORE_ADDR best_low = (CORE_ADDR) -1;
3206 CORE_ADDR best_high = (CORE_ADDR) 0;
3207 CORE_ADDR current_low, current_high;
3209 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
3211 best_low = current_low;
3212 best_high = current_high;
3216 struct die_info *child = die->child;
3218 while (child && child->tag)
3220 switch (child->tag) {
3221 case DW_TAG_subprogram:
3222 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
3224 best_low = min (best_low, current_low);
3225 best_high = max (best_high, current_high);
3228 case DW_TAG_namespace:
3229 /* FIXME: carlton/2004-01-16: Should we do this for
3230 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3231 that current GCC's always emit the DIEs corresponding
3232 to definitions of methods of classes as children of a
3233 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3234 the DIEs giving the declarations, which could be
3235 anywhere). But I don't see any reason why the
3236 standards says that they have to be there. */
3237 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
3239 if (current_low != ((CORE_ADDR) -1))
3241 best_low = min (best_low, current_low);
3242 best_high = max (best_high, current_high);
3250 child = sibling_die (child);
3255 *highpc = best_high;
3258 /* Add an aggregate field to the field list. */
3261 dwarf2_add_field (struct field_info *fip, struct die_info *die,
3262 struct dwarf2_cu *cu)
3264 struct objfile *objfile = cu->objfile;
3265 struct nextfield *new_field;
3266 struct attribute *attr;
3268 char *fieldname = "";
3270 /* Allocate a new field list entry and link it in. */
3271 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3272 make_cleanup (xfree, new_field);
3273 memset (new_field, 0, sizeof (struct nextfield));
3274 new_field->next = fip->fields;
3275 fip->fields = new_field;
3278 /* Handle accessibility and virtuality of field.
3279 The default accessibility for members is public, the default
3280 accessibility for inheritance is private. */
3281 if (die->tag != DW_TAG_inheritance)
3282 new_field->accessibility = DW_ACCESS_public;
3284 new_field->accessibility = DW_ACCESS_private;
3285 new_field->virtuality = DW_VIRTUALITY_none;
3287 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3289 new_field->accessibility = DW_UNSND (attr);
3290 if (new_field->accessibility != DW_ACCESS_public)
3291 fip->non_public_fields = 1;
3292 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
3294 new_field->virtuality = DW_UNSND (attr);
3296 fp = &new_field->field;
3298 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
3300 /* Data member other than a C++ static data member. */
3302 /* Get type of field. */
3303 fp->type = die_type (die, cu);
3305 FIELD_STATIC_KIND (*fp) = 0;
3307 /* Get bit size of field (zero if none). */
3308 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
3311 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
3315 FIELD_BITSIZE (*fp) = 0;
3318 /* Get bit offset of field. */
3319 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3322 FIELD_BITPOS (*fp) =
3323 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
3326 FIELD_BITPOS (*fp) = 0;
3327 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
3330 if (BITS_BIG_ENDIAN)
3332 /* For big endian bits, the DW_AT_bit_offset gives the
3333 additional bit offset from the MSB of the containing
3334 anonymous object to the MSB of the field. We don't
3335 have to do anything special since we don't need to
3336 know the size of the anonymous object. */
3337 FIELD_BITPOS (*fp) += DW_UNSND (attr);
3341 /* For little endian bits, compute the bit offset to the
3342 MSB of the anonymous object, subtract off the number of
3343 bits from the MSB of the field to the MSB of the
3344 object, and then subtract off the number of bits of
3345 the field itself. The result is the bit offset of
3346 the LSB of the field. */
3348 int bit_offset = DW_UNSND (attr);
3350 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3353 /* The size of the anonymous object containing
3354 the bit field is explicit, so use the
3355 indicated size (in bytes). */
3356 anonymous_size = DW_UNSND (attr);
3360 /* The size of the anonymous object containing
3361 the bit field must be inferred from the type
3362 attribute of the data member containing the
3364 anonymous_size = TYPE_LENGTH (fp->type);
3366 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
3367 - bit_offset - FIELD_BITSIZE (*fp);
3371 /* Get name of field. */
3372 attr = dwarf2_attr (die, DW_AT_name, cu);
3373 if (attr && DW_STRING (attr))
3374 fieldname = DW_STRING (attr);
3376 /* The name is already allocated along with this objfile, so we don't
3377 need to duplicate it for the type. */
3378 fp->name = fieldname;
3380 /* Change accessibility for artificial fields (e.g. virtual table
3381 pointer or virtual base class pointer) to private. */
3382 if (dwarf2_attr (die, DW_AT_artificial, cu))
3384 new_field->accessibility = DW_ACCESS_private;
3385 fip->non_public_fields = 1;
3388 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
3390 /* C++ static member. */
3392 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3393 is a declaration, but all versions of G++ as of this writing
3394 (so through at least 3.2.1) incorrectly generate
3395 DW_TAG_variable tags. */
3399 /* Get name of field. */
3400 attr = dwarf2_attr (die, DW_AT_name, cu);
3401 if (attr && DW_STRING (attr))
3402 fieldname = DW_STRING (attr);
3406 /* Get physical name. */
3407 physname = dwarf2_linkage_name (die, cu);
3409 /* The name is already allocated along with this objfile, so we don't
3410 need to duplicate it for the type. */
3411 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
3412 FIELD_TYPE (*fp) = die_type (die, cu);
3413 FIELD_NAME (*fp) = fieldname;
3415 else if (die->tag == DW_TAG_inheritance)
3417 /* C++ base class field. */
3418 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3420 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
3422 FIELD_BITSIZE (*fp) = 0;
3423 FIELD_STATIC_KIND (*fp) = 0;
3424 FIELD_TYPE (*fp) = die_type (die, cu);
3425 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
3426 fip->nbaseclasses++;
3430 /* Create the vector of fields, and attach it to the type. */
3433 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3434 struct dwarf2_cu *cu)
3436 int nfields = fip->nfields;
3438 /* Record the field count, allocate space for the array of fields,
3439 and create blank accessibility bitfields if necessary. */
3440 TYPE_NFIELDS (type) = nfields;
3441 TYPE_FIELDS (type) = (struct field *)
3442 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3443 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3445 if (fip->non_public_fields)
3447 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3449 TYPE_FIELD_PRIVATE_BITS (type) =
3450 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3451 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3453 TYPE_FIELD_PROTECTED_BITS (type) =
3454 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3455 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3457 TYPE_FIELD_IGNORE_BITS (type) =
3458 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3459 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3462 /* If the type has baseclasses, allocate and clear a bit vector for
3463 TYPE_FIELD_VIRTUAL_BITS. */
3464 if (fip->nbaseclasses)
3466 int num_bytes = B_BYTES (fip->nbaseclasses);
3467 unsigned char *pointer;
3469 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3470 pointer = TYPE_ALLOC (type, num_bytes);
3471 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
3472 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3473 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3476 /* Copy the saved-up fields into the field vector. Start from the head
3477 of the list, adding to the tail of the field array, so that they end
3478 up in the same order in the array in which they were added to the list. */
3479 while (nfields-- > 0)
3481 TYPE_FIELD (type, nfields) = fip->fields->field;
3482 switch (fip->fields->accessibility)
3484 case DW_ACCESS_private:
3485 SET_TYPE_FIELD_PRIVATE (type, nfields);
3488 case DW_ACCESS_protected:
3489 SET_TYPE_FIELD_PROTECTED (type, nfields);
3492 case DW_ACCESS_public:
3496 /* Unknown accessibility. Complain and treat it as public. */
3498 complaint (&symfile_complaints, _("unsupported accessibility %d"),
3499 fip->fields->accessibility);
3503 if (nfields < fip->nbaseclasses)
3505 switch (fip->fields->virtuality)
3507 case DW_VIRTUALITY_virtual:
3508 case DW_VIRTUALITY_pure_virtual:
3509 SET_TYPE_FIELD_VIRTUAL (type, nfields);
3513 fip->fields = fip->fields->next;
3517 /* Add a member function to the proper fieldlist. */
3520 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3521 struct type *type, struct dwarf2_cu *cu)
3523 struct objfile *objfile = cu->objfile;
3524 struct attribute *attr;
3525 struct fnfieldlist *flp;
3527 struct fn_field *fnp;
3530 struct nextfnfield *new_fnfield;
3532 /* Get name of member function. */
3533 attr = dwarf2_attr (die, DW_AT_name, cu);
3534 if (attr && DW_STRING (attr))
3535 fieldname = DW_STRING (attr);
3539 /* Get the mangled name. */
3540 physname = dwarf2_linkage_name (die, cu);
3542 /* Look up member function name in fieldlist. */
3543 for (i = 0; i < fip->nfnfields; i++)
3545 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3549 /* Create new list element if necessary. */
3550 if (i < fip->nfnfields)
3551 flp = &fip->fnfieldlists[i];
3554 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3556 fip->fnfieldlists = (struct fnfieldlist *)
3557 xrealloc (fip->fnfieldlists,
3558 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3559 * sizeof (struct fnfieldlist));
3560 if (fip->nfnfields == 0)
3561 make_cleanup (free_current_contents, &fip->fnfieldlists);
3563 flp = &fip->fnfieldlists[fip->nfnfields];
3564 flp->name = fieldname;
3570 /* Create a new member function field and chain it to the field list
3572 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3573 make_cleanup (xfree, new_fnfield);
3574 memset (new_fnfield, 0, sizeof (struct nextfnfield));
3575 new_fnfield->next = flp->head;
3576 flp->head = new_fnfield;
3579 /* Fill in the member function field info. */
3580 fnp = &new_fnfield->fnfield;
3581 /* The name is already allocated along with this objfile, so we don't
3582 need to duplicate it for the type. */
3583 fnp->physname = physname ? physname : "";
3584 fnp->type = alloc_type (objfile);
3585 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3587 int nparams = TYPE_NFIELDS (die->type);
3589 /* TYPE is the domain of this method, and DIE->TYPE is the type
3590 of the method itself (TYPE_CODE_METHOD). */
3591 smash_to_method_type (fnp->type, type,
3592 TYPE_TARGET_TYPE (die->type),
3593 TYPE_FIELDS (die->type),
3594 TYPE_NFIELDS (die->type),
3595 TYPE_VARARGS (die->type));
3597 /* Handle static member functions.
3598 Dwarf2 has no clean way to discern C++ static and non-static
3599 member functions. G++ helps GDB by marking the first
3600 parameter for non-static member functions (which is the
3601 this pointer) as artificial. We obtain this information
3602 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3603 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3604 fnp->voffset = VOFFSET_STATIC;
3607 complaint (&symfile_complaints, _("member function type missing for '%s'"),
3610 /* Get fcontext from DW_AT_containing_type if present. */
3611 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3612 fnp->fcontext = die_containing_type (die, cu);
3614 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3615 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3617 /* Get accessibility. */
3618 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3621 switch (DW_UNSND (attr))
3623 case DW_ACCESS_private:
3624 fnp->is_private = 1;
3626 case DW_ACCESS_protected:
3627 fnp->is_protected = 1;
3632 /* Check for artificial methods. */
3633 attr = dwarf2_attr (die, DW_AT_artificial, cu);
3634 if (attr && DW_UNSND (attr) != 0)
3635 fnp->is_artificial = 1;
3637 /* Get index in virtual function table if it is a virtual member function. */
3638 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3641 /* Support the .debug_loc offsets */
3642 if (attr_form_is_block (attr))
3644 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3646 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3648 dwarf2_complex_location_expr_complaint ();
3652 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3658 /* Create the vector of member function fields, and attach it to the type. */
3661 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3662 struct dwarf2_cu *cu)
3664 struct fnfieldlist *flp;
3665 int total_length = 0;
3668 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3669 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3670 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3672 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3674 struct nextfnfield *nfp = flp->head;
3675 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3678 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3679 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3680 fn_flp->fn_fields = (struct fn_field *)
3681 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3682 for (k = flp->length; (k--, nfp); nfp = nfp->next)
3683 fn_flp->fn_fields[k] = nfp->fnfield;
3685 total_length += flp->length;
3688 TYPE_NFN_FIELDS (type) = fip->nfnfields;
3689 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3693 /* Returns non-zero if NAME is the name of a vtable member in CU's
3694 language, zero otherwise. */
3696 is_vtable_name (const char *name, struct dwarf2_cu *cu)
3698 static const char vptr[] = "_vptr";
3699 static const char vtable[] = "vtable";
3701 /* Look for the C++ and Java forms of the vtable. */
3702 if ((cu->language == language_java
3703 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
3704 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
3705 && is_cplus_marker (name[sizeof (vptr) - 1])))
3711 /* GCC outputs unnamed structures that are really pointers to member
3712 functions, with the ABI-specified layout. If DIE (from CU) describes
3713 such a structure, set its type, and return nonzero. Otherwise return
3717 quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu)
3719 struct objfile *objfile = cu->objfile;
3721 struct die_info *pfn_die, *delta_die;
3722 struct attribute *pfn_name, *delta_name;
3723 struct type *pfn_type, *domain_type;
3725 /* Check for a structure with no name and two children. */
3726 if (die->tag != DW_TAG_structure_type
3727 || dwarf2_attr (die, DW_AT_name, cu) != NULL
3728 || die->child == NULL
3729 || die->child->sibling == NULL
3730 || (die->child->sibling->sibling != NULL
3731 && die->child->sibling->sibling->tag != DW_TAG_padding))
3734 /* Check for __pfn and __delta members. */
3735 pfn_die = die->child;
3736 pfn_name = dwarf2_attr (pfn_die, DW_AT_name, cu);
3737 if (pfn_die->tag != DW_TAG_member
3739 || DW_STRING (pfn_name) == NULL
3740 || strcmp ("__pfn", DW_STRING (pfn_name)) != 0)
3743 delta_die = pfn_die->sibling;
3744 delta_name = dwarf2_attr (delta_die, DW_AT_name, cu);
3745 if (delta_die->tag != DW_TAG_member
3746 || delta_name == NULL
3747 || DW_STRING (delta_name) == NULL
3748 || strcmp ("__delta", DW_STRING (delta_name)) != 0)
3751 /* Find the type of the method. */
3752 pfn_type = die_type (pfn_die, cu);
3753 if (pfn_type == NULL
3754 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
3755 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
3758 /* Look for the "this" argument. */
3759 pfn_type = TYPE_TARGET_TYPE (pfn_type);
3760 if (TYPE_NFIELDS (pfn_type) == 0
3761 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
3764 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
3765 type = alloc_type (objfile);
3766 smash_to_method_type (type, domain_type, TYPE_TARGET_TYPE (pfn_type),
3767 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
3768 TYPE_VARARGS (pfn_type));
3769 type = lookup_pointer_type (type);
3770 set_die_type (die, type, cu);
3775 /* Called when we find the DIE that starts a structure or union scope
3776 (definition) to process all dies that define the members of the
3779 NOTE: we need to call struct_type regardless of whether or not the
3780 DIE has an at_name attribute, since it might be an anonymous
3781 structure or union. This gets the type entered into our set of
3784 However, if the structure is incomplete (an opaque struct/union)
3785 then suppress creating a symbol table entry for it since gdb only
3786 wants to find the one with the complete definition. Note that if
3787 it is complete, we just call new_symbol, which does it's own
3788 checking about whether the struct/union is anonymous or not (and
3789 suppresses creating a symbol table entry itself). */
3792 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3794 struct objfile *objfile = cu->objfile;
3796 struct attribute *attr;
3797 const char *previous_prefix = processing_current_prefix;
3798 struct cleanup *back_to = NULL;
3803 if (quirk_gcc_member_function_pointer (die, cu))
3806 type = alloc_type (objfile);
3807 INIT_CPLUS_SPECIFIC (type);
3808 attr = dwarf2_attr (die, DW_AT_name, cu);
3809 if (attr && DW_STRING (attr))
3811 if (cu->language == language_cplus
3812 || cu->language == language_java)
3814 char *new_prefix = determine_class_name (die, cu);
3815 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3816 strlen (new_prefix),
3817 &objfile->objfile_obstack);
3818 back_to = make_cleanup (xfree, new_prefix);
3819 processing_current_prefix = new_prefix;
3823 /* The name is already allocated along with this objfile, so
3824 we don't need to duplicate it for the type. */
3825 TYPE_TAG_NAME (type) = DW_STRING (attr);
3829 if (die->tag == DW_TAG_structure_type)
3831 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3833 else if (die->tag == DW_TAG_union_type)
3835 TYPE_CODE (type) = TYPE_CODE_UNION;
3839 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3841 TYPE_CODE (type) = TYPE_CODE_CLASS;
3844 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3847 TYPE_LENGTH (type) = DW_UNSND (attr);
3851 TYPE_LENGTH (type) = 0;
3854 if (die_is_declaration (die, cu))
3855 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3857 /* We need to add the type field to the die immediately so we don't
3858 infinitely recurse when dealing with pointers to the structure
3859 type within the structure itself. */
3860 set_die_type (die, type, cu);
3862 if (die->child != NULL && ! die_is_declaration (die, cu))
3864 struct field_info fi;
3865 struct die_info *child_die;
3866 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3868 memset (&fi, 0, sizeof (struct field_info));
3870 child_die = die->child;
3872 while (child_die && child_die->tag)
3874 if (child_die->tag == DW_TAG_member
3875 || child_die->tag == DW_TAG_variable)
3877 /* NOTE: carlton/2002-11-05: A C++ static data member
3878 should be a DW_TAG_member that is a declaration, but
3879 all versions of G++ as of this writing (so through at
3880 least 3.2.1) incorrectly generate DW_TAG_variable
3881 tags for them instead. */
3882 dwarf2_add_field (&fi, child_die, cu);
3884 else if (child_die->tag == DW_TAG_subprogram)
3886 /* C++ member function. */
3887 read_type_die (child_die, cu);
3888 dwarf2_add_member_fn (&fi, child_die, type, cu);
3890 else if (child_die->tag == DW_TAG_inheritance)
3892 /* C++ base class field. */
3893 dwarf2_add_field (&fi, child_die, cu);
3895 child_die = sibling_die (child_die);
3898 /* Attach fields and member functions to the type. */
3900 dwarf2_attach_fields_to_type (&fi, type, cu);
3903 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3905 /* Get the type which refers to the base class (possibly this
3906 class itself) which contains the vtable pointer for the current
3907 class from the DW_AT_containing_type attribute. */
3909 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3911 struct type *t = die_containing_type (die, cu);
3913 TYPE_VPTR_BASETYPE (type) = t;
3918 /* Our own class provides vtbl ptr. */
3919 for (i = TYPE_NFIELDS (t) - 1;
3920 i >= TYPE_N_BASECLASSES (t);
3923 char *fieldname = TYPE_FIELD_NAME (t, i);
3925 if (is_vtable_name (fieldname, cu))
3927 TYPE_VPTR_FIELDNO (type) = i;
3932 /* Complain if virtual function table field not found. */
3933 if (i < TYPE_N_BASECLASSES (t))
3934 complaint (&symfile_complaints,
3935 _("virtual function table pointer not found when defining class '%s'"),
3936 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3941 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3944 else if (cu->producer
3945 && strncmp (cu->producer,
3946 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3948 /* The IBM XLC compiler does not provide direct indication
3949 of the containing type, but the vtable pointer is
3950 always named __vfp. */
3954 for (i = TYPE_NFIELDS (type) - 1;
3955 i >= TYPE_N_BASECLASSES (type);
3958 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
3960 TYPE_VPTR_FIELDNO (type) = i;
3961 TYPE_VPTR_BASETYPE (type) = type;
3968 do_cleanups (back_to);
3971 processing_current_prefix = previous_prefix;
3972 if (back_to != NULL)
3973 do_cleanups (back_to);
3977 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3979 struct objfile *objfile = cu->objfile;
3980 const char *previous_prefix = processing_current_prefix;
3981 struct die_info *child_die = die->child;
3983 if (TYPE_TAG_NAME (die->type) != NULL)
3984 processing_current_prefix = TYPE_TAG_NAME (die->type);
3986 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3987 snapshots) has been known to create a die giving a declaration
3988 for a class that has, as a child, a die giving a definition for a
3989 nested class. So we have to process our children even if the
3990 current die is a declaration. Normally, of course, a declaration
3991 won't have any children at all. */
3993 while (child_die != NULL && child_die->tag)
3995 if (child_die->tag == DW_TAG_member
3996 || child_die->tag == DW_TAG_variable
3997 || child_die->tag == DW_TAG_inheritance)
4002 process_die (child_die, cu);
4004 child_die = sibling_die (child_die);
4007 if (die->child != NULL && ! die_is_declaration (die, cu))
4008 new_symbol (die, die->type, cu);
4010 processing_current_prefix = previous_prefix;
4013 /* Given a DW_AT_enumeration_type die, set its type. We do not
4014 complete the type's fields yet, or create any symbols. */
4017 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
4019 struct objfile *objfile = cu->objfile;
4021 struct attribute *attr;
4026 type = alloc_type (objfile);
4028 TYPE_CODE (type) = TYPE_CODE_ENUM;
4029 attr = dwarf2_attr (die, DW_AT_name, cu);
4030 if (attr && DW_STRING (attr))
4032 char *name = DW_STRING (attr);
4034 if (processing_has_namespace_info)
4036 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
4037 processing_current_prefix,
4042 /* The name is already allocated along with this objfile, so
4043 we don't need to duplicate it for the type. */
4044 TYPE_TAG_NAME (type) = name;
4048 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4051 TYPE_LENGTH (type) = DW_UNSND (attr);
4055 TYPE_LENGTH (type) = 0;
4058 set_die_type (die, type, cu);
4061 /* Determine the name of the type represented by DIE, which should be
4062 a named C++ or Java compound type. Return the name in question; the caller
4063 is responsible for xfree()'ing it. */
4066 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
4068 struct cleanup *back_to = NULL;
4069 struct die_info *spec_die = die_specification (die, cu);
4070 char *new_prefix = NULL;
4072 /* If this is the definition of a class that is declared by another
4073 die, then processing_current_prefix may not be accurate; see
4074 read_func_scope for a similar example. */
4075 if (spec_die != NULL)
4077 char *specification_prefix = determine_prefix (spec_die, cu);
4078 processing_current_prefix = specification_prefix;
4079 back_to = make_cleanup (xfree, specification_prefix);
4082 /* If we don't have namespace debug info, guess the name by trying
4083 to demangle the names of members, just like we did in
4084 guess_structure_name. */
4085 if (!processing_has_namespace_info)
4087 struct die_info *child;
4089 for (child = die->child;
4090 child != NULL && child->tag != 0;
4091 child = sibling_die (child))
4093 if (child->tag == DW_TAG_subprogram)
4096 = language_class_name_from_physname (cu->language_defn,
4100 if (new_prefix != NULL)
4106 if (new_prefix == NULL)
4108 const char *name = dwarf2_name (die, cu);
4109 new_prefix = typename_concat (NULL, processing_current_prefix,
4110 name ? name : "<<anonymous>>",
4114 if (back_to != NULL)
4115 do_cleanups (back_to);
4120 /* Given a pointer to a die which begins an enumeration, process all
4121 the dies that define the members of the enumeration, and create the
4122 symbol for the enumeration type.
4124 NOTE: We reverse the order of the element list. */
4127 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4129 struct objfile *objfile = cu->objfile;
4130 struct die_info *child_die;
4131 struct field *fields;
4132 struct attribute *attr;
4135 int unsigned_enum = 1;
4139 if (die->child != NULL)
4141 child_die = die->child;
4142 while (child_die && child_die->tag)
4144 if (child_die->tag != DW_TAG_enumerator)
4146 process_die (child_die, cu);
4150 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4153 sym = new_symbol (child_die, die->type, cu);
4154 if (SYMBOL_VALUE (sym) < 0)
4157 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4159 fields = (struct field *)
4161 (num_fields + DW_FIELD_ALLOC_CHUNK)
4162 * sizeof (struct field));
4165 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4166 FIELD_TYPE (fields[num_fields]) = NULL;
4167 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4168 FIELD_BITSIZE (fields[num_fields]) = 0;
4169 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4175 child_die = sibling_die (child_die);
4180 TYPE_NFIELDS (die->type) = num_fields;
4181 TYPE_FIELDS (die->type) = (struct field *)
4182 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4183 memcpy (TYPE_FIELDS (die->type), fields,
4184 sizeof (struct field) * num_fields);
4188 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4191 new_symbol (die, die->type, cu);
4194 /* Extract all information from a DW_TAG_array_type DIE and put it in
4195 the DIE's type field. For now, this only handles one dimensional
4199 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4201 struct objfile *objfile = cu->objfile;
4202 struct die_info *child_die;
4203 struct type *type = NULL;
4204 struct type *element_type, *range_type, *index_type;
4205 struct type **range_types = NULL;
4206 struct attribute *attr;
4208 struct cleanup *back_to;
4210 /* Return if we've already decoded this type. */
4216 element_type = die_type (die, cu);
4218 /* Irix 6.2 native cc creates array types without children for
4219 arrays with unspecified length. */
4220 if (die->child == NULL)
4222 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4223 range_type = create_range_type (NULL, index_type, 0, -1);
4224 set_die_type (die, create_array_type (NULL, element_type, range_type),
4229 back_to = make_cleanup (null_cleanup, NULL);
4230 child_die = die->child;
4231 while (child_die && child_die->tag)
4233 if (child_die->tag == DW_TAG_subrange_type)
4235 read_subrange_type (child_die, cu);
4237 if (child_die->type != NULL)
4239 /* The range type was succesfully read. Save it for
4240 the array type creation. */
4241 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4243 range_types = (struct type **)
4244 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4245 * sizeof (struct type *));
4247 make_cleanup (free_current_contents, &range_types);
4249 range_types[ndim++] = child_die->type;
4252 child_die = sibling_die (child_die);
4255 /* Dwarf2 dimensions are output from left to right, create the
4256 necessary array types in backwards order. */
4258 type = element_type;
4260 if (read_array_order (die, cu) == DW_ORD_col_major)
4264 type = create_array_type (NULL, type, range_types[i++]);
4269 type = create_array_type (NULL, type, range_types[ndim]);
4272 /* Understand Dwarf2 support for vector types (like they occur on
4273 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4274 array type. This is not part of the Dwarf2/3 standard yet, but a
4275 custom vendor extension. The main difference between a regular
4276 array and the vector variant is that vectors are passed by value
4278 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4280 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4282 do_cleanups (back_to);
4284 /* Install the type in the die. */
4285 set_die_type (die, type, cu);
4288 static enum dwarf_array_dim_ordering
4289 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4291 struct attribute *attr;
4293 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4295 if (attr) return DW_SND (attr);
4298 GNU F77 is a special case, as at 08/2004 array type info is the
4299 opposite order to the dwarf2 specification, but data is still
4300 laid out as per normal fortran.
4302 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4306 if (cu->language == language_fortran &&
4307 cu->producer && strstr (cu->producer, "GNU F77"))
4309 return DW_ORD_row_major;
4312 switch (cu->language_defn->la_array_ordering)
4314 case array_column_major:
4315 return DW_ORD_col_major;
4316 case array_row_major:
4318 return DW_ORD_row_major;
4322 /* Extract all information from a DW_TAG_set_type DIE and put it in
4323 the DIE's type field. */
4326 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
4328 if (die->type == NULL)
4329 die->type = create_set_type ((struct type *) NULL, die_type (die, cu));
4332 /* First cut: install each common block member as a global variable. */
4335 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4337 struct die_info *child_die;
4338 struct attribute *attr;
4340 CORE_ADDR base = (CORE_ADDR) 0;
4342 attr = dwarf2_attr (die, DW_AT_location, cu);
4345 /* Support the .debug_loc offsets */
4346 if (attr_form_is_block (attr))
4348 base = decode_locdesc (DW_BLOCK (attr), cu);
4350 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4352 dwarf2_complex_location_expr_complaint ();
4356 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4357 "common block member");
4360 if (die->child != NULL)
4362 child_die = die->child;
4363 while (child_die && child_die->tag)
4365 sym = new_symbol (child_die, NULL, cu);
4366 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4369 SYMBOL_VALUE_ADDRESS (sym) =
4370 base + decode_locdesc (DW_BLOCK (attr), cu);
4371 add_symbol_to_list (sym, &global_symbols);
4373 child_die = sibling_die (child_die);
4378 /* Read a C++ namespace. */
4381 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4383 struct objfile *objfile = cu->objfile;
4384 const char *previous_prefix = processing_current_prefix;
4387 struct die_info *current_die;
4388 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4390 name = namespace_name (die, &is_anonymous, cu);
4392 /* Now build the name of the current namespace. */
4394 if (previous_prefix[0] == '\0')
4396 processing_current_prefix = name;
4400 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4401 make_cleanup (xfree, temp_name);
4402 processing_current_prefix = temp_name;
4405 /* Add a symbol associated to this if we haven't seen the namespace
4406 before. Also, add a using directive if it's an anonymous
4409 if (dwarf2_extension (die, cu) == NULL)
4413 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4414 this cast will hopefully become unnecessary. */
4415 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4416 (char *) processing_current_prefix,
4418 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4420 new_symbol (die, type, cu);
4421 set_die_type (die, type, cu);
4424 cp_add_using_directive (processing_current_prefix,
4425 strlen (previous_prefix),
4426 strlen (processing_current_prefix));
4429 if (die->child != NULL)
4431 struct die_info *child_die = die->child;
4433 while (child_die && child_die->tag)
4435 process_die (child_die, cu);
4436 child_die = sibling_die (child_die);
4440 processing_current_prefix = previous_prefix;
4441 do_cleanups (back_to);
4444 /* Return the name of the namespace represented by DIE. Set
4445 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4449 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4451 struct die_info *current_die;
4452 const char *name = NULL;
4454 /* Loop through the extensions until we find a name. */
4456 for (current_die = die;
4457 current_die != NULL;
4458 current_die = dwarf2_extension (die, cu))
4460 name = dwarf2_name (current_die, cu);
4465 /* Is it an anonymous namespace? */
4467 *is_anonymous = (name == NULL);
4469 name = "(anonymous namespace)";
4474 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4475 the user defined type vector. */
4478 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4480 struct comp_unit_head *cu_header = &cu->header;
4482 struct attribute *attr_byte_size;
4483 struct attribute *attr_address_class;
4484 int byte_size, addr_class;
4491 type = lookup_pointer_type (die_type (die, cu));
4493 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4495 byte_size = DW_UNSND (attr_byte_size);
4497 byte_size = cu_header->addr_size;
4499 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4500 if (attr_address_class)
4501 addr_class = DW_UNSND (attr_address_class);
4503 addr_class = DW_ADDR_none;
4505 /* If the pointer size or address class is different than the
4506 default, create a type variant marked as such and set the
4507 length accordingly. */
4508 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4510 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4514 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
4515 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4516 type = make_type_with_address_space (type, type_flags);
4518 else if (TYPE_LENGTH (type) != byte_size)
4520 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4523 /* Should we also complain about unhandled address classes? */
4527 TYPE_LENGTH (type) = byte_size;
4528 set_die_type (die, type, cu);
4531 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4532 the user defined type vector. */
4535 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4537 struct objfile *objfile = cu->objfile;
4539 struct type *to_type;
4540 struct type *domain;
4547 type = alloc_type (objfile);
4548 to_type = die_type (die, cu);
4549 domain = die_containing_type (die, cu);
4550 smash_to_member_type (type, domain, to_type);
4552 set_die_type (die, type, cu);
4555 /* Extract all information from a DW_TAG_reference_type DIE and add to
4556 the user defined type vector. */
4559 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4561 struct comp_unit_head *cu_header = &cu->header;
4563 struct attribute *attr;
4570 type = lookup_reference_type (die_type (die, cu));
4571 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4574 TYPE_LENGTH (type) = DW_UNSND (attr);
4578 TYPE_LENGTH (type) = cu_header->addr_size;
4580 set_die_type (die, type, cu);
4584 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4586 struct type *base_type;
4593 base_type = die_type (die, cu);
4594 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4599 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4601 struct type *base_type;
4608 base_type = die_type (die, cu);
4609 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4613 /* Extract all information from a DW_TAG_string_type DIE and add to
4614 the user defined type vector. It isn't really a user defined type,
4615 but it behaves like one, with other DIE's using an AT_user_def_type
4616 attribute to reference it. */
4619 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4621 struct objfile *objfile = cu->objfile;
4622 struct type *type, *range_type, *index_type, *char_type;
4623 struct attribute *attr;
4624 unsigned int length;
4631 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4634 length = DW_UNSND (attr);
4638 /* check for the DW_AT_byte_size attribute */
4639 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4642 length = DW_UNSND (attr);
4649 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4650 range_type = create_range_type (NULL, index_type, 1, length);
4651 if (cu->language == language_fortran)
4653 /* Need to create a unique string type for bounds
4655 type = create_string_type (0, range_type);
4659 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4660 type = create_string_type (char_type, range_type);
4662 set_die_type (die, type, cu);
4665 /* Handle DIES due to C code like:
4669 int (*funcp)(int a, long l);
4673 ('funcp' generates a DW_TAG_subroutine_type DIE)
4677 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4679 struct type *type; /* Type that this function returns */
4680 struct type *ftype; /* Function that returns above type */
4681 struct attribute *attr;
4683 /* Decode the type that this subroutine returns */
4688 type = die_type (die, cu);
4689 ftype = make_function_type (type, (struct type **) 0);
4691 /* All functions in C++ and Java have prototypes. */
4692 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4693 if ((attr && (DW_UNSND (attr) != 0))
4694 || cu->language == language_cplus
4695 || cu->language == language_java)
4696 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4698 if (die->child != NULL)
4700 struct die_info *child_die;
4704 /* Count the number of parameters.
4705 FIXME: GDB currently ignores vararg functions, but knows about
4706 vararg member functions. */
4707 child_die = die->child;
4708 while (child_die && child_die->tag)
4710 if (child_die->tag == DW_TAG_formal_parameter)
4712 else if (child_die->tag == DW_TAG_unspecified_parameters)
4713 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4714 child_die = sibling_die (child_die);
4717 /* Allocate storage for parameters and fill them in. */
4718 TYPE_NFIELDS (ftype) = nparams;
4719 TYPE_FIELDS (ftype) = (struct field *)
4720 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4722 child_die = die->child;
4723 while (child_die && child_die->tag)
4725 if (child_die->tag == DW_TAG_formal_parameter)
4727 /* Dwarf2 has no clean way to discern C++ static and non-static
4728 member functions. G++ helps GDB by marking the first
4729 parameter for non-static member functions (which is the
4730 this pointer) as artificial. We pass this information
4731 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4732 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4734 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4736 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4737 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4740 child_die = sibling_die (child_die);
4744 set_die_type (die, ftype, cu);
4748 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4750 struct objfile *objfile = cu->objfile;
4751 struct attribute *attr;
4756 attr = dwarf2_attr (die, DW_AT_name, cu);
4757 if (attr && DW_STRING (attr))
4759 name = DW_STRING (attr);
4761 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4762 TYPE_FLAG_TARGET_STUB, name, objfile),
4764 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4768 /* Find a representation of a given base type and install
4769 it in the TYPE field of the die. */
4772 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4774 struct objfile *objfile = cu->objfile;
4776 struct attribute *attr;
4777 int encoding = 0, size = 0;
4779 /* If we've already decoded this die, this is a no-op. */
4785 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4788 encoding = DW_UNSND (attr);
4790 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4793 size = DW_UNSND (attr);
4795 attr = dwarf2_attr (die, DW_AT_name, cu);
4796 if (attr && DW_STRING (attr))
4798 enum type_code code = TYPE_CODE_INT;
4803 case DW_ATE_address:
4804 /* Turn DW_ATE_address into a void * pointer. */
4805 code = TYPE_CODE_PTR;
4806 type_flags |= TYPE_FLAG_UNSIGNED;
4808 case DW_ATE_boolean:
4809 code = TYPE_CODE_BOOL;
4810 type_flags |= TYPE_FLAG_UNSIGNED;
4812 case DW_ATE_complex_float:
4813 code = TYPE_CODE_COMPLEX;
4816 code = TYPE_CODE_FLT;
4820 case DW_ATE_unsigned:
4821 type_flags |= TYPE_FLAG_UNSIGNED;
4823 case DW_ATE_signed_char:
4824 if (cu->language == language_m2)
4825 code = TYPE_CODE_CHAR;
4827 case DW_ATE_unsigned_char:
4828 if (cu->language == language_m2)
4829 code = TYPE_CODE_CHAR;
4830 type_flags |= TYPE_FLAG_UNSIGNED;
4833 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4834 dwarf_type_encoding_name (encoding));
4837 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4838 if (encoding == DW_ATE_address)
4839 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4841 else if (encoding == DW_ATE_complex_float)
4844 TYPE_TARGET_TYPE (type)
4845 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4846 else if (size == 16)
4847 TYPE_TARGET_TYPE (type)
4848 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4850 TYPE_TARGET_TYPE (type)
4851 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4856 type = dwarf_base_type (encoding, size, cu);
4858 set_die_type (die, type, cu);
4861 /* Read the given DW_AT_subrange DIE. */
4864 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4866 struct type *base_type;
4867 struct type *range_type;
4868 struct attribute *attr;
4872 /* If we have already decoded this die, then nothing more to do. */
4876 base_type = die_type (die, cu);
4877 if (base_type == NULL)
4879 complaint (&symfile_complaints,
4880 _("DW_AT_type missing from DW_TAG_subrange_type"));
4884 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4885 base_type = alloc_type (NULL);
4887 if (cu->language == language_fortran)
4889 /* FORTRAN implies a lower bound of 1, if not given. */
4893 /* FIXME: For variable sized arrays either of these could be
4894 a variable rather than a constant value. We'll allow it,
4895 but we don't know how to handle it. */
4896 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4898 low = dwarf2_get_attr_constant_value (attr, 0);
4900 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4903 if (attr->form == DW_FORM_block1)
4905 /* GCC encodes arrays with unspecified or dynamic length
4906 with a DW_FORM_block1 attribute.
4907 FIXME: GDB does not yet know how to handle dynamic
4908 arrays properly, treat them as arrays with unspecified
4911 FIXME: jimb/2003-09-22: GDB does not really know
4912 how to handle arrays of unspecified length
4913 either; we just represent them as zero-length
4914 arrays. Choose an appropriate upper bound given
4915 the lower bound we've computed above. */
4919 high = dwarf2_get_attr_constant_value (attr, 1);
4922 range_type = create_range_type (NULL, base_type, low, high);
4924 attr = dwarf2_attr (die, DW_AT_name, cu);
4925 if (attr && DW_STRING (attr))
4926 TYPE_NAME (range_type) = DW_STRING (attr);
4928 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4930 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4932 set_die_type (die, range_type, cu);
4936 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
4939 struct attribute *attr;
4944 /* For now, we only support the C meaning of an unspecified type: void. */
4946 attr = dwarf2_attr (die, DW_AT_name, cu);
4947 type = init_type (TYPE_CODE_VOID, 0, 0, attr ? DW_STRING (attr) : "",
4950 set_die_type (die, type, cu);
4953 /* Read a whole compilation unit into a linked list of dies. */
4955 static struct die_info *
4956 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4958 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4961 /* Read a single die and all its descendents. Set the die's sibling
4962 field to NULL; set other fields in the die correctly, and set all
4963 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4964 location of the info_ptr after reading all of those dies. PARENT
4965 is the parent of the die in question. */
4967 static struct die_info *
4968 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
4969 struct dwarf2_cu *cu,
4970 gdb_byte **new_info_ptr,
4971 struct die_info *parent)
4973 struct die_info *die;
4977 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4978 store_in_ref_table (die->offset, die, cu);
4982 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4988 *new_info_ptr = cur_ptr;
4991 die->sibling = NULL;
4992 die->parent = parent;
4996 /* Read a die, all of its descendents, and all of its siblings; set
4997 all of the fields of all of the dies correctly. Arguments are as
4998 in read_die_and_children. */
5000 static struct die_info *
5001 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
5002 struct dwarf2_cu *cu,
5003 gdb_byte **new_info_ptr,
5004 struct die_info *parent)
5006 struct die_info *first_die, *last_sibling;
5010 first_die = last_sibling = NULL;
5014 struct die_info *die
5015 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
5023 last_sibling->sibling = die;
5028 *new_info_ptr = cur_ptr;
5038 /* Free a linked list of dies. */
5041 free_die_list (struct die_info *dies)
5043 struct die_info *die, *next;
5048 if (die->child != NULL)
5049 free_die_list (die->child);
5050 next = die->sibling;
5057 /* Read the contents of the section at OFFSET and of size SIZE from the
5058 object file specified by OBJFILE into the objfile_obstack and return it. */
5061 dwarf2_read_section (struct objfile *objfile, asection *sectp)
5063 bfd *abfd = objfile->obfd;
5064 gdb_byte *buf, *retbuf;
5065 bfd_size_type size = bfd_get_section_size (sectp);
5070 buf = obstack_alloc (&objfile->objfile_obstack, size);
5071 retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
5075 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
5076 || bfd_bread (buf, size, abfd) != size)
5077 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5078 bfd_get_filename (abfd));
5083 /* In DWARF version 2, the description of the debugging information is
5084 stored in a separate .debug_abbrev section. Before we read any
5085 dies from a section we read in all abbreviations and install them
5086 in a hash table. This function also sets flags in CU describing
5087 the data found in the abbrev table. */
5090 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
5092 struct comp_unit_head *cu_header = &cu->header;
5093 gdb_byte *abbrev_ptr;
5094 struct abbrev_info *cur_abbrev;
5095 unsigned int abbrev_number, bytes_read, abbrev_name;
5096 unsigned int abbrev_form, hash_number;
5097 struct attr_abbrev *cur_attrs;
5098 unsigned int allocated_attrs;
5100 /* Initialize dwarf2 abbrevs */
5101 obstack_init (&cu->abbrev_obstack);
5102 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
5104 * sizeof (struct abbrev_info *)));
5105 memset (cu->dwarf2_abbrevs, 0,
5106 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
5108 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
5109 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5110 abbrev_ptr += bytes_read;
5112 allocated_attrs = ATTR_ALLOC_CHUNK;
5113 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
5115 /* loop until we reach an abbrev number of 0 */
5116 while (abbrev_number)
5118 cur_abbrev = dwarf_alloc_abbrev (cu);
5120 /* read in abbrev header */
5121 cur_abbrev->number = abbrev_number;
5122 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5123 abbrev_ptr += bytes_read;
5124 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5127 if (cur_abbrev->tag == DW_TAG_namespace)
5128 cu->has_namespace_info = 1;
5130 /* now read in declarations */
5131 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5132 abbrev_ptr += bytes_read;
5133 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5134 abbrev_ptr += bytes_read;
5137 if (cur_abbrev->num_attrs == allocated_attrs)
5139 allocated_attrs += ATTR_ALLOC_CHUNK;
5141 = xrealloc (cur_attrs, (allocated_attrs
5142 * sizeof (struct attr_abbrev)));
5145 /* Record whether this compilation unit might have
5146 inter-compilation-unit references. If we don't know what form
5147 this attribute will have, then it might potentially be a
5148 DW_FORM_ref_addr, so we conservatively expect inter-CU
5151 if (abbrev_form == DW_FORM_ref_addr
5152 || abbrev_form == DW_FORM_indirect)
5153 cu->has_form_ref_addr = 1;
5155 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5156 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5157 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5158 abbrev_ptr += bytes_read;
5159 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5160 abbrev_ptr += bytes_read;
5163 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5164 (cur_abbrev->num_attrs
5165 * sizeof (struct attr_abbrev)));
5166 memcpy (cur_abbrev->attrs, cur_attrs,
5167 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5169 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5170 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5171 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5173 /* Get next abbreviation.
5174 Under Irix6 the abbreviations for a compilation unit are not
5175 always properly terminated with an abbrev number of 0.
5176 Exit loop if we encounter an abbreviation which we have
5177 already read (which means we are about to read the abbreviations
5178 for the next compile unit) or if the end of the abbreviation
5179 table is reached. */
5180 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5181 >= dwarf2_per_objfile->abbrev_size)
5183 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5184 abbrev_ptr += bytes_read;
5185 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5192 /* Release the memory used by the abbrev table for a compilation unit. */
5195 dwarf2_free_abbrev_table (void *ptr_to_cu)
5197 struct dwarf2_cu *cu = ptr_to_cu;
5199 obstack_free (&cu->abbrev_obstack, NULL);
5200 cu->dwarf2_abbrevs = NULL;
5203 /* Lookup an abbrev_info structure in the abbrev hash table. */
5205 static struct abbrev_info *
5206 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5208 unsigned int hash_number;
5209 struct abbrev_info *abbrev;
5211 hash_number = number % ABBREV_HASH_SIZE;
5212 abbrev = cu->dwarf2_abbrevs[hash_number];
5216 if (abbrev->number == number)
5219 abbrev = abbrev->next;
5224 /* Returns nonzero if TAG represents a type that we might generate a partial
5228 is_type_tag_for_partial (int tag)
5233 /* Some types that would be reasonable to generate partial symbols for,
5234 that we don't at present. */
5235 case DW_TAG_array_type:
5236 case DW_TAG_file_type:
5237 case DW_TAG_ptr_to_member_type:
5238 case DW_TAG_set_type:
5239 case DW_TAG_string_type:
5240 case DW_TAG_subroutine_type:
5242 case DW_TAG_base_type:
5243 case DW_TAG_class_type:
5244 case DW_TAG_enumeration_type:
5245 case DW_TAG_structure_type:
5246 case DW_TAG_subrange_type:
5247 case DW_TAG_typedef:
5248 case DW_TAG_union_type:
5255 /* Load all DIEs that are interesting for partial symbols into memory. */
5257 static struct partial_die_info *
5258 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5259 struct dwarf2_cu *cu)
5261 struct partial_die_info *part_die;
5262 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5263 struct abbrev_info *abbrev;
5264 unsigned int bytes_read;
5265 unsigned int load_all = 0;
5267 int nesting_level = 1;
5272 if (cu->per_cu && cu->per_cu->load_all_dies)
5276 = htab_create_alloc_ex (cu->header.length / 12,
5280 &cu->comp_unit_obstack,
5281 hashtab_obstack_allocate,
5282 dummy_obstack_deallocate);
5284 part_die = obstack_alloc (&cu->comp_unit_obstack,
5285 sizeof (struct partial_die_info));
5289 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5291 /* A NULL abbrev means the end of a series of children. */
5294 if (--nesting_level == 0)
5296 /* PART_DIE was probably the last thing allocated on the
5297 comp_unit_obstack, so we could call obstack_free
5298 here. We don't do that because the waste is small,
5299 and will be cleaned up when we're done with this
5300 compilation unit. This way, we're also more robust
5301 against other users of the comp_unit_obstack. */
5304 info_ptr += bytes_read;
5305 last_die = parent_die;
5306 parent_die = parent_die->die_parent;
5310 /* Check whether this DIE is interesting enough to save. Normally
5311 we would not be interested in members here, but there may be
5312 later variables referencing them via DW_AT_specification (for
5315 && !is_type_tag_for_partial (abbrev->tag)
5316 && abbrev->tag != DW_TAG_enumerator
5317 && abbrev->tag != DW_TAG_subprogram
5318 && abbrev->tag != DW_TAG_variable
5319 && abbrev->tag != DW_TAG_namespace
5320 && abbrev->tag != DW_TAG_member)
5322 /* Otherwise we skip to the next sibling, if any. */
5323 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5327 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5328 abfd, info_ptr, cu);
5330 /* This two-pass algorithm for processing partial symbols has a
5331 high cost in cache pressure. Thus, handle some simple cases
5332 here which cover the majority of C partial symbols. DIEs
5333 which neither have specification tags in them, nor could have
5334 specification tags elsewhere pointing at them, can simply be
5335 processed and discarded.
5337 This segment is also optional; scan_partial_symbols and
5338 add_partial_symbol will handle these DIEs if we chain
5339 them in normally. When compilers which do not emit large
5340 quantities of duplicate debug information are more common,
5341 this code can probably be removed. */
5343 /* Any complete simple types at the top level (pretty much all
5344 of them, for a language without namespaces), can be processed
5346 if (parent_die == NULL
5347 && part_die->has_specification == 0
5348 && part_die->is_declaration == 0
5349 && (part_die->tag == DW_TAG_typedef
5350 || part_die->tag == DW_TAG_base_type
5351 || part_die->tag == DW_TAG_subrange_type))
5353 if (building_psymtab && part_die->name != NULL)
5354 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5355 VAR_DOMAIN, LOC_TYPEDEF,
5356 &cu->objfile->static_psymbols,
5357 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5358 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5362 /* If we're at the second level, and we're an enumerator, and
5363 our parent has no specification (meaning possibly lives in a
5364 namespace elsewhere), then we can add the partial symbol now
5365 instead of queueing it. */
5366 if (part_die->tag == DW_TAG_enumerator
5367 && parent_die != NULL
5368 && parent_die->die_parent == NULL
5369 && parent_die->tag == DW_TAG_enumeration_type
5370 && parent_die->has_specification == 0)
5372 if (part_die->name == NULL)
5373 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5374 else if (building_psymtab)
5375 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5376 VAR_DOMAIN, LOC_CONST,
5377 (cu->language == language_cplus
5378 || cu->language == language_java)
5379 ? &cu->objfile->global_psymbols
5380 : &cu->objfile->static_psymbols,
5381 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5383 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5387 /* We'll save this DIE so link it in. */
5388 part_die->die_parent = parent_die;
5389 part_die->die_sibling = NULL;
5390 part_die->die_child = NULL;
5392 if (last_die && last_die == parent_die)
5393 last_die->die_child = part_die;
5395 last_die->die_sibling = part_die;
5397 last_die = part_die;
5399 if (first_die == NULL)
5400 first_die = part_die;
5402 /* Maybe add the DIE to the hash table. Not all DIEs that we
5403 find interesting need to be in the hash table, because we
5404 also have the parent/sibling/child chains; only those that we
5405 might refer to by offset later during partial symbol reading.
5407 For now this means things that might have be the target of a
5408 DW_AT_specification, DW_AT_abstract_origin, or
5409 DW_AT_extension. DW_AT_extension will refer only to
5410 namespaces; DW_AT_abstract_origin refers to functions (and
5411 many things under the function DIE, but we do not recurse
5412 into function DIEs during partial symbol reading) and
5413 possibly variables as well; DW_AT_specification refers to
5414 declarations. Declarations ought to have the DW_AT_declaration
5415 flag. It happens that GCC forgets to put it in sometimes, but
5416 only for functions, not for types.
5418 Adding more things than necessary to the hash table is harmless
5419 except for the performance cost. Adding too few will result in
5420 wasted time in find_partial_die, when we reread the compilation
5421 unit with load_all_dies set. */
5424 || abbrev->tag == DW_TAG_subprogram
5425 || abbrev->tag == DW_TAG_variable
5426 || abbrev->tag == DW_TAG_namespace
5427 || part_die->is_declaration)
5431 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5432 part_die->offset, INSERT);
5436 part_die = obstack_alloc (&cu->comp_unit_obstack,
5437 sizeof (struct partial_die_info));
5439 /* For some DIEs we want to follow their children (if any). For C
5440 we have no reason to follow the children of structures; for other
5441 languages we have to, both so that we can get at method physnames
5442 to infer fully qualified class names, and for DW_AT_specification. */
5443 if (last_die->has_children
5445 || last_die->tag == DW_TAG_namespace
5446 || last_die->tag == DW_TAG_enumeration_type
5447 || (cu->language != language_c
5448 && (last_die->tag == DW_TAG_class_type
5449 || last_die->tag == DW_TAG_structure_type
5450 || last_die->tag == DW_TAG_union_type))))
5453 parent_die = last_die;
5457 /* Otherwise we skip to the next sibling, if any. */
5458 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5460 /* Back to the top, do it again. */
5464 /* Read a minimal amount of information into the minimal die structure. */
5467 read_partial_die (struct partial_die_info *part_die,
5468 struct abbrev_info *abbrev,
5469 unsigned int abbrev_len, bfd *abfd,
5470 gdb_byte *info_ptr, struct dwarf2_cu *cu)
5472 unsigned int bytes_read, i;
5473 struct attribute attr;
5474 int has_low_pc_attr = 0;
5475 int has_high_pc_attr = 0;
5477 memset (part_die, 0, sizeof (struct partial_die_info));
5479 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5481 info_ptr += abbrev_len;
5486 part_die->tag = abbrev->tag;
5487 part_die->has_children = abbrev->has_children;
5489 for (i = 0; i < abbrev->num_attrs; ++i)
5491 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5493 /* Store the data if it is of an attribute we want to keep in a
5494 partial symbol table. */
5499 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5500 if (part_die->name == NULL)
5501 part_die->name = DW_STRING (&attr);
5503 case DW_AT_comp_dir:
5504 if (part_die->dirname == NULL)
5505 part_die->dirname = DW_STRING (&attr);
5507 case DW_AT_MIPS_linkage_name:
5508 part_die->name = DW_STRING (&attr);
5511 has_low_pc_attr = 1;
5512 part_die->lowpc = DW_ADDR (&attr);
5515 has_high_pc_attr = 1;
5516 part_die->highpc = DW_ADDR (&attr);
5518 case DW_AT_location:
5519 /* Support the .debug_loc offsets */
5520 if (attr_form_is_block (&attr))
5522 part_die->locdesc = DW_BLOCK (&attr);
5524 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5526 dwarf2_complex_location_expr_complaint ();
5530 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5531 "partial symbol information");
5534 case DW_AT_language:
5535 part_die->language = DW_UNSND (&attr);
5537 case DW_AT_external:
5538 part_die->is_external = DW_UNSND (&attr);
5540 case DW_AT_declaration:
5541 part_die->is_declaration = DW_UNSND (&attr);
5544 part_die->has_type = 1;
5546 case DW_AT_abstract_origin:
5547 case DW_AT_specification:
5548 case DW_AT_extension:
5549 part_die->has_specification = 1;
5550 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5553 /* Ignore absolute siblings, they might point outside of
5554 the current compile unit. */
5555 if (attr.form == DW_FORM_ref_addr)
5556 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5558 part_die->sibling = dwarf2_per_objfile->info_buffer
5559 + dwarf2_get_ref_die_offset (&attr, cu);
5561 case DW_AT_stmt_list:
5562 part_die->has_stmt_list = 1;
5563 part_die->line_offset = DW_UNSND (&attr);
5570 /* When using the GNU linker, .gnu.linkonce. sections are used to
5571 eliminate duplicate copies of functions and vtables and such.
5572 The linker will arbitrarily choose one and discard the others.
5573 The AT_*_pc values for such functions refer to local labels in
5574 these sections. If the section from that file was discarded, the
5575 labels are not in the output, so the relocs get a value of 0.
5576 If this is a discarded function, mark the pc bounds as invalid,
5577 so that GDB will ignore it. */
5578 if (has_low_pc_attr && has_high_pc_attr
5579 && part_die->lowpc < part_die->highpc
5580 && (part_die->lowpc != 0
5581 || dwarf2_per_objfile->has_section_at_zero))
5582 part_die->has_pc_info = 1;
5586 /* Find a cached partial DIE at OFFSET in CU. */
5588 static struct partial_die_info *
5589 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5591 struct partial_die_info *lookup_die = NULL;
5592 struct partial_die_info part_die;
5594 part_die.offset = offset;
5595 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5600 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5602 static struct partial_die_info *
5603 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5605 struct dwarf2_per_cu_data *per_cu = NULL;
5606 struct partial_die_info *pd = NULL;
5608 if (offset >= cu->header.offset
5609 && offset < cu->header.offset + cu->header.length)
5611 pd = find_partial_die_in_comp_unit (offset, cu);
5616 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5618 if (per_cu->cu == NULL)
5620 load_comp_unit (per_cu, cu->objfile);
5621 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5622 dwarf2_per_objfile->read_in_chain = per_cu;
5625 per_cu->cu->last_used = 0;
5626 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5628 if (pd == NULL && per_cu->load_all_dies == 0)
5630 struct cleanup *back_to;
5631 struct partial_die_info comp_unit_die;
5632 struct abbrev_info *abbrev;
5633 unsigned int bytes_read;
5636 per_cu->load_all_dies = 1;
5638 /* Re-read the DIEs. */
5639 back_to = make_cleanup (null_cleanup, 0);
5640 if (per_cu->cu->dwarf2_abbrevs == NULL)
5642 dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
5643 back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
5645 info_ptr = per_cu->cu->header.first_die_ptr;
5646 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
5647 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
5648 per_cu->cu->objfile->obfd, info_ptr,
5650 if (comp_unit_die.has_children)
5651 load_partial_dies (per_cu->cu->objfile->obfd, info_ptr, 0, per_cu->cu);
5652 do_cleanups (back_to);
5654 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5658 internal_error (__FILE__, __LINE__,
5659 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5660 offset, bfd_get_filename (cu->objfile->obfd));
5664 /* Adjust PART_DIE before generating a symbol for it. This function
5665 may set the is_external flag or change the DIE's name. */
5668 fixup_partial_die (struct partial_die_info *part_die,
5669 struct dwarf2_cu *cu)
5671 /* If we found a reference attribute and the DIE has no name, try
5672 to find a name in the referred to DIE. */
5674 if (part_die->name == NULL && part_die->has_specification)
5676 struct partial_die_info *spec_die;
5678 spec_die = find_partial_die (part_die->spec_offset, cu);
5680 fixup_partial_die (spec_die, cu);
5684 part_die->name = spec_die->name;
5686 /* Copy DW_AT_external attribute if it is set. */
5687 if (spec_die->is_external)
5688 part_die->is_external = spec_die->is_external;
5692 /* Set default names for some unnamed DIEs. */
5693 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5694 || part_die->tag == DW_TAG_class_type))
5695 part_die->name = "(anonymous class)";
5697 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5698 part_die->name = "(anonymous namespace)";
5700 if (part_die->tag == DW_TAG_structure_type
5701 || part_die->tag == DW_TAG_class_type
5702 || part_die->tag == DW_TAG_union_type)
5703 guess_structure_name (part_die, cu);
5706 /* Read the die from the .debug_info section buffer. Set DIEP to
5707 point to a newly allocated die with its information, except for its
5708 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5709 whether the die has children or not. */
5712 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5713 struct dwarf2_cu *cu, int *has_children)
5715 unsigned int abbrev_number, bytes_read, i, offset;
5716 struct abbrev_info *abbrev;
5717 struct die_info *die;
5719 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5720 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5721 info_ptr += bytes_read;
5724 die = dwarf_alloc_die ();
5726 die->abbrev = abbrev_number;
5733 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5736 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5738 bfd_get_filename (abfd));
5740 die = dwarf_alloc_die ();
5741 die->offset = offset;
5742 die->tag = abbrev->tag;
5743 die->abbrev = abbrev_number;
5746 die->num_attrs = abbrev->num_attrs;
5747 die->attrs = (struct attribute *)
5748 xmalloc (die->num_attrs * sizeof (struct attribute));
5750 for (i = 0; i < abbrev->num_attrs; ++i)
5752 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5753 abfd, info_ptr, cu);
5755 /* If this attribute is an absolute reference to a different
5756 compilation unit, make sure that compilation unit is loaded
5758 if (die->attrs[i].form == DW_FORM_ref_addr
5759 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5760 || (DW_ADDR (&die->attrs[i])
5761 >= cu->header.offset + cu->header.length)))
5763 struct dwarf2_per_cu_data *per_cu;
5764 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5767 /* Mark the dependence relation so that we don't flush PER_CU
5769 dwarf2_add_dependence (cu, per_cu);
5771 /* If it's already on the queue, we have nothing to do. */
5775 /* If the compilation unit is already loaded, just mark it as
5777 if (per_cu->cu != NULL)
5779 per_cu->cu->last_used = 0;
5783 /* Add it to the queue. */
5784 queue_comp_unit (per_cu);
5789 *has_children = abbrev->has_children;
5793 /* Read an attribute value described by an attribute form. */
5796 read_attribute_value (struct attribute *attr, unsigned form,
5797 bfd *abfd, gdb_byte *info_ptr,
5798 struct dwarf2_cu *cu)
5800 struct comp_unit_head *cu_header = &cu->header;
5801 unsigned int bytes_read;
5802 struct dwarf_block *blk;
5808 case DW_FORM_ref_addr:
5809 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5810 info_ptr += bytes_read;
5812 case DW_FORM_block2:
5813 blk = dwarf_alloc_block (cu);
5814 blk->size = read_2_bytes (abfd, info_ptr);
5816 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5817 info_ptr += blk->size;
5818 DW_BLOCK (attr) = blk;
5820 case DW_FORM_block4:
5821 blk = dwarf_alloc_block (cu);
5822 blk->size = read_4_bytes (abfd, info_ptr);
5824 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5825 info_ptr += blk->size;
5826 DW_BLOCK (attr) = blk;
5829 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5833 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5837 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5840 case DW_FORM_string:
5841 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5842 info_ptr += bytes_read;
5845 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5847 info_ptr += bytes_read;
5850 blk = dwarf_alloc_block (cu);
5851 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5852 info_ptr += bytes_read;
5853 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5854 info_ptr += blk->size;
5855 DW_BLOCK (attr) = blk;
5857 case DW_FORM_block1:
5858 blk = dwarf_alloc_block (cu);
5859 blk->size = read_1_byte (abfd, info_ptr);
5861 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5862 info_ptr += blk->size;
5863 DW_BLOCK (attr) = blk;
5866 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5870 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5874 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5875 info_ptr += bytes_read;
5878 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5879 info_ptr += bytes_read;
5882 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5886 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5890 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5894 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5897 case DW_FORM_ref_udata:
5898 DW_ADDR (attr) = (cu->header.offset
5899 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5900 info_ptr += bytes_read;
5902 case DW_FORM_indirect:
5903 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5904 info_ptr += bytes_read;
5905 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5908 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5909 dwarf_form_name (form),
5910 bfd_get_filename (abfd));
5915 /* Read an attribute described by an abbreviated attribute. */
5918 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5919 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
5921 attr->name = abbrev->name;
5922 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5925 /* read dwarf information from a buffer */
5928 read_1_byte (bfd *abfd, gdb_byte *buf)
5930 return bfd_get_8 (abfd, buf);
5934 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
5936 return bfd_get_signed_8 (abfd, buf);
5940 read_2_bytes (bfd *abfd, gdb_byte *buf)
5942 return bfd_get_16 (abfd, buf);
5946 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
5948 return bfd_get_signed_16 (abfd, buf);
5952 read_4_bytes (bfd *abfd, gdb_byte *buf)
5954 return bfd_get_32 (abfd, buf);
5958 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
5960 return bfd_get_signed_32 (abfd, buf);
5963 static unsigned long
5964 read_8_bytes (bfd *abfd, gdb_byte *buf)
5966 return bfd_get_64 (abfd, buf);
5970 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
5971 unsigned int *bytes_read)
5973 struct comp_unit_head *cu_header = &cu->header;
5974 CORE_ADDR retval = 0;
5976 if (cu_header->signed_addr_p)
5978 switch (cu_header->addr_size)
5981 retval = bfd_get_signed_16 (abfd, buf);
5984 retval = bfd_get_signed_32 (abfd, buf);
5987 retval = bfd_get_signed_64 (abfd, buf);
5990 internal_error (__FILE__, __LINE__,
5991 _("read_address: bad switch, signed [in module %s]"),
5992 bfd_get_filename (abfd));
5997 switch (cu_header->addr_size)
6000 retval = bfd_get_16 (abfd, buf);
6003 retval = bfd_get_32 (abfd, buf);
6006 retval = bfd_get_64 (abfd, buf);
6009 internal_error (__FILE__, __LINE__,
6010 _("read_address: bad switch, unsigned [in module %s]"),
6011 bfd_get_filename (abfd));
6015 *bytes_read = cu_header->addr_size;
6019 /* Read the initial length from a section. The (draft) DWARF 3
6020 specification allows the initial length to take up either 4 bytes
6021 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6022 bytes describe the length and all offsets will be 8 bytes in length
6025 An older, non-standard 64-bit format is also handled by this
6026 function. The older format in question stores the initial length
6027 as an 8-byte quantity without an escape value. Lengths greater
6028 than 2^32 aren't very common which means that the initial 4 bytes
6029 is almost always zero. Since a length value of zero doesn't make
6030 sense for the 32-bit format, this initial zero can be considered to
6031 be an escape value which indicates the presence of the older 64-bit
6032 format. As written, the code can't detect (old format) lengths
6033 greater than 4GB. If it becomes necessary to handle lengths
6034 somewhat larger than 4GB, we could allow other small values (such
6035 as the non-sensical values of 1, 2, and 3) to also be used as
6036 escape values indicating the presence of the old format.
6038 The value returned via bytes_read should be used to increment the
6039 relevant pointer after calling read_initial_length().
6041 As a side effect, this function sets the fields initial_length_size
6042 and offset_size in cu_header to the values appropriate for the
6043 length field. (The format of the initial length field determines
6044 the width of file offsets to be fetched later with read_offset().)
6046 [ Note: read_initial_length() and read_offset() are based on the
6047 document entitled "DWARF Debugging Information Format", revision
6048 3, draft 8, dated November 19, 2001. This document was obtained
6051 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6053 This document is only a draft and is subject to change. (So beware.)
6055 Details regarding the older, non-standard 64-bit format were
6056 determined empirically by examining 64-bit ELF files produced by
6057 the SGI toolchain on an IRIX 6.5 machine.
6059 - Kevin, July 16, 2002
6063 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
6064 unsigned int *bytes_read)
6066 LONGEST length = bfd_get_32 (abfd, buf);
6068 if (length == 0xffffffff)
6070 length = bfd_get_64 (abfd, buf + 4);
6073 else if (length == 0)
6075 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6076 length = bfd_get_64 (abfd, buf);
6086 gdb_assert (cu_header->initial_length_size == 0
6087 || cu_header->initial_length_size == 4
6088 || cu_header->initial_length_size == 8
6089 || cu_header->initial_length_size == 12);
6091 if (cu_header->initial_length_size != 0
6092 && cu_header->initial_length_size != *bytes_read)
6093 complaint (&symfile_complaints,
6094 _("intermixed 32-bit and 64-bit DWARF sections"));
6096 cu_header->initial_length_size = *bytes_read;
6097 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
6103 /* Read an offset from the data stream. The size of the offset is
6104 given by cu_header->offset_size. */
6107 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
6108 unsigned int *bytes_read)
6112 switch (cu_header->offset_size)
6115 retval = bfd_get_32 (abfd, buf);
6119 retval = bfd_get_64 (abfd, buf);
6123 internal_error (__FILE__, __LINE__,
6124 _("read_offset: bad switch [in module %s]"),
6125 bfd_get_filename (abfd));
6132 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
6134 /* If the size of a host char is 8 bits, we can return a pointer
6135 to the buffer, otherwise we have to copy the data to a buffer
6136 allocated on the temporary obstack. */
6137 gdb_assert (HOST_CHAR_BIT == 8);
6142 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6144 /* If the size of a host char is 8 bits, we can return a pointer
6145 to the string, otherwise we have to copy the string to a buffer
6146 allocated on the temporary obstack. */
6147 gdb_assert (HOST_CHAR_BIT == 8);
6150 *bytes_read_ptr = 1;
6153 *bytes_read_ptr = strlen ((char *) buf) + 1;
6154 return (char *) buf;
6158 read_indirect_string (bfd *abfd, gdb_byte *buf,
6159 const struct comp_unit_head *cu_header,
6160 unsigned int *bytes_read_ptr)
6162 LONGEST str_offset = read_offset (abfd, buf, cu_header,
6165 if (dwarf2_per_objfile->str_buffer == NULL)
6167 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6168 bfd_get_filename (abfd));
6171 if (str_offset >= dwarf2_per_objfile->str_size)
6173 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6174 bfd_get_filename (abfd));
6177 gdb_assert (HOST_CHAR_BIT == 8);
6178 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6180 return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6183 static unsigned long
6184 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6186 unsigned long result;
6187 unsigned int num_read;
6197 byte = bfd_get_8 (abfd, buf);
6200 result |= ((unsigned long)(byte & 127) << shift);
6201 if ((byte & 128) == 0)
6207 *bytes_read_ptr = num_read;
6212 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6215 int i, shift, num_read;
6224 byte = bfd_get_8 (abfd, buf);
6227 result |= ((long)(byte & 127) << shift);
6229 if ((byte & 128) == 0)
6234 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6235 result |= -(((long)1) << shift);
6236 *bytes_read_ptr = num_read;
6240 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6243 skip_leb128 (bfd *abfd, gdb_byte *buf)
6249 byte = bfd_get_8 (abfd, buf);
6251 if ((byte & 128) == 0)
6257 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6263 cu->language = language_c;
6265 case DW_LANG_C_plus_plus:
6266 cu->language = language_cplus;
6268 case DW_LANG_Fortran77:
6269 case DW_LANG_Fortran90:
6270 case DW_LANG_Fortran95:
6271 cu->language = language_fortran;
6273 case DW_LANG_Mips_Assembler:
6274 cu->language = language_asm;
6277 cu->language = language_java;
6281 cu->language = language_ada;
6283 case DW_LANG_Modula2:
6284 cu->language = language_m2;
6286 case DW_LANG_Cobol74:
6287 case DW_LANG_Cobol85:
6288 case DW_LANG_Pascal83:
6290 cu->language = language_minimal;
6293 cu->language_defn = language_def (cu->language);
6296 /* Return the named attribute or NULL if not there. */
6298 static struct attribute *
6299 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6302 struct attribute *spec = NULL;
6304 for (i = 0; i < die->num_attrs; ++i)
6306 if (die->attrs[i].name == name)
6307 return &die->attrs[i];
6308 if (die->attrs[i].name == DW_AT_specification
6309 || die->attrs[i].name == DW_AT_abstract_origin)
6310 spec = &die->attrs[i];
6314 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6319 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6320 and holds a non-zero value. This function should only be used for
6321 DW_FORM_flag attributes. */
6324 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6326 struct attribute *attr = dwarf2_attr (die, name, cu);
6328 return (attr && DW_UNSND (attr));
6332 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6334 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6335 which value is non-zero. However, we have to be careful with
6336 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6337 (via dwarf2_flag_true_p) follows this attribute. So we may
6338 end up accidently finding a declaration attribute that belongs
6339 to a different DIE referenced by the specification attribute,
6340 even though the given DIE does not have a declaration attribute. */
6341 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6342 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6345 /* Return the die giving the specification for DIE, if there is
6348 static struct die_info *
6349 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6351 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6353 if (spec_attr == NULL)
6356 return follow_die_ref (die, spec_attr, cu);
6359 /* Free the line_header structure *LH, and any arrays and strings it
6362 free_line_header (struct line_header *lh)
6364 if (lh->standard_opcode_lengths)
6365 xfree (lh->standard_opcode_lengths);
6367 /* Remember that all the lh->file_names[i].name pointers are
6368 pointers into debug_line_buffer, and don't need to be freed. */
6370 xfree (lh->file_names);
6372 /* Similarly for the include directory names. */
6373 if (lh->include_dirs)
6374 xfree (lh->include_dirs);
6380 /* Add an entry to LH's include directory table. */
6382 add_include_dir (struct line_header *lh, char *include_dir)
6384 /* Grow the array if necessary. */
6385 if (lh->include_dirs_size == 0)
6387 lh->include_dirs_size = 1; /* for testing */
6388 lh->include_dirs = xmalloc (lh->include_dirs_size
6389 * sizeof (*lh->include_dirs));
6391 else if (lh->num_include_dirs >= lh->include_dirs_size)
6393 lh->include_dirs_size *= 2;
6394 lh->include_dirs = xrealloc (lh->include_dirs,
6395 (lh->include_dirs_size
6396 * sizeof (*lh->include_dirs)));
6399 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6403 /* Add an entry to LH's file name table. */
6405 add_file_name (struct line_header *lh,
6407 unsigned int dir_index,
6408 unsigned int mod_time,
6409 unsigned int length)
6411 struct file_entry *fe;
6413 /* Grow the array if necessary. */
6414 if (lh->file_names_size == 0)
6416 lh->file_names_size = 1; /* for testing */
6417 lh->file_names = xmalloc (lh->file_names_size
6418 * sizeof (*lh->file_names));
6420 else if (lh->num_file_names >= lh->file_names_size)
6422 lh->file_names_size *= 2;
6423 lh->file_names = xrealloc (lh->file_names,
6424 (lh->file_names_size
6425 * sizeof (*lh->file_names)));
6428 fe = &lh->file_names[lh->num_file_names++];
6430 fe->dir_index = dir_index;
6431 fe->mod_time = mod_time;
6432 fe->length = length;
6437 /* Read the statement program header starting at OFFSET in
6438 .debug_line, according to the endianness of ABFD. Return a pointer
6439 to a struct line_header, allocated using xmalloc.
6441 NOTE: the strings in the include directory and file name tables of
6442 the returned object point into debug_line_buffer, and must not be
6444 static struct line_header *
6445 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6446 struct dwarf2_cu *cu)
6448 struct cleanup *back_to;
6449 struct line_header *lh;
6451 unsigned int bytes_read;
6453 char *cur_dir, *cur_file;
6455 if (dwarf2_per_objfile->line_buffer == NULL)
6457 complaint (&symfile_complaints, _("missing .debug_line section"));
6461 /* Make sure that at least there's room for the total_length field.
6462 That could be 12 bytes long, but we're just going to fudge that. */
6463 if (offset + 4 >= dwarf2_per_objfile->line_size)
6465 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6469 lh = xmalloc (sizeof (*lh));
6470 memset (lh, 0, sizeof (*lh));
6471 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6474 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6476 /* Read in the header. */
6478 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6479 line_ptr += bytes_read;
6480 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6481 + dwarf2_per_objfile->line_size))
6483 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6486 lh->statement_program_end = line_ptr + lh->total_length;
6487 lh->version = read_2_bytes (abfd, line_ptr);
6489 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6490 line_ptr += bytes_read;
6491 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6493 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6495 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6497 lh->line_range = read_1_byte (abfd, line_ptr);
6499 lh->opcode_base = read_1_byte (abfd, line_ptr);
6501 lh->standard_opcode_lengths
6502 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6504 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6505 for (i = 1; i < lh->opcode_base; ++i)
6507 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6511 /* Read directory table. */
6512 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6514 line_ptr += bytes_read;
6515 add_include_dir (lh, cur_dir);
6517 line_ptr += bytes_read;
6519 /* Read file name table. */
6520 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6522 unsigned int dir_index, mod_time, length;
6524 line_ptr += bytes_read;
6525 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6526 line_ptr += bytes_read;
6527 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6528 line_ptr += bytes_read;
6529 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6530 line_ptr += bytes_read;
6532 add_file_name (lh, cur_file, dir_index, mod_time, length);
6534 line_ptr += bytes_read;
6535 lh->statement_program_start = line_ptr;
6537 if (line_ptr > (dwarf2_per_objfile->line_buffer
6538 + dwarf2_per_objfile->line_size))
6539 complaint (&symfile_complaints,
6540 _("line number info header doesn't fit in `.debug_line' section"));
6542 discard_cleanups (back_to);
6546 /* This function exists to work around a bug in certain compilers
6547 (particularly GCC 2.95), in which the first line number marker of a
6548 function does not show up until after the prologue, right before
6549 the second line number marker. This function shifts ADDRESS down
6550 to the beginning of the function if necessary, and is called on
6551 addresses passed to record_line. */
6554 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6556 struct function_range *fn;
6558 /* Find the function_range containing address. */
6563 cu->cached_fn = cu->first_fn;
6567 if (fn->lowpc <= address && fn->highpc > address)
6573 while (fn && fn != cu->cached_fn)
6574 if (fn->lowpc <= address && fn->highpc > address)
6584 if (address != fn->lowpc)
6585 complaint (&symfile_complaints,
6586 _("misplaced first line number at 0x%lx for '%s'"),
6587 (unsigned long) address, fn->name);
6592 /* Decode the Line Number Program (LNP) for the given line_header
6593 structure and CU. The actual information extracted and the type
6594 of structures created from the LNP depends on the value of PST.
6596 1. If PST is NULL, then this procedure uses the data from the program
6597 to create all necessary symbol tables, and their linetables.
6598 The compilation directory of the file is passed in COMP_DIR,
6599 and must not be NULL.
6601 2. If PST is not NULL, this procedure reads the program to determine
6602 the list of files included by the unit represented by PST, and
6603 builds all the associated partial symbol tables. In this case,
6604 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6605 is not used to compute the full name of the symtab, and therefore
6606 omitting it when building the partial symtab does not introduce
6607 the potential for inconsistency - a partial symtab and its associated
6608 symbtab having a different fullname -). */
6611 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6612 struct dwarf2_cu *cu, struct partial_symtab *pst)
6616 unsigned int bytes_read;
6617 unsigned char op_code, extended_op, adj_opcode;
6619 struct objfile *objfile = cu->objfile;
6620 const int decode_for_pst_p = (pst != NULL);
6622 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6624 line_ptr = lh->statement_program_start;
6625 line_end = lh->statement_program_end;
6627 /* Read the statement sequences until there's nothing left. */
6628 while (line_ptr < line_end)
6630 /* state machine registers */
6631 CORE_ADDR address = 0;
6632 unsigned int file = 1;
6633 unsigned int line = 1;
6634 unsigned int column = 0;
6635 int is_stmt = lh->default_is_stmt;
6636 int basic_block = 0;
6637 int end_sequence = 0;
6639 if (!decode_for_pst_p && lh->num_file_names >= file)
6641 /* Start a subfile for the current file of the state machine. */
6642 /* lh->include_dirs and lh->file_names are 0-based, but the
6643 directory and file name numbers in the statement program
6645 struct file_entry *fe = &lh->file_names[file - 1];
6649 dir = lh->include_dirs[fe->dir_index - 1];
6651 dwarf2_start_subfile (fe->name, dir, comp_dir);
6654 /* Decode the table. */
6655 while (!end_sequence)
6657 op_code = read_1_byte (abfd, line_ptr);
6660 if (op_code >= lh->opcode_base)
6662 /* Special operand. */
6663 adj_opcode = op_code - lh->opcode_base;
6664 address += (adj_opcode / lh->line_range)
6665 * lh->minimum_instruction_length;
6666 line += lh->line_base + (adj_opcode % lh->line_range);
6667 lh->file_names[file - 1].included_p = 1;
6668 if (!decode_for_pst_p)
6670 /* Append row to matrix using current values. */
6671 record_line (current_subfile, line,
6672 check_cu_functions (address, cu));
6676 else switch (op_code)
6678 case DW_LNS_extended_op:
6679 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6680 line_ptr += bytes_read;
6681 extended_op = read_1_byte (abfd, line_ptr);
6683 switch (extended_op)
6685 case DW_LNE_end_sequence:
6687 lh->file_names[file - 1].included_p = 1;
6688 if (!decode_for_pst_p)
6689 record_line (current_subfile, 0, address);
6691 case DW_LNE_set_address:
6692 address = read_address (abfd, line_ptr, cu, &bytes_read);
6693 line_ptr += bytes_read;
6694 address += baseaddr;
6696 case DW_LNE_define_file:
6699 unsigned int dir_index, mod_time, length;
6701 cur_file = read_string (abfd, line_ptr, &bytes_read);
6702 line_ptr += bytes_read;
6704 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6705 line_ptr += bytes_read;
6707 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6708 line_ptr += bytes_read;
6710 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6711 line_ptr += bytes_read;
6712 add_file_name (lh, cur_file, dir_index, mod_time, length);
6716 complaint (&symfile_complaints,
6717 _("mangled .debug_line section"));
6722 lh->file_names[file - 1].included_p = 1;
6723 if (!decode_for_pst_p)
6724 record_line (current_subfile, line,
6725 check_cu_functions (address, cu));
6728 case DW_LNS_advance_pc:
6729 address += lh->minimum_instruction_length
6730 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6731 line_ptr += bytes_read;
6733 case DW_LNS_advance_line:
6734 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6735 line_ptr += bytes_read;
6737 case DW_LNS_set_file:
6739 /* The arrays lh->include_dirs and lh->file_names are
6740 0-based, but the directory and file name numbers in
6741 the statement program are 1-based. */
6742 struct file_entry *fe;
6745 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6746 line_ptr += bytes_read;
6747 fe = &lh->file_names[file - 1];
6749 dir = lh->include_dirs[fe->dir_index - 1];
6751 if (!decode_for_pst_p)
6752 dwarf2_start_subfile (fe->name, dir, comp_dir);
6755 case DW_LNS_set_column:
6756 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6757 line_ptr += bytes_read;
6759 case DW_LNS_negate_stmt:
6760 is_stmt = (!is_stmt);
6762 case DW_LNS_set_basic_block:
6765 /* Add to the address register of the state machine the
6766 address increment value corresponding to special opcode
6767 255. I.e., this value is scaled by the minimum
6768 instruction length since special opcode 255 would have
6769 scaled the the increment. */
6770 case DW_LNS_const_add_pc:
6771 address += (lh->minimum_instruction_length
6772 * ((255 - lh->opcode_base) / lh->line_range));
6774 case DW_LNS_fixed_advance_pc:
6775 address += read_2_bytes (abfd, line_ptr);
6780 /* Unknown standard opcode, ignore it. */
6783 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6785 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6786 line_ptr += bytes_read;
6793 if (decode_for_pst_p)
6797 /* Now that we're done scanning the Line Header Program, we can
6798 create the psymtab of each included file. */
6799 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6800 if (lh->file_names[file_index].included_p == 1)
6802 const struct file_entry fe = lh->file_names [file_index];
6803 char *include_name = fe.name;
6804 char *dir_name = NULL;
6805 char *pst_filename = pst->filename;
6808 dir_name = lh->include_dirs[fe.dir_index - 1];
6810 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6812 include_name = concat (dir_name, SLASH_STRING,
6813 include_name, (char *)NULL);
6814 make_cleanup (xfree, include_name);
6817 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6819 pst_filename = concat (pst->dirname, SLASH_STRING,
6820 pst_filename, (char *)NULL);
6821 make_cleanup (xfree, pst_filename);
6824 if (strcmp (include_name, pst_filename) != 0)
6825 dwarf2_create_include_psymtab (include_name, pst, objfile);
6830 /* Start a subfile for DWARF. FILENAME is the name of the file and
6831 DIRNAME the name of the source directory which contains FILENAME
6832 or NULL if not known. COMP_DIR is the compilation directory for the
6833 linetable's compilation unit or NULL if not known.
6834 This routine tries to keep line numbers from identical absolute and
6835 relative file names in a common subfile.
6837 Using the `list' example from the GDB testsuite, which resides in
6838 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6839 of /srcdir/list0.c yields the following debugging information for list0.c:
6841 DW_AT_name: /srcdir/list0.c
6842 DW_AT_comp_dir: /compdir
6843 files.files[0].name: list0.h
6844 files.files[0].dir: /srcdir
6845 files.files[1].name: list0.c
6846 files.files[1].dir: /srcdir
6848 The line number information for list0.c has to end up in a single
6849 subfile, so that `break /srcdir/list0.c:1' works as expected.
6850 start_subfile will ensure that this happens provided that we pass the
6851 concatenation of files.files[1].dir and files.files[1].name as the
6855 dwarf2_start_subfile (char *filename, char *dirname, char *comp_dir)
6859 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6860 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6861 second argument to start_subfile. To be consistent, we do the
6862 same here. In order not to lose the line information directory,
6863 we concatenate it to the filename when it makes sense.
6864 Note that the Dwarf3 standard says (speaking of filenames in line
6865 information): ``The directory index is ignored for file names
6866 that represent full path names''. Thus ignoring dirname in the
6867 `else' branch below isn't an issue. */
6869 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6870 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
6872 fullname = filename;
6874 start_subfile (fullname, comp_dir);
6876 if (fullname != filename)
6881 var_decode_location (struct attribute *attr, struct symbol *sym,
6882 struct dwarf2_cu *cu)
6884 struct objfile *objfile = cu->objfile;
6885 struct comp_unit_head *cu_header = &cu->header;
6887 /* NOTE drow/2003-01-30: There used to be a comment and some special
6888 code here to turn a symbol with DW_AT_external and a
6889 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6890 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6891 with some versions of binutils) where shared libraries could have
6892 relocations against symbols in their debug information - the
6893 minimal symbol would have the right address, but the debug info
6894 would not. It's no longer necessary, because we will explicitly
6895 apply relocations when we read in the debug information now. */
6897 /* A DW_AT_location attribute with no contents indicates that a
6898 variable has been optimized away. */
6899 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6901 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6905 /* Handle one degenerate form of location expression specially, to
6906 preserve GDB's previous behavior when section offsets are
6907 specified. If this is just a DW_OP_addr then mark this symbol
6910 if (attr_form_is_block (attr)
6911 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6912 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6916 SYMBOL_VALUE_ADDRESS (sym) =
6917 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6918 fixup_symbol_section (sym, objfile);
6919 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6920 SYMBOL_SECTION (sym));
6921 SYMBOL_CLASS (sym) = LOC_STATIC;
6925 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6926 expression evaluator, and use LOC_COMPUTED only when necessary
6927 (i.e. when the value of a register or memory location is
6928 referenced, or a thread-local block, etc.). Then again, it might
6929 not be worthwhile. I'm assuming that it isn't unless performance
6930 or memory numbers show me otherwise. */
6932 dwarf2_symbol_mark_computed (attr, sym, cu);
6933 SYMBOL_CLASS (sym) = LOC_COMPUTED;
6936 /* Given a pointer to a DWARF information entry, figure out if we need
6937 to make a symbol table entry for it, and if so, create a new entry
6938 and return a pointer to it.
6939 If TYPE is NULL, determine symbol type from the die, otherwise
6940 used the passed type. */
6942 static struct symbol *
6943 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6945 struct objfile *objfile = cu->objfile;
6946 struct symbol *sym = NULL;
6948 struct attribute *attr = NULL;
6949 struct attribute *attr2 = NULL;
6952 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6954 if (die->tag != DW_TAG_namespace)
6955 name = dwarf2_linkage_name (die, cu);
6957 name = TYPE_NAME (type);
6961 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6962 sizeof (struct symbol));
6963 OBJSTAT (objfile, n_syms++);
6964 memset (sym, 0, sizeof (struct symbol));
6966 /* Cache this symbol's name and the name's demangled form (if any). */
6967 SYMBOL_LANGUAGE (sym) = cu->language;
6968 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
6970 /* Default assumptions.
6971 Use the passed type or decode it from the die. */
6972 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6973 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6975 SYMBOL_TYPE (sym) = type;
6977 SYMBOL_TYPE (sym) = die_type (die, cu);
6978 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
6981 SYMBOL_LINE (sym) = DW_UNSND (attr);
6986 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6989 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
6991 SYMBOL_CLASS (sym) = LOC_LABEL;
6993 case DW_TAG_subprogram:
6994 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6996 SYMBOL_CLASS (sym) = LOC_BLOCK;
6997 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6998 if (attr2 && (DW_UNSND (attr2) != 0))
7000 add_symbol_to_list (sym, &global_symbols);
7004 add_symbol_to_list (sym, cu->list_in_scope);
7007 case DW_TAG_variable:
7008 /* Compilation with minimal debug info may result in variables
7009 with missing type entries. Change the misleading `void' type
7010 to something sensible. */
7011 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
7012 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
7013 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
7014 "<variable, no debug info>",
7016 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7019 dwarf2_const_value (attr, sym, cu);
7020 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7021 if (attr2 && (DW_UNSND (attr2) != 0))
7022 add_symbol_to_list (sym, &global_symbols);
7024 add_symbol_to_list (sym, cu->list_in_scope);
7027 attr = dwarf2_attr (die, DW_AT_location, cu);
7030 var_decode_location (attr, sym, cu);
7031 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7032 if (attr2 && (DW_UNSND (attr2) != 0))
7033 add_symbol_to_list (sym, &global_symbols);
7035 add_symbol_to_list (sym, cu->list_in_scope);
7039 /* We do not know the address of this symbol.
7040 If it is an external symbol and we have type information
7041 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7042 The address of the variable will then be determined from
7043 the minimal symbol table whenever the variable is
7045 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7046 if (attr2 && (DW_UNSND (attr2) != 0)
7047 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
7049 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
7050 add_symbol_to_list (sym, &global_symbols);
7054 case DW_TAG_formal_parameter:
7055 attr = dwarf2_attr (die, DW_AT_location, cu);
7058 var_decode_location (attr, sym, cu);
7059 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7060 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
7061 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
7063 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7066 dwarf2_const_value (attr, sym, cu);
7068 add_symbol_to_list (sym, cu->list_in_scope);
7070 case DW_TAG_unspecified_parameters:
7071 /* From varargs functions; gdb doesn't seem to have any
7072 interest in this information, so just ignore it for now.
7075 case DW_TAG_class_type:
7076 case DW_TAG_structure_type:
7077 case DW_TAG_union_type:
7078 case DW_TAG_set_type:
7079 case DW_TAG_enumeration_type:
7080 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7081 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7083 /* Make sure that the symbol includes appropriate enclosing
7084 classes/namespaces in its name. These are calculated in
7085 read_structure_type, and the correct name is saved in
7088 if (cu->language == language_cplus
7089 || cu->language == language_java)
7091 struct type *type = SYMBOL_TYPE (sym);
7093 if (TYPE_TAG_NAME (type) != NULL)
7095 /* FIXME: carlton/2003-11-10: Should this use
7096 SYMBOL_SET_NAMES instead? (The same problem also
7097 arises further down in this function.) */
7098 /* The type's name is already allocated along with
7099 this objfile, so we don't need to duplicate it
7101 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
7106 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7107 really ever be static objects: otherwise, if you try
7108 to, say, break of a class's method and you're in a file
7109 which doesn't mention that class, it won't work unless
7110 the check for all static symbols in lookup_symbol_aux
7111 saves you. See the OtherFileClass tests in
7112 gdb.c++/namespace.exp. */
7114 struct pending **list_to_add;
7116 list_to_add = (cu->list_in_scope == &file_symbols
7117 && (cu->language == language_cplus
7118 || cu->language == language_java)
7119 ? &global_symbols : cu->list_in_scope);
7121 add_symbol_to_list (sym, list_to_add);
7123 /* The semantics of C++ state that "struct foo { ... }" also
7124 defines a typedef for "foo". A Java class declaration also
7125 defines a typedef for the class. Synthesize a typedef symbol
7126 so that "ptype foo" works as expected. */
7127 if (cu->language == language_cplus
7128 || cu->language == language_java)
7130 struct symbol *typedef_sym = (struct symbol *)
7131 obstack_alloc (&objfile->objfile_obstack,
7132 sizeof (struct symbol));
7133 *typedef_sym = *sym;
7134 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
7135 /* The symbol's name is already allocated along with
7136 this objfile, so we don't need to duplicate it for
7138 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
7139 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
7140 add_symbol_to_list (typedef_sym, list_to_add);
7144 case DW_TAG_typedef:
7145 if (processing_has_namespace_info
7146 && processing_current_prefix[0] != '\0')
7148 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7149 processing_current_prefix,
7152 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7153 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7154 add_symbol_to_list (sym, cu->list_in_scope);
7156 case DW_TAG_base_type:
7157 case DW_TAG_subrange_type:
7158 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7159 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7160 add_symbol_to_list (sym, cu->list_in_scope);
7162 case DW_TAG_enumerator:
7163 if (processing_has_namespace_info
7164 && processing_current_prefix[0] != '\0')
7166 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7167 processing_current_prefix,
7170 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7173 dwarf2_const_value (attr, sym, cu);
7176 /* NOTE: carlton/2003-11-10: See comment above in the
7177 DW_TAG_class_type, etc. block. */
7179 struct pending **list_to_add;
7181 list_to_add = (cu->list_in_scope == &file_symbols
7182 && (cu->language == language_cplus
7183 || cu->language == language_java)
7184 ? &global_symbols : cu->list_in_scope);
7186 add_symbol_to_list (sym, list_to_add);
7189 case DW_TAG_namespace:
7190 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7191 add_symbol_to_list (sym, &global_symbols);
7194 /* Not a tag we recognize. Hopefully we aren't processing
7195 trash data, but since we must specifically ignore things
7196 we don't recognize, there is nothing else we should do at
7198 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7199 dwarf_tag_name (die->tag));
7206 /* Copy constant value from an attribute to a symbol. */
7209 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7210 struct dwarf2_cu *cu)
7212 struct objfile *objfile = cu->objfile;
7213 struct comp_unit_head *cu_header = &cu->header;
7214 struct dwarf_block *blk;
7219 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7220 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7221 cu_header->addr_size,
7222 TYPE_LENGTH (SYMBOL_TYPE
7224 SYMBOL_VALUE_BYTES (sym) =
7225 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7226 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7227 it's body - store_unsigned_integer. */
7228 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7230 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7232 case DW_FORM_block1:
7233 case DW_FORM_block2:
7234 case DW_FORM_block4:
7236 blk = DW_BLOCK (attr);
7237 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7238 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7240 TYPE_LENGTH (SYMBOL_TYPE
7242 SYMBOL_VALUE_BYTES (sym) =
7243 obstack_alloc (&objfile->objfile_obstack, blk->size);
7244 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7245 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7248 /* The DW_AT_const_value attributes are supposed to carry the
7249 symbol's value "represented as it would be on the target
7250 architecture." By the time we get here, it's already been
7251 converted to host endianness, so we just need to sign- or
7252 zero-extend it as appropriate. */
7254 dwarf2_const_value_data (attr, sym, 8);
7257 dwarf2_const_value_data (attr, sym, 16);
7260 dwarf2_const_value_data (attr, sym, 32);
7263 dwarf2_const_value_data (attr, sym, 64);
7267 SYMBOL_VALUE (sym) = DW_SND (attr);
7268 SYMBOL_CLASS (sym) = LOC_CONST;
7272 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7273 SYMBOL_CLASS (sym) = LOC_CONST;
7277 complaint (&symfile_complaints,
7278 _("unsupported const value attribute form: '%s'"),
7279 dwarf_form_name (attr->form));
7280 SYMBOL_VALUE (sym) = 0;
7281 SYMBOL_CLASS (sym) = LOC_CONST;
7287 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7288 or zero-extend it as appropriate for the symbol's type. */
7290 dwarf2_const_value_data (struct attribute *attr,
7294 LONGEST l = DW_UNSND (attr);
7296 if (bits < sizeof (l) * 8)
7298 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7299 l &= ((LONGEST) 1 << bits) - 1;
7301 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7304 SYMBOL_VALUE (sym) = l;
7305 SYMBOL_CLASS (sym) = LOC_CONST;
7309 /* Return the type of the die in question using its DW_AT_type attribute. */
7311 static struct type *
7312 die_type (struct die_info *die, struct dwarf2_cu *cu)
7315 struct attribute *type_attr;
7316 struct die_info *type_die;
7318 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7321 /* A missing DW_AT_type represents a void type. */
7322 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7325 type_die = follow_die_ref (die, type_attr, cu);
7327 type = tag_type_to_type (type_die, cu);
7330 dump_die (type_die);
7331 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7337 /* Return the containing type of the die in question using its
7338 DW_AT_containing_type attribute. */
7340 static struct type *
7341 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7343 struct type *type = NULL;
7344 struct attribute *type_attr;
7345 struct die_info *type_die = NULL;
7347 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7350 type_die = follow_die_ref (die, type_attr, cu);
7351 type = tag_type_to_type (type_die, cu);
7356 dump_die (type_die);
7357 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7363 static struct type *
7364 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7372 read_type_die (die, cu);
7376 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7384 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7386 char *prefix = determine_prefix (die, cu);
7387 const char *old_prefix = processing_current_prefix;
7388 struct cleanup *back_to = make_cleanup (xfree, prefix);
7389 processing_current_prefix = prefix;
7393 case DW_TAG_class_type:
7394 case DW_TAG_structure_type:
7395 case DW_TAG_union_type:
7396 read_structure_type (die, cu);
7398 case DW_TAG_enumeration_type:
7399 read_enumeration_type (die, cu);
7401 case DW_TAG_subprogram:
7402 case DW_TAG_subroutine_type:
7403 read_subroutine_type (die, cu);
7405 case DW_TAG_array_type:
7406 read_array_type (die, cu);
7408 case DW_TAG_set_type:
7409 read_set_type (die, cu);
7411 case DW_TAG_pointer_type:
7412 read_tag_pointer_type (die, cu);
7414 case DW_TAG_ptr_to_member_type:
7415 read_tag_ptr_to_member_type (die, cu);
7417 case DW_TAG_reference_type:
7418 read_tag_reference_type (die, cu);
7420 case DW_TAG_const_type:
7421 read_tag_const_type (die, cu);
7423 case DW_TAG_volatile_type:
7424 read_tag_volatile_type (die, cu);
7426 case DW_TAG_string_type:
7427 read_tag_string_type (die, cu);
7429 case DW_TAG_typedef:
7430 read_typedef (die, cu);
7432 case DW_TAG_subrange_type:
7433 read_subrange_type (die, cu);
7435 case DW_TAG_base_type:
7436 read_base_type (die, cu);
7438 case DW_TAG_unspecified_type:
7439 read_unspecified_type (die, cu);
7442 complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
7443 dwarf_tag_name (die->tag));
7447 processing_current_prefix = old_prefix;
7448 do_cleanups (back_to);
7451 /* Return the name of the namespace/class that DIE is defined within,
7452 or "" if we can't tell. The caller should xfree the result. */
7454 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7455 therein) for an example of how to use this function to deal with
7456 DW_AT_specification. */
7459 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7461 struct die_info *parent;
7463 if (cu->language != language_cplus
7464 && cu->language != language_java)
7467 parent = die->parent;
7471 return xstrdup ("");
7475 switch (parent->tag) {
7476 case DW_TAG_namespace:
7478 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7479 before doing this check? */
7480 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7482 return xstrdup (TYPE_TAG_NAME (parent->type));
7487 char *parent_prefix = determine_prefix (parent, cu);
7488 char *retval = typename_concat (NULL, parent_prefix,
7489 namespace_name (parent, &dummy,
7492 xfree (parent_prefix);
7497 case DW_TAG_class_type:
7498 case DW_TAG_structure_type:
7500 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7502 return xstrdup (TYPE_TAG_NAME (parent->type));
7506 const char *old_prefix = processing_current_prefix;
7507 char *new_prefix = determine_prefix (parent, cu);
7510 processing_current_prefix = new_prefix;
7511 retval = determine_class_name (parent, cu);
7512 processing_current_prefix = old_prefix;
7519 return determine_prefix (parent, cu);
7524 /* Return a newly-allocated string formed by concatenating PREFIX and
7525 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7526 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7527 perform an obconcat, otherwise allocate storage for the result. The CU argument
7528 is used to determine the language and hence, the appropriate separator. */
7530 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7533 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7534 struct dwarf2_cu *cu)
7538 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7540 else if (cu->language == language_java)
7547 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7552 strcpy (retval, prefix);
7553 strcat (retval, sep);
7556 strcat (retval, suffix);
7562 /* We have an obstack. */
7563 return obconcat (obs, prefix, sep, suffix);
7567 static struct type *
7568 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7570 struct objfile *objfile = cu->objfile;
7572 /* FIXME - this should not produce a new (struct type *)
7573 every time. It should cache base types. */
7577 case DW_ATE_address:
7578 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7580 case DW_ATE_boolean:
7581 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7583 case DW_ATE_complex_float:
7586 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7590 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7596 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7600 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7607 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7610 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7614 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7618 case DW_ATE_signed_char:
7619 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7621 case DW_ATE_unsigned:
7625 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7628 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7632 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7636 case DW_ATE_unsigned_char:
7637 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7640 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7647 copy_die (struct die_info *old_die)
7649 struct die_info *new_die;
7652 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7653 memset (new_die, 0, sizeof (struct die_info));
7655 new_die->tag = old_die->tag;
7656 new_die->has_children = old_die->has_children;
7657 new_die->abbrev = old_die->abbrev;
7658 new_die->offset = old_die->offset;
7659 new_die->type = NULL;
7661 num_attrs = old_die->num_attrs;
7662 new_die->num_attrs = num_attrs;
7663 new_die->attrs = (struct attribute *)
7664 xmalloc (num_attrs * sizeof (struct attribute));
7666 for (i = 0; i < old_die->num_attrs; ++i)
7668 new_die->attrs[i].name = old_die->attrs[i].name;
7669 new_die->attrs[i].form = old_die->attrs[i].form;
7670 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7673 new_die->next = NULL;
7678 /* Return sibling of die, NULL if no sibling. */
7680 static struct die_info *
7681 sibling_die (struct die_info *die)
7683 return die->sibling;
7686 /* Get linkage name of a die, return NULL if not found. */
7689 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7691 struct attribute *attr;
7693 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7694 if (attr && DW_STRING (attr))
7695 return DW_STRING (attr);
7696 attr = dwarf2_attr (die, DW_AT_name, cu);
7697 if (attr && DW_STRING (attr))
7698 return DW_STRING (attr);
7702 /* Get name of a die, return NULL if not found. */
7705 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7707 struct attribute *attr;
7709 attr = dwarf2_attr (die, DW_AT_name, cu);
7710 if (attr && DW_STRING (attr))
7711 return DW_STRING (attr);
7715 /* Return the die that this die in an extension of, or NULL if there
7718 static struct die_info *
7719 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7721 struct attribute *attr;
7723 attr = dwarf2_attr (die, DW_AT_extension, cu);
7727 return follow_die_ref (die, attr, cu);
7730 /* Convert a DIE tag into its string name. */
7733 dwarf_tag_name (unsigned tag)
7737 case DW_TAG_padding:
7738 return "DW_TAG_padding";
7739 case DW_TAG_array_type:
7740 return "DW_TAG_array_type";
7741 case DW_TAG_class_type:
7742 return "DW_TAG_class_type";
7743 case DW_TAG_entry_point:
7744 return "DW_TAG_entry_point";
7745 case DW_TAG_enumeration_type:
7746 return "DW_TAG_enumeration_type";
7747 case DW_TAG_formal_parameter:
7748 return "DW_TAG_formal_parameter";
7749 case DW_TAG_imported_declaration:
7750 return "DW_TAG_imported_declaration";
7752 return "DW_TAG_label";
7753 case DW_TAG_lexical_block:
7754 return "DW_TAG_lexical_block";
7756 return "DW_TAG_member";
7757 case DW_TAG_pointer_type:
7758 return "DW_TAG_pointer_type";
7759 case DW_TAG_reference_type:
7760 return "DW_TAG_reference_type";
7761 case DW_TAG_compile_unit:
7762 return "DW_TAG_compile_unit";
7763 case DW_TAG_string_type:
7764 return "DW_TAG_string_type";
7765 case DW_TAG_structure_type:
7766 return "DW_TAG_structure_type";
7767 case DW_TAG_subroutine_type:
7768 return "DW_TAG_subroutine_type";
7769 case DW_TAG_typedef:
7770 return "DW_TAG_typedef";
7771 case DW_TAG_union_type:
7772 return "DW_TAG_union_type";
7773 case DW_TAG_unspecified_parameters:
7774 return "DW_TAG_unspecified_parameters";
7775 case DW_TAG_variant:
7776 return "DW_TAG_variant";
7777 case DW_TAG_common_block:
7778 return "DW_TAG_common_block";
7779 case DW_TAG_common_inclusion:
7780 return "DW_TAG_common_inclusion";
7781 case DW_TAG_inheritance:
7782 return "DW_TAG_inheritance";
7783 case DW_TAG_inlined_subroutine:
7784 return "DW_TAG_inlined_subroutine";
7786 return "DW_TAG_module";
7787 case DW_TAG_ptr_to_member_type:
7788 return "DW_TAG_ptr_to_member_type";
7789 case DW_TAG_set_type:
7790 return "DW_TAG_set_type";
7791 case DW_TAG_subrange_type:
7792 return "DW_TAG_subrange_type";
7793 case DW_TAG_with_stmt:
7794 return "DW_TAG_with_stmt";
7795 case DW_TAG_access_declaration:
7796 return "DW_TAG_access_declaration";
7797 case DW_TAG_base_type:
7798 return "DW_TAG_base_type";
7799 case DW_TAG_catch_block:
7800 return "DW_TAG_catch_block";
7801 case DW_TAG_const_type:
7802 return "DW_TAG_const_type";
7803 case DW_TAG_constant:
7804 return "DW_TAG_constant";
7805 case DW_TAG_enumerator:
7806 return "DW_TAG_enumerator";
7807 case DW_TAG_file_type:
7808 return "DW_TAG_file_type";
7810 return "DW_TAG_friend";
7811 case DW_TAG_namelist:
7812 return "DW_TAG_namelist";
7813 case DW_TAG_namelist_item:
7814 return "DW_TAG_namelist_item";
7815 case DW_TAG_packed_type:
7816 return "DW_TAG_packed_type";
7817 case DW_TAG_subprogram:
7818 return "DW_TAG_subprogram";
7819 case DW_TAG_template_type_param:
7820 return "DW_TAG_template_type_param";
7821 case DW_TAG_template_value_param:
7822 return "DW_TAG_template_value_param";
7823 case DW_TAG_thrown_type:
7824 return "DW_TAG_thrown_type";
7825 case DW_TAG_try_block:
7826 return "DW_TAG_try_block";
7827 case DW_TAG_variant_part:
7828 return "DW_TAG_variant_part";
7829 case DW_TAG_variable:
7830 return "DW_TAG_variable";
7831 case DW_TAG_volatile_type:
7832 return "DW_TAG_volatile_type";
7833 case DW_TAG_dwarf_procedure:
7834 return "DW_TAG_dwarf_procedure";
7835 case DW_TAG_restrict_type:
7836 return "DW_TAG_restrict_type";
7837 case DW_TAG_interface_type:
7838 return "DW_TAG_interface_type";
7839 case DW_TAG_namespace:
7840 return "DW_TAG_namespace";
7841 case DW_TAG_imported_module:
7842 return "DW_TAG_imported_module";
7843 case DW_TAG_unspecified_type:
7844 return "DW_TAG_unspecified_type";
7845 case DW_TAG_partial_unit:
7846 return "DW_TAG_partial_unit";
7847 case DW_TAG_imported_unit:
7848 return "DW_TAG_imported_unit";
7849 case DW_TAG_MIPS_loop:
7850 return "DW_TAG_MIPS_loop";
7851 case DW_TAG_format_label:
7852 return "DW_TAG_format_label";
7853 case DW_TAG_function_template:
7854 return "DW_TAG_function_template";
7855 case DW_TAG_class_template:
7856 return "DW_TAG_class_template";
7858 return "DW_TAG_<unknown>";
7862 /* Convert a DWARF attribute code into its string name. */
7865 dwarf_attr_name (unsigned attr)
7870 return "DW_AT_sibling";
7871 case DW_AT_location:
7872 return "DW_AT_location";
7874 return "DW_AT_name";
7875 case DW_AT_ordering:
7876 return "DW_AT_ordering";
7877 case DW_AT_subscr_data:
7878 return "DW_AT_subscr_data";
7879 case DW_AT_byte_size:
7880 return "DW_AT_byte_size";
7881 case DW_AT_bit_offset:
7882 return "DW_AT_bit_offset";
7883 case DW_AT_bit_size:
7884 return "DW_AT_bit_size";
7885 case DW_AT_element_list:
7886 return "DW_AT_element_list";
7887 case DW_AT_stmt_list:
7888 return "DW_AT_stmt_list";
7890 return "DW_AT_low_pc";
7892 return "DW_AT_high_pc";
7893 case DW_AT_language:
7894 return "DW_AT_language";
7896 return "DW_AT_member";
7898 return "DW_AT_discr";
7899 case DW_AT_discr_value:
7900 return "DW_AT_discr_value";
7901 case DW_AT_visibility:
7902 return "DW_AT_visibility";
7904 return "DW_AT_import";
7905 case DW_AT_string_length:
7906 return "DW_AT_string_length";
7907 case DW_AT_common_reference:
7908 return "DW_AT_common_reference";
7909 case DW_AT_comp_dir:
7910 return "DW_AT_comp_dir";
7911 case DW_AT_const_value:
7912 return "DW_AT_const_value";
7913 case DW_AT_containing_type:
7914 return "DW_AT_containing_type";
7915 case DW_AT_default_value:
7916 return "DW_AT_default_value";
7918 return "DW_AT_inline";
7919 case DW_AT_is_optional:
7920 return "DW_AT_is_optional";
7921 case DW_AT_lower_bound:
7922 return "DW_AT_lower_bound";
7923 case DW_AT_producer:
7924 return "DW_AT_producer";
7925 case DW_AT_prototyped:
7926 return "DW_AT_prototyped";
7927 case DW_AT_return_addr:
7928 return "DW_AT_return_addr";
7929 case DW_AT_start_scope:
7930 return "DW_AT_start_scope";
7931 case DW_AT_stride_size:
7932 return "DW_AT_stride_size";
7933 case DW_AT_upper_bound:
7934 return "DW_AT_upper_bound";
7935 case DW_AT_abstract_origin:
7936 return "DW_AT_abstract_origin";
7937 case DW_AT_accessibility:
7938 return "DW_AT_accessibility";
7939 case DW_AT_address_class:
7940 return "DW_AT_address_class";
7941 case DW_AT_artificial:
7942 return "DW_AT_artificial";
7943 case DW_AT_base_types:
7944 return "DW_AT_base_types";
7945 case DW_AT_calling_convention:
7946 return "DW_AT_calling_convention";
7948 return "DW_AT_count";
7949 case DW_AT_data_member_location:
7950 return "DW_AT_data_member_location";
7951 case DW_AT_decl_column:
7952 return "DW_AT_decl_column";
7953 case DW_AT_decl_file:
7954 return "DW_AT_decl_file";
7955 case DW_AT_decl_line:
7956 return "DW_AT_decl_line";
7957 case DW_AT_declaration:
7958 return "DW_AT_declaration";
7959 case DW_AT_discr_list:
7960 return "DW_AT_discr_list";
7961 case DW_AT_encoding:
7962 return "DW_AT_encoding";
7963 case DW_AT_external:
7964 return "DW_AT_external";
7965 case DW_AT_frame_base:
7966 return "DW_AT_frame_base";
7968 return "DW_AT_friend";
7969 case DW_AT_identifier_case:
7970 return "DW_AT_identifier_case";
7971 case DW_AT_macro_info:
7972 return "DW_AT_macro_info";
7973 case DW_AT_namelist_items:
7974 return "DW_AT_namelist_items";
7975 case DW_AT_priority:
7976 return "DW_AT_priority";
7978 return "DW_AT_segment";
7979 case DW_AT_specification:
7980 return "DW_AT_specification";
7981 case DW_AT_static_link:
7982 return "DW_AT_static_link";
7984 return "DW_AT_type";
7985 case DW_AT_use_location:
7986 return "DW_AT_use_location";
7987 case DW_AT_variable_parameter:
7988 return "DW_AT_variable_parameter";
7989 case DW_AT_virtuality:
7990 return "DW_AT_virtuality";
7991 case DW_AT_vtable_elem_location:
7992 return "DW_AT_vtable_elem_location";
7993 case DW_AT_allocated:
7994 return "DW_AT_allocated";
7995 case DW_AT_associated:
7996 return "DW_AT_associated";
7997 case DW_AT_data_location:
7998 return "DW_AT_data_location";
8000 return "DW_AT_stride";
8001 case DW_AT_entry_pc:
8002 return "DW_AT_entry_pc";
8003 case DW_AT_use_UTF8:
8004 return "DW_AT_use_UTF8";
8005 case DW_AT_extension:
8006 return "DW_AT_extension";
8008 return "DW_AT_ranges";
8009 case DW_AT_trampoline:
8010 return "DW_AT_trampoline";
8011 case DW_AT_call_column:
8012 return "DW_AT_call_column";
8013 case DW_AT_call_file:
8014 return "DW_AT_call_file";
8015 case DW_AT_call_line:
8016 return "DW_AT_call_line";
8018 case DW_AT_MIPS_fde:
8019 return "DW_AT_MIPS_fde";
8020 case DW_AT_MIPS_loop_begin:
8021 return "DW_AT_MIPS_loop_begin";
8022 case DW_AT_MIPS_tail_loop_begin:
8023 return "DW_AT_MIPS_tail_loop_begin";
8024 case DW_AT_MIPS_epilog_begin:
8025 return "DW_AT_MIPS_epilog_begin";
8026 case DW_AT_MIPS_loop_unroll_factor:
8027 return "DW_AT_MIPS_loop_unroll_factor";
8028 case DW_AT_MIPS_software_pipeline_depth:
8029 return "DW_AT_MIPS_software_pipeline_depth";
8031 case DW_AT_MIPS_linkage_name:
8032 return "DW_AT_MIPS_linkage_name";
8034 case DW_AT_sf_names:
8035 return "DW_AT_sf_names";
8036 case DW_AT_src_info:
8037 return "DW_AT_src_info";
8038 case DW_AT_mac_info:
8039 return "DW_AT_mac_info";
8040 case DW_AT_src_coords:
8041 return "DW_AT_src_coords";
8042 case DW_AT_body_begin:
8043 return "DW_AT_body_begin";
8044 case DW_AT_body_end:
8045 return "DW_AT_body_end";
8046 case DW_AT_GNU_vector:
8047 return "DW_AT_GNU_vector";
8049 return "DW_AT_<unknown>";
8053 /* Convert a DWARF value form code into its string name. */
8056 dwarf_form_name (unsigned form)
8061 return "DW_FORM_addr";
8062 case DW_FORM_block2:
8063 return "DW_FORM_block2";
8064 case DW_FORM_block4:
8065 return "DW_FORM_block4";
8067 return "DW_FORM_data2";
8069 return "DW_FORM_data4";
8071 return "DW_FORM_data8";
8072 case DW_FORM_string:
8073 return "DW_FORM_string";
8075 return "DW_FORM_block";
8076 case DW_FORM_block1:
8077 return "DW_FORM_block1";
8079 return "DW_FORM_data1";
8081 return "DW_FORM_flag";
8083 return "DW_FORM_sdata";
8085 return "DW_FORM_strp";
8087 return "DW_FORM_udata";
8088 case DW_FORM_ref_addr:
8089 return "DW_FORM_ref_addr";
8091 return "DW_FORM_ref1";
8093 return "DW_FORM_ref2";
8095 return "DW_FORM_ref4";
8097 return "DW_FORM_ref8";
8098 case DW_FORM_ref_udata:
8099 return "DW_FORM_ref_udata";
8100 case DW_FORM_indirect:
8101 return "DW_FORM_indirect";
8103 return "DW_FORM_<unknown>";
8107 /* Convert a DWARF stack opcode into its string name. */
8110 dwarf_stack_op_name (unsigned op)
8115 return "DW_OP_addr";
8117 return "DW_OP_deref";
8119 return "DW_OP_const1u";
8121 return "DW_OP_const1s";
8123 return "DW_OP_const2u";
8125 return "DW_OP_const2s";
8127 return "DW_OP_const4u";
8129 return "DW_OP_const4s";
8131 return "DW_OP_const8u";
8133 return "DW_OP_const8s";
8135 return "DW_OP_constu";
8137 return "DW_OP_consts";
8141 return "DW_OP_drop";
8143 return "DW_OP_over";
8145 return "DW_OP_pick";
8147 return "DW_OP_swap";
8151 return "DW_OP_xderef";
8159 return "DW_OP_minus";
8171 return "DW_OP_plus";
8172 case DW_OP_plus_uconst:
8173 return "DW_OP_plus_uconst";
8179 return "DW_OP_shra";
8197 return "DW_OP_skip";
8199 return "DW_OP_lit0";
8201 return "DW_OP_lit1";
8203 return "DW_OP_lit2";
8205 return "DW_OP_lit3";
8207 return "DW_OP_lit4";
8209 return "DW_OP_lit5";
8211 return "DW_OP_lit6";
8213 return "DW_OP_lit7";
8215 return "DW_OP_lit8";
8217 return "DW_OP_lit9";
8219 return "DW_OP_lit10";
8221 return "DW_OP_lit11";
8223 return "DW_OP_lit12";
8225 return "DW_OP_lit13";
8227 return "DW_OP_lit14";
8229 return "DW_OP_lit15";
8231 return "DW_OP_lit16";
8233 return "DW_OP_lit17";
8235 return "DW_OP_lit18";
8237 return "DW_OP_lit19";
8239 return "DW_OP_lit20";
8241 return "DW_OP_lit21";
8243 return "DW_OP_lit22";
8245 return "DW_OP_lit23";
8247 return "DW_OP_lit24";
8249 return "DW_OP_lit25";
8251 return "DW_OP_lit26";
8253 return "DW_OP_lit27";
8255 return "DW_OP_lit28";
8257 return "DW_OP_lit29";
8259 return "DW_OP_lit30";
8261 return "DW_OP_lit31";
8263 return "DW_OP_reg0";
8265 return "DW_OP_reg1";
8267 return "DW_OP_reg2";
8269 return "DW_OP_reg3";
8271 return "DW_OP_reg4";
8273 return "DW_OP_reg5";
8275 return "DW_OP_reg6";
8277 return "DW_OP_reg7";
8279 return "DW_OP_reg8";
8281 return "DW_OP_reg9";
8283 return "DW_OP_reg10";
8285 return "DW_OP_reg11";
8287 return "DW_OP_reg12";
8289 return "DW_OP_reg13";
8291 return "DW_OP_reg14";
8293 return "DW_OP_reg15";
8295 return "DW_OP_reg16";
8297 return "DW_OP_reg17";
8299 return "DW_OP_reg18";
8301 return "DW_OP_reg19";
8303 return "DW_OP_reg20";
8305 return "DW_OP_reg21";
8307 return "DW_OP_reg22";
8309 return "DW_OP_reg23";
8311 return "DW_OP_reg24";
8313 return "DW_OP_reg25";
8315 return "DW_OP_reg26";
8317 return "DW_OP_reg27";
8319 return "DW_OP_reg28";
8321 return "DW_OP_reg29";
8323 return "DW_OP_reg30";
8325 return "DW_OP_reg31";
8327 return "DW_OP_breg0";
8329 return "DW_OP_breg1";
8331 return "DW_OP_breg2";
8333 return "DW_OP_breg3";
8335 return "DW_OP_breg4";
8337 return "DW_OP_breg5";
8339 return "DW_OP_breg6";
8341 return "DW_OP_breg7";
8343 return "DW_OP_breg8";
8345 return "DW_OP_breg9";
8347 return "DW_OP_breg10";
8349 return "DW_OP_breg11";
8351 return "DW_OP_breg12";
8353 return "DW_OP_breg13";
8355 return "DW_OP_breg14";
8357 return "DW_OP_breg15";
8359 return "DW_OP_breg16";
8361 return "DW_OP_breg17";
8363 return "DW_OP_breg18";
8365 return "DW_OP_breg19";
8367 return "DW_OP_breg20";
8369 return "DW_OP_breg21";
8371 return "DW_OP_breg22";
8373 return "DW_OP_breg23";
8375 return "DW_OP_breg24";
8377 return "DW_OP_breg25";
8379 return "DW_OP_breg26";
8381 return "DW_OP_breg27";
8383 return "DW_OP_breg28";
8385 return "DW_OP_breg29";
8387 return "DW_OP_breg30";
8389 return "DW_OP_breg31";
8391 return "DW_OP_regx";
8393 return "DW_OP_fbreg";
8395 return "DW_OP_bregx";
8397 return "DW_OP_piece";
8398 case DW_OP_deref_size:
8399 return "DW_OP_deref_size";
8400 case DW_OP_xderef_size:
8401 return "DW_OP_xderef_size";
8404 /* DWARF 3 extensions. */
8405 case DW_OP_push_object_address:
8406 return "DW_OP_push_object_address";
8408 return "DW_OP_call2";
8410 return "DW_OP_call4";
8411 case DW_OP_call_ref:
8412 return "DW_OP_call_ref";
8413 /* GNU extensions. */
8414 case DW_OP_GNU_push_tls_address:
8415 return "DW_OP_GNU_push_tls_address";
8417 return "OP_<unknown>";
8422 dwarf_bool_name (unsigned mybool)
8430 /* Convert a DWARF type code into its string name. */
8433 dwarf_type_encoding_name (unsigned enc)
8437 case DW_ATE_address:
8438 return "DW_ATE_address";
8439 case DW_ATE_boolean:
8440 return "DW_ATE_boolean";
8441 case DW_ATE_complex_float:
8442 return "DW_ATE_complex_float";
8444 return "DW_ATE_float";
8446 return "DW_ATE_signed";
8447 case DW_ATE_signed_char:
8448 return "DW_ATE_signed_char";
8449 case DW_ATE_unsigned:
8450 return "DW_ATE_unsigned";
8451 case DW_ATE_unsigned_char:
8452 return "DW_ATE_unsigned_char";
8453 case DW_ATE_imaginary_float:
8454 return "DW_ATE_imaginary_float";
8456 return "DW_ATE_<unknown>";
8460 /* Convert a DWARF call frame info operation to its string name. */
8464 dwarf_cfi_name (unsigned cfi_opc)
8468 case DW_CFA_advance_loc:
8469 return "DW_CFA_advance_loc";
8471 return "DW_CFA_offset";
8472 case DW_CFA_restore:
8473 return "DW_CFA_restore";
8475 return "DW_CFA_nop";
8476 case DW_CFA_set_loc:
8477 return "DW_CFA_set_loc";
8478 case DW_CFA_advance_loc1:
8479 return "DW_CFA_advance_loc1";
8480 case DW_CFA_advance_loc2:
8481 return "DW_CFA_advance_loc2";
8482 case DW_CFA_advance_loc4:
8483 return "DW_CFA_advance_loc4";
8484 case DW_CFA_offset_extended:
8485 return "DW_CFA_offset_extended";
8486 case DW_CFA_restore_extended:
8487 return "DW_CFA_restore_extended";
8488 case DW_CFA_undefined:
8489 return "DW_CFA_undefined";
8490 case DW_CFA_same_value:
8491 return "DW_CFA_same_value";
8492 case DW_CFA_register:
8493 return "DW_CFA_register";
8494 case DW_CFA_remember_state:
8495 return "DW_CFA_remember_state";
8496 case DW_CFA_restore_state:
8497 return "DW_CFA_restore_state";
8498 case DW_CFA_def_cfa:
8499 return "DW_CFA_def_cfa";
8500 case DW_CFA_def_cfa_register:
8501 return "DW_CFA_def_cfa_register";
8502 case DW_CFA_def_cfa_offset:
8503 return "DW_CFA_def_cfa_offset";
8506 case DW_CFA_def_cfa_expression:
8507 return "DW_CFA_def_cfa_expression";
8508 case DW_CFA_expression:
8509 return "DW_CFA_expression";
8510 case DW_CFA_offset_extended_sf:
8511 return "DW_CFA_offset_extended_sf";
8512 case DW_CFA_def_cfa_sf:
8513 return "DW_CFA_def_cfa_sf";
8514 case DW_CFA_def_cfa_offset_sf:
8515 return "DW_CFA_def_cfa_offset_sf";
8517 /* SGI/MIPS specific */
8518 case DW_CFA_MIPS_advance_loc8:
8519 return "DW_CFA_MIPS_advance_loc8";
8521 /* GNU extensions */
8522 case DW_CFA_GNU_window_save:
8523 return "DW_CFA_GNU_window_save";
8524 case DW_CFA_GNU_args_size:
8525 return "DW_CFA_GNU_args_size";
8526 case DW_CFA_GNU_negative_offset_extended:
8527 return "DW_CFA_GNU_negative_offset_extended";
8530 return "DW_CFA_<unknown>";
8536 dump_die (struct die_info *die)
8540 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8541 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8542 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8543 dwarf_bool_name (die->child != NULL));
8545 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8546 for (i = 0; i < die->num_attrs; ++i)
8548 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8549 dwarf_attr_name (die->attrs[i].name),
8550 dwarf_form_name (die->attrs[i].form));
8551 switch (die->attrs[i].form)
8553 case DW_FORM_ref_addr:
8555 fprintf_unfiltered (gdb_stderr, "address: ");
8556 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8558 case DW_FORM_block2:
8559 case DW_FORM_block4:
8561 case DW_FORM_block1:
8562 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8567 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8568 (long) (DW_ADDR (&die->attrs[i])));
8576 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8578 case DW_FORM_string:
8580 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8581 DW_STRING (&die->attrs[i])
8582 ? DW_STRING (&die->attrs[i]) : "");
8585 if (DW_UNSND (&die->attrs[i]))
8586 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8588 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8590 case DW_FORM_indirect:
8591 /* the reader will have reduced the indirect form to
8592 the "base form" so this form should not occur */
8593 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8596 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8597 die->attrs[i].form);
8599 fprintf_unfiltered (gdb_stderr, "\n");
8604 dump_die_list (struct die_info *die)
8609 if (die->child != NULL)
8610 dump_die_list (die->child);
8611 if (die->sibling != NULL)
8612 dump_die_list (die->sibling);
8617 store_in_ref_table (unsigned int offset, struct die_info *die,
8618 struct dwarf2_cu *cu)
8621 struct die_info *old;
8623 h = (offset % REF_HASH_SIZE);
8624 old = cu->die_ref_table[h];
8625 die->next_ref = old;
8626 cu->die_ref_table[h] = die;
8630 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8632 unsigned int result = 0;
8636 case DW_FORM_ref_addr:
8641 case DW_FORM_ref_udata:
8642 result = DW_ADDR (attr);
8645 complaint (&symfile_complaints,
8646 _("unsupported die ref attribute form: '%s'"),
8647 dwarf_form_name (attr->form));
8652 /* Return the constant value held by the given attribute. Return -1
8653 if the value held by the attribute is not constant. */
8656 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8658 if (attr->form == DW_FORM_sdata)
8659 return DW_SND (attr);
8660 else if (attr->form == DW_FORM_udata
8661 || attr->form == DW_FORM_data1
8662 || attr->form == DW_FORM_data2
8663 || attr->form == DW_FORM_data4
8664 || attr->form == DW_FORM_data8)
8665 return DW_UNSND (attr);
8668 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8669 dwarf_form_name (attr->form));
8670 return default_value;
8674 static struct die_info *
8675 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8676 struct dwarf2_cu *cu)
8678 struct die_info *die;
8679 unsigned int offset;
8681 struct die_info temp_die;
8682 struct dwarf2_cu *target_cu;
8684 offset = dwarf2_get_ref_die_offset (attr, cu);
8686 if (DW_ADDR (attr) < cu->header.offset
8687 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
8689 struct dwarf2_per_cu_data *per_cu;
8690 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
8692 target_cu = per_cu->cu;
8697 h = (offset % REF_HASH_SIZE);
8698 die = target_cu->die_ref_table[h];
8701 if (die->offset == offset)
8703 die = die->next_ref;
8706 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8707 "at 0x%lx [in module %s]"),
8708 (long) src_die->offset, (long) offset, cu->objfile->name);
8713 static struct type *
8714 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
8715 struct dwarf2_cu *cu)
8717 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
8719 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8720 typeid, objfile->name);
8723 /* Look for this particular type in the fundamental type vector. If
8724 one is not found, create and install one appropriate for the
8725 current language and the current target machine. */
8727 if (cu->ftypes[typeid] == NULL)
8729 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8732 return (cu->ftypes[typeid]);
8735 /* Decode simple location descriptions.
8736 Given a pointer to a dwarf block that defines a location, compute
8737 the location and return the value.
8739 NOTE drow/2003-11-18: This function is called in two situations
8740 now: for the address of static or global variables (partial symbols
8741 only) and for offsets into structures which are expected to be
8742 (more or less) constant. The partial symbol case should go away,
8743 and only the constant case should remain. That will let this
8744 function complain more accurately. A few special modes are allowed
8745 without complaint for global variables (for instance, global
8746 register values and thread-local values).
8748 A location description containing no operations indicates that the
8749 object is optimized out. The return value is 0 for that case.
8750 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8751 callers will only want a very basic result and this can become a
8754 Note that stack[0] is unused except as a default error return.
8755 Note that stack overflow is not yet handled. */
8758 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8760 struct objfile *objfile = cu->objfile;
8761 struct comp_unit_head *cu_header = &cu->header;
8763 int size = blk->size;
8764 gdb_byte *data = blk->data;
8765 CORE_ADDR stack[64];
8767 unsigned int bytes_read, unsnd;
8811 stack[++stacki] = op - DW_OP_lit0;
8846 stack[++stacki] = op - DW_OP_reg0;
8848 dwarf2_complex_location_expr_complaint ();
8852 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8854 stack[++stacki] = unsnd;
8856 dwarf2_complex_location_expr_complaint ();
8860 stack[++stacki] = read_address (objfile->obfd, &data[i],
8866 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8871 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8876 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8881 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8886 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8891 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8896 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8902 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8907 stack[stacki + 1] = stack[stacki];
8912 stack[stacki - 1] += stack[stacki];
8916 case DW_OP_plus_uconst:
8917 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8922 stack[stacki - 1] -= stack[stacki];
8927 /* If we're not the last op, then we definitely can't encode
8928 this using GDB's address_class enum. This is valid for partial
8929 global symbols, although the variable's address will be bogus
8932 dwarf2_complex_location_expr_complaint ();
8935 case DW_OP_GNU_push_tls_address:
8936 /* The top of the stack has the offset from the beginning
8937 of the thread control block at which the variable is located. */
8938 /* Nothing should follow this operator, so the top of stack would
8940 /* This is valid for partial global symbols, but the variable's
8941 address will be bogus in the psymtab. */
8943 dwarf2_complex_location_expr_complaint ();
8947 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
8948 dwarf_stack_op_name (op));
8949 return (stack[stacki]);
8952 return (stack[stacki]);
8955 /* memory allocation interface */
8957 static struct dwarf_block *
8958 dwarf_alloc_block (struct dwarf2_cu *cu)
8960 struct dwarf_block *blk;
8962 blk = (struct dwarf_block *)
8963 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8967 static struct abbrev_info *
8968 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8970 struct abbrev_info *abbrev;
8972 abbrev = (struct abbrev_info *)
8973 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
8974 memset (abbrev, 0, sizeof (struct abbrev_info));
8978 static struct die_info *
8979 dwarf_alloc_die (void)
8981 struct die_info *die;
8983 die = (struct die_info *) xmalloc (sizeof (struct die_info));
8984 memset (die, 0, sizeof (struct die_info));
8989 /* Macro support. */
8992 /* Return the full name of file number I in *LH's file name table.
8993 Use COMP_DIR as the name of the current directory of the
8994 compilation. The result is allocated using xmalloc; the caller is
8995 responsible for freeing it. */
8997 file_full_name (int file, struct line_header *lh, const char *comp_dir)
8999 /* Is the file number a valid index into the line header's file name
9000 table? Remember that file numbers start with one, not zero. */
9001 if (1 <= file && file <= lh->num_file_names)
9003 struct file_entry *fe = &lh->file_names[file - 1];
9005 if (IS_ABSOLUTE_PATH (fe->name))
9006 return xstrdup (fe->name);
9014 dir = lh->include_dirs[fe->dir_index - 1];
9020 dir_len = strlen (dir);
9021 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
9022 strcpy (full_name, dir);
9023 full_name[dir_len] = '/';
9024 strcpy (full_name + dir_len + 1, fe->name);
9028 return xstrdup (fe->name);
9033 /* The compiler produced a bogus file number. We can at least
9034 record the macro definitions made in the file, even if we
9035 won't be able to find the file by name. */
9037 sprintf (fake_name, "<bad macro file number %d>", file);
9039 complaint (&symfile_complaints,
9040 _("bad file number in macro information (%d)"),
9043 return xstrdup (fake_name);
9048 static struct macro_source_file *
9049 macro_start_file (int file, int line,
9050 struct macro_source_file *current_file,
9051 const char *comp_dir,
9052 struct line_header *lh, struct objfile *objfile)
9054 /* The full name of this source file. */
9055 char *full_name = file_full_name (file, lh, comp_dir);
9057 /* We don't create a macro table for this compilation unit
9058 at all until we actually get a filename. */
9059 if (! pending_macros)
9060 pending_macros = new_macro_table (&objfile->objfile_obstack,
9061 objfile->macro_cache);
9064 /* If we have no current file, then this must be the start_file
9065 directive for the compilation unit's main source file. */
9066 current_file = macro_set_main (pending_macros, full_name);
9068 current_file = macro_include (current_file, line, full_name);
9072 return current_file;
9076 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9077 followed by a null byte. */
9079 copy_string (const char *buf, int len)
9081 char *s = xmalloc (len + 1);
9082 memcpy (s, buf, len);
9090 consume_improper_spaces (const char *p, const char *body)
9094 complaint (&symfile_complaints,
9095 _("macro definition contains spaces in formal argument list:\n`%s'"),
9107 parse_macro_definition (struct macro_source_file *file, int line,
9112 /* The body string takes one of two forms. For object-like macro
9113 definitions, it should be:
9115 <macro name> " " <definition>
9117 For function-like macro definitions, it should be:
9119 <macro name> "() " <definition>
9121 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9123 Spaces may appear only where explicitly indicated, and in the
9126 The Dwarf 2 spec says that an object-like macro's name is always
9127 followed by a space, but versions of GCC around March 2002 omit
9128 the space when the macro's definition is the empty string.
9130 The Dwarf 2 spec says that there should be no spaces between the
9131 formal arguments in a function-like macro's formal argument list,
9132 but versions of GCC around March 2002 include spaces after the
9136 /* Find the extent of the macro name. The macro name is terminated
9137 by either a space or null character (for an object-like macro) or
9138 an opening paren (for a function-like macro). */
9139 for (p = body; *p; p++)
9140 if (*p == ' ' || *p == '(')
9143 if (*p == ' ' || *p == '\0')
9145 /* It's an object-like macro. */
9146 int name_len = p - body;
9147 char *name = copy_string (body, name_len);
9148 const char *replacement;
9151 replacement = body + name_len + 1;
9154 dwarf2_macro_malformed_definition_complaint (body);
9155 replacement = body + name_len;
9158 macro_define_object (file, line, name, replacement);
9164 /* It's a function-like macro. */
9165 char *name = copy_string (body, p - body);
9168 char **argv = xmalloc (argv_size * sizeof (*argv));
9172 p = consume_improper_spaces (p, body);
9174 /* Parse the formal argument list. */
9175 while (*p && *p != ')')
9177 /* Find the extent of the current argument name. */
9178 const char *arg_start = p;
9180 while (*p && *p != ',' && *p != ')' && *p != ' ')
9183 if (! *p || p == arg_start)
9184 dwarf2_macro_malformed_definition_complaint (body);
9187 /* Make sure argv has room for the new argument. */
9188 if (argc >= argv_size)
9191 argv = xrealloc (argv, argv_size * sizeof (*argv));
9194 argv[argc++] = copy_string (arg_start, p - arg_start);
9197 p = consume_improper_spaces (p, body);
9199 /* Consume the comma, if present. */
9204 p = consume_improper_spaces (p, body);
9213 /* Perfectly formed definition, no complaints. */
9214 macro_define_function (file, line, name,
9215 argc, (const char **) argv,
9217 else if (*p == '\0')
9219 /* Complain, but do define it. */
9220 dwarf2_macro_malformed_definition_complaint (body);
9221 macro_define_function (file, line, name,
9222 argc, (const char **) argv,
9226 /* Just complain. */
9227 dwarf2_macro_malformed_definition_complaint (body);
9230 /* Just complain. */
9231 dwarf2_macro_malformed_definition_complaint (body);
9237 for (i = 0; i < argc; i++)
9243 dwarf2_macro_malformed_definition_complaint (body);
9248 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9249 char *comp_dir, bfd *abfd,
9250 struct dwarf2_cu *cu)
9252 gdb_byte *mac_ptr, *mac_end;
9253 struct macro_source_file *current_file = 0;
9255 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9257 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9261 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9262 mac_end = dwarf2_per_objfile->macinfo_buffer
9263 + dwarf2_per_objfile->macinfo_size;
9267 enum dwarf_macinfo_record_type macinfo_type;
9269 /* Do we at least have room for a macinfo type byte? */
9270 if (mac_ptr >= mac_end)
9272 dwarf2_macros_too_long_complaint ();
9276 macinfo_type = read_1_byte (abfd, mac_ptr);
9279 switch (macinfo_type)
9281 /* A zero macinfo type indicates the end of the macro
9286 case DW_MACINFO_define:
9287 case DW_MACINFO_undef:
9289 unsigned int bytes_read;
9293 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9294 mac_ptr += bytes_read;
9295 body = read_string (abfd, mac_ptr, &bytes_read);
9296 mac_ptr += bytes_read;
9299 complaint (&symfile_complaints,
9300 _("debug info gives macro %s outside of any file: %s"),
9302 DW_MACINFO_define ? "definition" : macinfo_type ==
9303 DW_MACINFO_undef ? "undefinition" :
9304 "something-or-other", body);
9307 if (macinfo_type == DW_MACINFO_define)
9308 parse_macro_definition (current_file, line, body);
9309 else if (macinfo_type == DW_MACINFO_undef)
9310 macro_undef (current_file, line, body);
9315 case DW_MACINFO_start_file:
9317 unsigned int bytes_read;
9320 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9321 mac_ptr += bytes_read;
9322 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9323 mac_ptr += bytes_read;
9325 current_file = macro_start_file (file, line,
9326 current_file, comp_dir,
9331 case DW_MACINFO_end_file:
9333 complaint (&symfile_complaints,
9334 _("macro debug info has an unmatched `close_file' directive"));
9337 current_file = current_file->included_by;
9340 enum dwarf_macinfo_record_type next_type;
9342 /* GCC circa March 2002 doesn't produce the zero
9343 type byte marking the end of the compilation
9344 unit. Complain if it's not there, but exit no
9347 /* Do we at least have room for a macinfo type byte? */
9348 if (mac_ptr >= mac_end)
9350 dwarf2_macros_too_long_complaint ();
9354 /* We don't increment mac_ptr here, so this is just
9356 next_type = read_1_byte (abfd, mac_ptr);
9358 complaint (&symfile_complaints,
9359 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9366 case DW_MACINFO_vendor_ext:
9368 unsigned int bytes_read;
9372 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9373 mac_ptr += bytes_read;
9374 string = read_string (abfd, mac_ptr, &bytes_read);
9375 mac_ptr += bytes_read;
9377 /* We don't recognize any vendor extensions. */
9384 /* Check if the attribute's form is a DW_FORM_block*
9385 if so return true else false. */
9387 attr_form_is_block (struct attribute *attr)
9389 return (attr == NULL ? 0 :
9390 attr->form == DW_FORM_block1
9391 || attr->form == DW_FORM_block2
9392 || attr->form == DW_FORM_block4
9393 || attr->form == DW_FORM_block);
9397 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9398 struct dwarf2_cu *cu)
9400 if ((attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9401 /* ".debug_loc" may not exist at all, or the offset may be outside
9402 the section. If so, fall through to the complaint in the
9404 && DW_UNSND (attr) < dwarf2_per_objfile->loc_size)
9406 struct dwarf2_loclist_baton *baton;
9408 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9409 sizeof (struct dwarf2_loclist_baton));
9410 baton->objfile = cu->objfile;
9412 /* We don't know how long the location list is, but make sure we
9413 don't run off the edge of the section. */
9414 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9415 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9416 baton->base_address = cu->header.base_address;
9417 if (cu->header.base_known == 0)
9418 complaint (&symfile_complaints,
9419 _("Location list used without specifying the CU base address."));
9421 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9422 SYMBOL_LOCATION_BATON (sym) = baton;
9426 struct dwarf2_locexpr_baton *baton;
9428 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9429 sizeof (struct dwarf2_locexpr_baton));
9430 baton->objfile = cu->objfile;
9432 if (attr_form_is_block (attr))
9434 /* Note that we're just copying the block's data pointer
9435 here, not the actual data. We're still pointing into the
9436 info_buffer for SYM's objfile; right now we never release
9437 that buffer, but when we do clean up properly this may
9439 baton->size = DW_BLOCK (attr)->size;
9440 baton->data = DW_BLOCK (attr)->data;
9444 dwarf2_invalid_attrib_class_complaint ("location description",
9445 SYMBOL_NATURAL_NAME (sym));
9450 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9451 SYMBOL_LOCATION_BATON (sym) = baton;
9455 /* Locate the compilation unit from CU's objfile which contains the
9456 DIE at OFFSET. Raises an error on failure. */
9458 static struct dwarf2_per_cu_data *
9459 dwarf2_find_containing_comp_unit (unsigned long offset,
9460 struct objfile *objfile)
9462 struct dwarf2_per_cu_data *this_cu;
9466 high = dwarf2_per_objfile->n_comp_units - 1;
9469 int mid = low + (high - low) / 2;
9470 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9475 gdb_assert (low == high);
9476 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9479 error (_("Dwarf Error: could not find partial DIE containing "
9480 "offset 0x%lx [in module %s]"),
9481 (long) offset, bfd_get_filename (objfile->obfd));
9483 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9484 return dwarf2_per_objfile->all_comp_units[low-1];
9488 this_cu = dwarf2_per_objfile->all_comp_units[low];
9489 if (low == dwarf2_per_objfile->n_comp_units - 1
9490 && offset >= this_cu->offset + this_cu->length)
9491 error (_("invalid dwarf2 offset %ld"), offset);
9492 gdb_assert (offset < this_cu->offset + this_cu->length);
9497 /* Locate the compilation unit from OBJFILE which is located at exactly
9498 OFFSET. Raises an error on failure. */
9500 static struct dwarf2_per_cu_data *
9501 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9503 struct dwarf2_per_cu_data *this_cu;
9504 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9505 if (this_cu->offset != offset)
9506 error (_("no compilation unit with offset %ld."), offset);
9510 /* Release one cached compilation unit, CU. We unlink it from the tree
9511 of compilation units, but we don't remove it from the read_in_chain;
9512 the caller is responsible for that. */
9515 free_one_comp_unit (void *data)
9517 struct dwarf2_cu *cu = data;
9519 if (cu->per_cu != NULL)
9520 cu->per_cu->cu = NULL;
9523 obstack_free (&cu->comp_unit_obstack, NULL);
9525 free_die_list (cu->dies);
9530 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9531 when we're finished with it. We can't free the pointer itself, but be
9532 sure to unlink it from the cache. Also release any associated storage
9533 and perform cache maintenance.
9535 Only used during partial symbol parsing. */
9538 free_stack_comp_unit (void *data)
9540 struct dwarf2_cu *cu = data;
9542 obstack_free (&cu->comp_unit_obstack, NULL);
9543 cu->partial_dies = NULL;
9545 if (cu->per_cu != NULL)
9547 /* This compilation unit is on the stack in our caller, so we
9548 should not xfree it. Just unlink it. */
9549 cu->per_cu->cu = NULL;
9552 /* If we had a per-cu pointer, then we may have other compilation
9553 units loaded, so age them now. */
9554 age_cached_comp_units ();
9558 /* Free all cached compilation units. */
9561 free_cached_comp_units (void *data)
9563 struct dwarf2_per_cu_data *per_cu, **last_chain;
9565 per_cu = dwarf2_per_objfile->read_in_chain;
9566 last_chain = &dwarf2_per_objfile->read_in_chain;
9567 while (per_cu != NULL)
9569 struct dwarf2_per_cu_data *next_cu;
9571 next_cu = per_cu->cu->read_in_chain;
9573 free_one_comp_unit (per_cu->cu);
9574 *last_chain = next_cu;
9580 /* Increase the age counter on each cached compilation unit, and free
9581 any that are too old. */
9584 age_cached_comp_units (void)
9586 struct dwarf2_per_cu_data *per_cu, **last_chain;
9588 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9589 per_cu = dwarf2_per_objfile->read_in_chain;
9590 while (per_cu != NULL)
9592 per_cu->cu->last_used ++;
9593 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9594 dwarf2_mark (per_cu->cu);
9595 per_cu = per_cu->cu->read_in_chain;
9598 per_cu = dwarf2_per_objfile->read_in_chain;
9599 last_chain = &dwarf2_per_objfile->read_in_chain;
9600 while (per_cu != NULL)
9602 struct dwarf2_per_cu_data *next_cu;
9604 next_cu = per_cu->cu->read_in_chain;
9606 if (!per_cu->cu->mark)
9608 free_one_comp_unit (per_cu->cu);
9609 *last_chain = next_cu;
9612 last_chain = &per_cu->cu->read_in_chain;
9618 /* Remove a single compilation unit from the cache. */
9621 free_one_cached_comp_unit (void *target_cu)
9623 struct dwarf2_per_cu_data *per_cu, **last_chain;
9625 per_cu = dwarf2_per_objfile->read_in_chain;
9626 last_chain = &dwarf2_per_objfile->read_in_chain;
9627 while (per_cu != NULL)
9629 struct dwarf2_per_cu_data *next_cu;
9631 next_cu = per_cu->cu->read_in_chain;
9633 if (per_cu->cu == target_cu)
9635 free_one_comp_unit (per_cu->cu);
9636 *last_chain = next_cu;
9640 last_chain = &per_cu->cu->read_in_chain;
9646 /* A pair of DIE offset and GDB type pointer. We store these
9647 in a hash table separate from the DIEs, and preserve them
9648 when the DIEs are flushed out of cache. */
9650 struct dwarf2_offset_and_type
9652 unsigned int offset;
9656 /* Hash function for a dwarf2_offset_and_type. */
9659 offset_and_type_hash (const void *item)
9661 const struct dwarf2_offset_and_type *ofs = item;
9665 /* Equality function for a dwarf2_offset_and_type. */
9668 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9670 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9671 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9672 return ofs_lhs->offset == ofs_rhs->offset;
9675 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9676 table if necessary. */
9679 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
9681 struct dwarf2_offset_and_type **slot, ofs;
9685 if (cu->per_cu == NULL)
9688 if (cu->per_cu->type_hash == NULL)
9689 cu->per_cu->type_hash
9690 = htab_create_alloc_ex (cu->header.length / 24,
9691 offset_and_type_hash,
9694 &cu->objfile->objfile_obstack,
9695 hashtab_obstack_allocate,
9696 dummy_obstack_deallocate);
9698 ofs.offset = die->offset;
9700 slot = (struct dwarf2_offset_and_type **)
9701 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
9702 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
9706 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9707 have a saved type. */
9709 static struct type *
9710 get_die_type (struct die_info *die, htab_t type_hash)
9712 struct dwarf2_offset_and_type *slot, ofs;
9714 ofs.offset = die->offset;
9715 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
9722 /* Restore the types of the DIE tree starting at START_DIE from the hash
9723 table saved in CU. */
9726 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
9728 struct die_info *die;
9730 if (cu->per_cu->type_hash == NULL)
9733 for (die = start_die; die != NULL; die = die->sibling)
9735 die->type = get_die_type (die, cu->per_cu->type_hash);
9736 if (die->child != NULL)
9737 reset_die_and_siblings_types (die->child, cu);
9741 /* Set the mark field in CU and in every other compilation unit in the
9742 cache that we must keep because we are keeping CU. */
9744 /* Add a dependence relationship from CU to REF_PER_CU. */
9747 dwarf2_add_dependence (struct dwarf2_cu *cu,
9748 struct dwarf2_per_cu_data *ref_per_cu)
9752 if (cu->dependencies == NULL)
9754 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
9755 NULL, &cu->comp_unit_obstack,
9756 hashtab_obstack_allocate,
9757 dummy_obstack_deallocate);
9759 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
9764 /* Set the mark field in CU and in every other compilation unit in the
9765 cache that we must keep because we are keeping CU. */
9768 dwarf2_mark_helper (void **slot, void *data)
9770 struct dwarf2_per_cu_data *per_cu;
9772 per_cu = (struct dwarf2_per_cu_data *) *slot;
9773 if (per_cu->cu->mark)
9775 per_cu->cu->mark = 1;
9777 if (per_cu->cu->dependencies != NULL)
9778 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
9784 dwarf2_mark (struct dwarf2_cu *cu)
9789 if (cu->dependencies != NULL)
9790 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
9794 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
9798 per_cu->cu->mark = 0;
9799 per_cu = per_cu->cu->read_in_chain;
9803 /* Trivial hash function for partial_die_info: the hash value of a DIE
9804 is its offset in .debug_info for this objfile. */
9807 partial_die_hash (const void *item)
9809 const struct partial_die_info *part_die = item;
9810 return part_die->offset;
9813 /* Trivial comparison function for partial_die_info structures: two DIEs
9814 are equal if they have the same offset. */
9817 partial_die_eq (const void *item_lhs, const void *item_rhs)
9819 const struct partial_die_info *part_die_lhs = item_lhs;
9820 const struct partial_die_info *part_die_rhs = item_rhs;
9821 return part_die_lhs->offset == part_die_rhs->offset;
9824 static struct cmd_list_element *set_dwarf2_cmdlist;
9825 static struct cmd_list_element *show_dwarf2_cmdlist;
9828 set_dwarf2_cmd (char *args, int from_tty)
9830 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
9834 show_dwarf2_cmd (char *args, int from_tty)
9836 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
9839 void _initialize_dwarf2_read (void);
9842 _initialize_dwarf2_read (void)
9844 dwarf2_objfile_data_key = register_objfile_data ();
9846 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
9847 Set DWARF 2 specific variables.\n\
9848 Configure DWARF 2 variables such as the cache size"),
9849 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
9850 0/*allow-unknown*/, &maintenance_set_cmdlist);
9852 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
9853 Show DWARF 2 specific variables\n\
9854 Show DWARF 2 variables such as the cache size"),
9855 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
9856 0/*allow-unknown*/, &maintenance_show_cmdlist);
9858 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
9859 &dwarf2_max_cache_age, _("\
9860 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9861 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9862 A higher limit means that cached compilation units will be stored\n\
9863 in memory longer, and more total memory will be used. Zero disables\n\
9864 caching, which can slow down startup."),
9866 show_dwarf2_max_cache_age,
9867 &set_dwarf2_cmdlist,
9868 &show_dwarf2_cmdlist);