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
3716 GCC shouldn't do this; it should just output pointer to member DIEs.
3717 This is GCC PR debug/28767. */
3720 quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu)
3722 struct objfile *objfile = cu->objfile;
3724 struct die_info *pfn_die, *delta_die;
3725 struct attribute *pfn_name, *delta_name;
3726 struct type *pfn_type, *domain_type;
3728 /* Check for a structure with no name and two children. */
3729 if (die->tag != DW_TAG_structure_type
3730 || dwarf2_attr (die, DW_AT_name, cu) != NULL
3731 || die->child == NULL
3732 || die->child->sibling == NULL
3733 || (die->child->sibling->sibling != NULL
3734 && die->child->sibling->sibling->tag != DW_TAG_padding))
3737 /* Check for __pfn and __delta members. */
3738 pfn_die = die->child;
3739 pfn_name = dwarf2_attr (pfn_die, DW_AT_name, cu);
3740 if (pfn_die->tag != DW_TAG_member
3742 || DW_STRING (pfn_name) == NULL
3743 || strcmp ("__pfn", DW_STRING (pfn_name)) != 0)
3746 delta_die = pfn_die->sibling;
3747 delta_name = dwarf2_attr (delta_die, DW_AT_name, cu);
3748 if (delta_die->tag != DW_TAG_member
3749 || delta_name == NULL
3750 || DW_STRING (delta_name) == NULL
3751 || strcmp ("__delta", DW_STRING (delta_name)) != 0)
3754 /* Find the type of the method. */
3755 pfn_type = die_type (pfn_die, cu);
3756 if (pfn_type == NULL
3757 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
3758 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
3761 /* Look for the "this" argument. */
3762 pfn_type = TYPE_TARGET_TYPE (pfn_type);
3763 if (TYPE_NFIELDS (pfn_type) == 0
3764 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
3767 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
3768 type = alloc_type (objfile);
3769 smash_to_method_type (type, domain_type, TYPE_TARGET_TYPE (pfn_type),
3770 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
3771 TYPE_VARARGS (pfn_type));
3772 type = lookup_pointer_type (type);
3773 set_die_type (die, type, cu);
3778 /* Called when we find the DIE that starts a structure or union scope
3779 (definition) to process all dies that define the members of the
3782 NOTE: we need to call struct_type regardless of whether or not the
3783 DIE has an at_name attribute, since it might be an anonymous
3784 structure or union. This gets the type entered into our set of
3787 However, if the structure is incomplete (an opaque struct/union)
3788 then suppress creating a symbol table entry for it since gdb only
3789 wants to find the one with the complete definition. Note that if
3790 it is complete, we just call new_symbol, which does it's own
3791 checking about whether the struct/union is anonymous or not (and
3792 suppresses creating a symbol table entry itself). */
3795 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3797 struct objfile *objfile = cu->objfile;
3799 struct attribute *attr;
3800 const char *previous_prefix = processing_current_prefix;
3801 struct cleanup *back_to = NULL;
3806 if (quirk_gcc_member_function_pointer (die, cu))
3809 type = alloc_type (objfile);
3810 INIT_CPLUS_SPECIFIC (type);
3811 attr = dwarf2_attr (die, DW_AT_name, cu);
3812 if (attr && DW_STRING (attr))
3814 if (cu->language == language_cplus
3815 || cu->language == language_java)
3817 char *new_prefix = determine_class_name (die, cu);
3818 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3819 strlen (new_prefix),
3820 &objfile->objfile_obstack);
3821 back_to = make_cleanup (xfree, new_prefix);
3822 processing_current_prefix = new_prefix;
3826 /* The name is already allocated along with this objfile, so
3827 we don't need to duplicate it for the type. */
3828 TYPE_TAG_NAME (type) = DW_STRING (attr);
3832 if (die->tag == DW_TAG_structure_type)
3834 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3836 else if (die->tag == DW_TAG_union_type)
3838 TYPE_CODE (type) = TYPE_CODE_UNION;
3842 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3844 TYPE_CODE (type) = TYPE_CODE_CLASS;
3847 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3850 TYPE_LENGTH (type) = DW_UNSND (attr);
3854 TYPE_LENGTH (type) = 0;
3857 if (die_is_declaration (die, cu))
3858 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3860 /* We need to add the type field to the die immediately so we don't
3861 infinitely recurse when dealing with pointers to the structure
3862 type within the structure itself. */
3863 set_die_type (die, type, cu);
3865 if (die->child != NULL && ! die_is_declaration (die, cu))
3867 struct field_info fi;
3868 struct die_info *child_die;
3869 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3871 memset (&fi, 0, sizeof (struct field_info));
3873 child_die = die->child;
3875 while (child_die && child_die->tag)
3877 if (child_die->tag == DW_TAG_member
3878 || child_die->tag == DW_TAG_variable)
3880 /* NOTE: carlton/2002-11-05: A C++ static data member
3881 should be a DW_TAG_member that is a declaration, but
3882 all versions of G++ as of this writing (so through at
3883 least 3.2.1) incorrectly generate DW_TAG_variable
3884 tags for them instead. */
3885 dwarf2_add_field (&fi, child_die, cu);
3887 else if (child_die->tag == DW_TAG_subprogram)
3889 /* C++ member function. */
3890 read_type_die (child_die, cu);
3891 dwarf2_add_member_fn (&fi, child_die, type, cu);
3893 else if (child_die->tag == DW_TAG_inheritance)
3895 /* C++ base class field. */
3896 dwarf2_add_field (&fi, child_die, cu);
3898 child_die = sibling_die (child_die);
3901 /* Attach fields and member functions to the type. */
3903 dwarf2_attach_fields_to_type (&fi, type, cu);
3906 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3908 /* Get the type which refers to the base class (possibly this
3909 class itself) which contains the vtable pointer for the current
3910 class from the DW_AT_containing_type attribute. */
3912 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3914 struct type *t = die_containing_type (die, cu);
3916 TYPE_VPTR_BASETYPE (type) = t;
3921 /* Our own class provides vtbl ptr. */
3922 for (i = TYPE_NFIELDS (t) - 1;
3923 i >= TYPE_N_BASECLASSES (t);
3926 char *fieldname = TYPE_FIELD_NAME (t, i);
3928 if (is_vtable_name (fieldname, cu))
3930 TYPE_VPTR_FIELDNO (type) = i;
3935 /* Complain if virtual function table field not found. */
3936 if (i < TYPE_N_BASECLASSES (t))
3937 complaint (&symfile_complaints,
3938 _("virtual function table pointer not found when defining class '%s'"),
3939 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3944 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3947 else if (cu->producer
3948 && strncmp (cu->producer,
3949 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3951 /* The IBM XLC compiler does not provide direct indication
3952 of the containing type, but the vtable pointer is
3953 always named __vfp. */
3957 for (i = TYPE_NFIELDS (type) - 1;
3958 i >= TYPE_N_BASECLASSES (type);
3961 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
3963 TYPE_VPTR_FIELDNO (type) = i;
3964 TYPE_VPTR_BASETYPE (type) = type;
3971 do_cleanups (back_to);
3974 processing_current_prefix = previous_prefix;
3975 if (back_to != NULL)
3976 do_cleanups (back_to);
3980 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3982 struct objfile *objfile = cu->objfile;
3983 const char *previous_prefix = processing_current_prefix;
3984 struct die_info *child_die = die->child;
3986 if (TYPE_TAG_NAME (die->type) != NULL)
3987 processing_current_prefix = TYPE_TAG_NAME (die->type);
3989 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3990 snapshots) has been known to create a die giving a declaration
3991 for a class that has, as a child, a die giving a definition for a
3992 nested class. So we have to process our children even if the
3993 current die is a declaration. Normally, of course, a declaration
3994 won't have any children at all. */
3996 while (child_die != NULL && child_die->tag)
3998 if (child_die->tag == DW_TAG_member
3999 || child_die->tag == DW_TAG_variable
4000 || child_die->tag == DW_TAG_inheritance)
4005 process_die (child_die, cu);
4007 child_die = sibling_die (child_die);
4010 if (die->child != NULL && ! die_is_declaration (die, cu))
4011 new_symbol (die, die->type, cu);
4013 processing_current_prefix = previous_prefix;
4016 /* Given a DW_AT_enumeration_type die, set its type. We do not
4017 complete the type's fields yet, or create any symbols. */
4020 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
4022 struct objfile *objfile = cu->objfile;
4024 struct attribute *attr;
4029 type = alloc_type (objfile);
4031 TYPE_CODE (type) = TYPE_CODE_ENUM;
4032 attr = dwarf2_attr (die, DW_AT_name, cu);
4033 if (attr && DW_STRING (attr))
4035 char *name = DW_STRING (attr);
4037 if (processing_has_namespace_info)
4039 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
4040 processing_current_prefix,
4045 /* The name is already allocated along with this objfile, so
4046 we don't need to duplicate it for the type. */
4047 TYPE_TAG_NAME (type) = name;
4051 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4054 TYPE_LENGTH (type) = DW_UNSND (attr);
4058 TYPE_LENGTH (type) = 0;
4061 set_die_type (die, type, cu);
4064 /* Determine the name of the type represented by DIE, which should be
4065 a named C++ or Java compound type. Return the name in question; the caller
4066 is responsible for xfree()'ing it. */
4069 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
4071 struct cleanup *back_to = NULL;
4072 struct die_info *spec_die = die_specification (die, cu);
4073 char *new_prefix = NULL;
4075 /* If this is the definition of a class that is declared by another
4076 die, then processing_current_prefix may not be accurate; see
4077 read_func_scope for a similar example. */
4078 if (spec_die != NULL)
4080 char *specification_prefix = determine_prefix (spec_die, cu);
4081 processing_current_prefix = specification_prefix;
4082 back_to = make_cleanup (xfree, specification_prefix);
4085 /* If we don't have namespace debug info, guess the name by trying
4086 to demangle the names of members, just like we did in
4087 guess_structure_name. */
4088 if (!processing_has_namespace_info)
4090 struct die_info *child;
4092 for (child = die->child;
4093 child != NULL && child->tag != 0;
4094 child = sibling_die (child))
4096 if (child->tag == DW_TAG_subprogram)
4099 = language_class_name_from_physname (cu->language_defn,
4103 if (new_prefix != NULL)
4109 if (new_prefix == NULL)
4111 const char *name = dwarf2_name (die, cu);
4112 new_prefix = typename_concat (NULL, processing_current_prefix,
4113 name ? name : "<<anonymous>>",
4117 if (back_to != NULL)
4118 do_cleanups (back_to);
4123 /* Given a pointer to a die which begins an enumeration, process all
4124 the dies that define the members of the enumeration, and create the
4125 symbol for the enumeration type.
4127 NOTE: We reverse the order of the element list. */
4130 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4132 struct objfile *objfile = cu->objfile;
4133 struct die_info *child_die;
4134 struct field *fields;
4135 struct attribute *attr;
4138 int unsigned_enum = 1;
4142 if (die->child != NULL)
4144 child_die = die->child;
4145 while (child_die && child_die->tag)
4147 if (child_die->tag != DW_TAG_enumerator)
4149 process_die (child_die, cu);
4153 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4156 sym = new_symbol (child_die, die->type, cu);
4157 if (SYMBOL_VALUE (sym) < 0)
4160 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4162 fields = (struct field *)
4164 (num_fields + DW_FIELD_ALLOC_CHUNK)
4165 * sizeof (struct field));
4168 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4169 FIELD_TYPE (fields[num_fields]) = NULL;
4170 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4171 FIELD_BITSIZE (fields[num_fields]) = 0;
4172 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4178 child_die = sibling_die (child_die);
4183 TYPE_NFIELDS (die->type) = num_fields;
4184 TYPE_FIELDS (die->type) = (struct field *)
4185 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4186 memcpy (TYPE_FIELDS (die->type), fields,
4187 sizeof (struct field) * num_fields);
4191 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4194 new_symbol (die, die->type, cu);
4197 /* Extract all information from a DW_TAG_array_type DIE and put it in
4198 the DIE's type field. For now, this only handles one dimensional
4202 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4204 struct objfile *objfile = cu->objfile;
4205 struct die_info *child_die;
4206 struct type *type = NULL;
4207 struct type *element_type, *range_type, *index_type;
4208 struct type **range_types = NULL;
4209 struct attribute *attr;
4211 struct cleanup *back_to;
4213 /* Return if we've already decoded this type. */
4219 element_type = die_type (die, cu);
4221 /* Irix 6.2 native cc creates array types without children for
4222 arrays with unspecified length. */
4223 if (die->child == NULL)
4225 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4226 range_type = create_range_type (NULL, index_type, 0, -1);
4227 set_die_type (die, create_array_type (NULL, element_type, range_type),
4232 back_to = make_cleanup (null_cleanup, NULL);
4233 child_die = die->child;
4234 while (child_die && child_die->tag)
4236 if (child_die->tag == DW_TAG_subrange_type)
4238 read_subrange_type (child_die, cu);
4240 if (child_die->type != NULL)
4242 /* The range type was succesfully read. Save it for
4243 the array type creation. */
4244 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4246 range_types = (struct type **)
4247 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4248 * sizeof (struct type *));
4250 make_cleanup (free_current_contents, &range_types);
4252 range_types[ndim++] = child_die->type;
4255 child_die = sibling_die (child_die);
4258 /* Dwarf2 dimensions are output from left to right, create the
4259 necessary array types in backwards order. */
4261 type = element_type;
4263 if (read_array_order (die, cu) == DW_ORD_col_major)
4267 type = create_array_type (NULL, type, range_types[i++]);
4272 type = create_array_type (NULL, type, range_types[ndim]);
4275 /* Understand Dwarf2 support for vector types (like they occur on
4276 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4277 array type. This is not part of the Dwarf2/3 standard yet, but a
4278 custom vendor extension. The main difference between a regular
4279 array and the vector variant is that vectors are passed by value
4281 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4283 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4285 attr = dwarf2_attr (die, DW_AT_name, cu);
4286 if (attr && DW_STRING (attr))
4287 TYPE_NAME (type) = DW_STRING (attr);
4289 do_cleanups (back_to);
4291 /* Install the type in the die. */
4292 set_die_type (die, type, cu);
4295 static enum dwarf_array_dim_ordering
4296 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4298 struct attribute *attr;
4300 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4302 if (attr) return DW_SND (attr);
4305 GNU F77 is a special case, as at 08/2004 array type info is the
4306 opposite order to the dwarf2 specification, but data is still
4307 laid out as per normal fortran.
4309 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4313 if (cu->language == language_fortran &&
4314 cu->producer && strstr (cu->producer, "GNU F77"))
4316 return DW_ORD_row_major;
4319 switch (cu->language_defn->la_array_ordering)
4321 case array_column_major:
4322 return DW_ORD_col_major;
4323 case array_row_major:
4325 return DW_ORD_row_major;
4329 /* Extract all information from a DW_TAG_set_type DIE and put it in
4330 the DIE's type field. */
4333 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
4335 if (die->type == NULL)
4336 die->type = create_set_type ((struct type *) NULL, die_type (die, cu));
4339 /* First cut: install each common block member as a global variable. */
4342 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4344 struct die_info *child_die;
4345 struct attribute *attr;
4347 CORE_ADDR base = (CORE_ADDR) 0;
4349 attr = dwarf2_attr (die, DW_AT_location, cu);
4352 /* Support the .debug_loc offsets */
4353 if (attr_form_is_block (attr))
4355 base = decode_locdesc (DW_BLOCK (attr), cu);
4357 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4359 dwarf2_complex_location_expr_complaint ();
4363 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4364 "common block member");
4367 if (die->child != NULL)
4369 child_die = die->child;
4370 while (child_die && child_die->tag)
4372 sym = new_symbol (child_die, NULL, cu);
4373 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4376 SYMBOL_VALUE_ADDRESS (sym) =
4377 base + decode_locdesc (DW_BLOCK (attr), cu);
4378 add_symbol_to_list (sym, &global_symbols);
4380 child_die = sibling_die (child_die);
4385 /* Read a C++ namespace. */
4388 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4390 struct objfile *objfile = cu->objfile;
4391 const char *previous_prefix = processing_current_prefix;
4394 struct die_info *current_die;
4395 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4397 name = namespace_name (die, &is_anonymous, cu);
4399 /* Now build the name of the current namespace. */
4401 if (previous_prefix[0] == '\0')
4403 processing_current_prefix = name;
4407 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4408 make_cleanup (xfree, temp_name);
4409 processing_current_prefix = temp_name;
4412 /* Add a symbol associated to this if we haven't seen the namespace
4413 before. Also, add a using directive if it's an anonymous
4416 if (dwarf2_extension (die, cu) == NULL)
4420 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4421 this cast will hopefully become unnecessary. */
4422 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4423 (char *) processing_current_prefix,
4425 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4427 new_symbol (die, type, cu);
4428 set_die_type (die, type, cu);
4431 cp_add_using_directive (processing_current_prefix,
4432 strlen (previous_prefix),
4433 strlen (processing_current_prefix));
4436 if (die->child != NULL)
4438 struct die_info *child_die = die->child;
4440 while (child_die && child_die->tag)
4442 process_die (child_die, cu);
4443 child_die = sibling_die (child_die);
4447 processing_current_prefix = previous_prefix;
4448 do_cleanups (back_to);
4451 /* Return the name of the namespace represented by DIE. Set
4452 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4456 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4458 struct die_info *current_die;
4459 const char *name = NULL;
4461 /* Loop through the extensions until we find a name. */
4463 for (current_die = die;
4464 current_die != NULL;
4465 current_die = dwarf2_extension (die, cu))
4467 name = dwarf2_name (current_die, cu);
4472 /* Is it an anonymous namespace? */
4474 *is_anonymous = (name == NULL);
4476 name = "(anonymous namespace)";
4481 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4482 the user defined type vector. */
4485 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4487 struct comp_unit_head *cu_header = &cu->header;
4489 struct attribute *attr_byte_size;
4490 struct attribute *attr_address_class;
4491 int byte_size, addr_class;
4498 type = lookup_pointer_type (die_type (die, cu));
4500 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4502 byte_size = DW_UNSND (attr_byte_size);
4504 byte_size = cu_header->addr_size;
4506 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4507 if (attr_address_class)
4508 addr_class = DW_UNSND (attr_address_class);
4510 addr_class = DW_ADDR_none;
4512 /* If the pointer size or address class is different than the
4513 default, create a type variant marked as such and set the
4514 length accordingly. */
4515 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4517 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4521 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
4522 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4523 type = make_type_with_address_space (type, type_flags);
4525 else if (TYPE_LENGTH (type) != byte_size)
4527 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4530 /* Should we also complain about unhandled address classes? */
4534 TYPE_LENGTH (type) = byte_size;
4535 set_die_type (die, type, cu);
4538 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4539 the user defined type vector. */
4542 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4544 struct objfile *objfile = cu->objfile;
4546 struct type *to_type;
4547 struct type *domain;
4554 type = alloc_type (objfile);
4555 to_type = die_type (die, cu);
4556 domain = die_containing_type (die, cu);
4557 smash_to_member_type (type, domain, to_type);
4559 set_die_type (die, type, cu);
4562 /* Extract all information from a DW_TAG_reference_type DIE and add to
4563 the user defined type vector. */
4566 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4568 struct comp_unit_head *cu_header = &cu->header;
4570 struct attribute *attr;
4577 type = lookup_reference_type (die_type (die, cu));
4578 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4581 TYPE_LENGTH (type) = DW_UNSND (attr);
4585 TYPE_LENGTH (type) = cu_header->addr_size;
4587 set_die_type (die, type, cu);
4591 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4593 struct type *base_type;
4600 base_type = die_type (die, cu);
4601 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4606 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4608 struct type *base_type;
4615 base_type = die_type (die, cu);
4616 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4620 /* Extract all information from a DW_TAG_string_type DIE and add to
4621 the user defined type vector. It isn't really a user defined type,
4622 but it behaves like one, with other DIE's using an AT_user_def_type
4623 attribute to reference it. */
4626 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4628 struct objfile *objfile = cu->objfile;
4629 struct type *type, *range_type, *index_type, *char_type;
4630 struct attribute *attr;
4631 unsigned int length;
4638 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4641 length = DW_UNSND (attr);
4645 /* check for the DW_AT_byte_size attribute */
4646 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4649 length = DW_UNSND (attr);
4656 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4657 range_type = create_range_type (NULL, index_type, 1, length);
4658 if (cu->language == language_fortran)
4660 /* Need to create a unique string type for bounds
4662 type = create_string_type (0, range_type);
4666 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4667 type = create_string_type (char_type, range_type);
4669 set_die_type (die, type, cu);
4672 /* Handle DIES due to C code like:
4676 int (*funcp)(int a, long l);
4680 ('funcp' generates a DW_TAG_subroutine_type DIE)
4684 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4686 struct type *type; /* Type that this function returns */
4687 struct type *ftype; /* Function that returns above type */
4688 struct attribute *attr;
4690 /* Decode the type that this subroutine returns */
4695 type = die_type (die, cu);
4696 ftype = make_function_type (type, (struct type **) 0);
4698 /* All functions in C++ and Java have prototypes. */
4699 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4700 if ((attr && (DW_UNSND (attr) != 0))
4701 || cu->language == language_cplus
4702 || cu->language == language_java)
4703 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4705 if (die->child != NULL)
4707 struct die_info *child_die;
4711 /* Count the number of parameters.
4712 FIXME: GDB currently ignores vararg functions, but knows about
4713 vararg member functions. */
4714 child_die = die->child;
4715 while (child_die && child_die->tag)
4717 if (child_die->tag == DW_TAG_formal_parameter)
4719 else if (child_die->tag == DW_TAG_unspecified_parameters)
4720 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4721 child_die = sibling_die (child_die);
4724 /* Allocate storage for parameters and fill them in. */
4725 TYPE_NFIELDS (ftype) = nparams;
4726 TYPE_FIELDS (ftype) = (struct field *)
4727 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4729 child_die = die->child;
4730 while (child_die && child_die->tag)
4732 if (child_die->tag == DW_TAG_formal_parameter)
4734 /* Dwarf2 has no clean way to discern C++ static and non-static
4735 member functions. G++ helps GDB by marking the first
4736 parameter for non-static member functions (which is the
4737 this pointer) as artificial. We pass this information
4738 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4739 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4741 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4743 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4744 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4747 child_die = sibling_die (child_die);
4751 set_die_type (die, ftype, cu);
4755 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4757 struct objfile *objfile = cu->objfile;
4758 struct attribute *attr;
4763 attr = dwarf2_attr (die, DW_AT_name, cu);
4764 if (attr && DW_STRING (attr))
4766 name = DW_STRING (attr);
4768 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4769 TYPE_FLAG_TARGET_STUB, name, objfile),
4771 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4775 /* Find a representation of a given base type and install
4776 it in the TYPE field of the die. */
4779 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4781 struct objfile *objfile = cu->objfile;
4783 struct attribute *attr;
4784 int encoding = 0, size = 0;
4786 /* If we've already decoded this die, this is a no-op. */
4792 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4795 encoding = DW_UNSND (attr);
4797 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4800 size = DW_UNSND (attr);
4802 attr = dwarf2_attr (die, DW_AT_name, cu);
4803 if (attr && DW_STRING (attr))
4805 enum type_code code = TYPE_CODE_INT;
4810 case DW_ATE_address:
4811 /* Turn DW_ATE_address into a void * pointer. */
4812 code = TYPE_CODE_PTR;
4813 type_flags |= TYPE_FLAG_UNSIGNED;
4815 case DW_ATE_boolean:
4816 code = TYPE_CODE_BOOL;
4817 type_flags |= TYPE_FLAG_UNSIGNED;
4819 case DW_ATE_complex_float:
4820 code = TYPE_CODE_COMPLEX;
4823 code = TYPE_CODE_FLT;
4827 case DW_ATE_unsigned:
4828 type_flags |= TYPE_FLAG_UNSIGNED;
4830 case DW_ATE_signed_char:
4831 if (cu->language == language_m2)
4832 code = TYPE_CODE_CHAR;
4834 case DW_ATE_unsigned_char:
4835 if (cu->language == language_m2)
4836 code = TYPE_CODE_CHAR;
4837 type_flags |= TYPE_FLAG_UNSIGNED;
4840 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4841 dwarf_type_encoding_name (encoding));
4844 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4845 if (encoding == DW_ATE_address)
4846 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4848 else if (encoding == DW_ATE_complex_float)
4851 TYPE_TARGET_TYPE (type)
4852 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4853 else if (size == 16)
4854 TYPE_TARGET_TYPE (type)
4855 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4857 TYPE_TARGET_TYPE (type)
4858 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4863 type = dwarf_base_type (encoding, size, cu);
4865 set_die_type (die, type, cu);
4868 /* Read the given DW_AT_subrange DIE. */
4871 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4873 struct type *base_type;
4874 struct type *range_type;
4875 struct attribute *attr;
4879 /* If we have already decoded this die, then nothing more to do. */
4883 base_type = die_type (die, cu);
4884 if (base_type == NULL)
4886 complaint (&symfile_complaints,
4887 _("DW_AT_type missing from DW_TAG_subrange_type"));
4891 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4892 base_type = alloc_type (NULL);
4894 if (cu->language == language_fortran)
4896 /* FORTRAN implies a lower bound of 1, if not given. */
4900 /* FIXME: For variable sized arrays either of these could be
4901 a variable rather than a constant value. We'll allow it,
4902 but we don't know how to handle it. */
4903 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4905 low = dwarf2_get_attr_constant_value (attr, 0);
4907 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4910 if (attr->form == DW_FORM_block1)
4912 /* GCC encodes arrays with unspecified or dynamic length
4913 with a DW_FORM_block1 attribute.
4914 FIXME: GDB does not yet know how to handle dynamic
4915 arrays properly, treat them as arrays with unspecified
4918 FIXME: jimb/2003-09-22: GDB does not really know
4919 how to handle arrays of unspecified length
4920 either; we just represent them as zero-length
4921 arrays. Choose an appropriate upper bound given
4922 the lower bound we've computed above. */
4926 high = dwarf2_get_attr_constant_value (attr, 1);
4929 range_type = create_range_type (NULL, base_type, low, high);
4931 attr = dwarf2_attr (die, DW_AT_name, cu);
4932 if (attr && DW_STRING (attr))
4933 TYPE_NAME (range_type) = DW_STRING (attr);
4935 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4937 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4939 set_die_type (die, range_type, cu);
4943 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
4946 struct attribute *attr;
4951 /* For now, we only support the C meaning of an unspecified type: void. */
4953 attr = dwarf2_attr (die, DW_AT_name, cu);
4954 type = init_type (TYPE_CODE_VOID, 0, 0, attr ? DW_STRING (attr) : "",
4957 set_die_type (die, type, cu);
4960 /* Read a whole compilation unit into a linked list of dies. */
4962 static struct die_info *
4963 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4965 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4968 /* Read a single die and all its descendents. Set the die's sibling
4969 field to NULL; set other fields in the die correctly, and set all
4970 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4971 location of the info_ptr after reading all of those dies. PARENT
4972 is the parent of the die in question. */
4974 static struct die_info *
4975 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
4976 struct dwarf2_cu *cu,
4977 gdb_byte **new_info_ptr,
4978 struct die_info *parent)
4980 struct die_info *die;
4984 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4985 store_in_ref_table (die->offset, die, cu);
4989 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4995 *new_info_ptr = cur_ptr;
4998 die->sibling = NULL;
4999 die->parent = parent;
5003 /* Read a die, all of its descendents, and all of its siblings; set
5004 all of the fields of all of the dies correctly. Arguments are as
5005 in read_die_and_children. */
5007 static struct die_info *
5008 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
5009 struct dwarf2_cu *cu,
5010 gdb_byte **new_info_ptr,
5011 struct die_info *parent)
5013 struct die_info *first_die, *last_sibling;
5017 first_die = last_sibling = NULL;
5021 struct die_info *die
5022 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
5030 last_sibling->sibling = die;
5035 *new_info_ptr = cur_ptr;
5045 /* Free a linked list of dies. */
5048 free_die_list (struct die_info *dies)
5050 struct die_info *die, *next;
5055 if (die->child != NULL)
5056 free_die_list (die->child);
5057 next = die->sibling;
5064 /* Read the contents of the section at OFFSET and of size SIZE from the
5065 object file specified by OBJFILE into the objfile_obstack and return it. */
5068 dwarf2_read_section (struct objfile *objfile, asection *sectp)
5070 bfd *abfd = objfile->obfd;
5071 gdb_byte *buf, *retbuf;
5072 bfd_size_type size = bfd_get_section_size (sectp);
5077 buf = obstack_alloc (&objfile->objfile_obstack, size);
5078 retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
5082 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
5083 || bfd_bread (buf, size, abfd) != size)
5084 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5085 bfd_get_filename (abfd));
5090 /* In DWARF version 2, the description of the debugging information is
5091 stored in a separate .debug_abbrev section. Before we read any
5092 dies from a section we read in all abbreviations and install them
5093 in a hash table. This function also sets flags in CU describing
5094 the data found in the abbrev table. */
5097 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
5099 struct comp_unit_head *cu_header = &cu->header;
5100 gdb_byte *abbrev_ptr;
5101 struct abbrev_info *cur_abbrev;
5102 unsigned int abbrev_number, bytes_read, abbrev_name;
5103 unsigned int abbrev_form, hash_number;
5104 struct attr_abbrev *cur_attrs;
5105 unsigned int allocated_attrs;
5107 /* Initialize dwarf2 abbrevs */
5108 obstack_init (&cu->abbrev_obstack);
5109 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
5111 * sizeof (struct abbrev_info *)));
5112 memset (cu->dwarf2_abbrevs, 0,
5113 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
5115 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
5116 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5117 abbrev_ptr += bytes_read;
5119 allocated_attrs = ATTR_ALLOC_CHUNK;
5120 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
5122 /* loop until we reach an abbrev number of 0 */
5123 while (abbrev_number)
5125 cur_abbrev = dwarf_alloc_abbrev (cu);
5127 /* read in abbrev header */
5128 cur_abbrev->number = abbrev_number;
5129 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5130 abbrev_ptr += bytes_read;
5131 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5134 if (cur_abbrev->tag == DW_TAG_namespace)
5135 cu->has_namespace_info = 1;
5137 /* now read in declarations */
5138 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5139 abbrev_ptr += bytes_read;
5140 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5141 abbrev_ptr += bytes_read;
5144 if (cur_abbrev->num_attrs == allocated_attrs)
5146 allocated_attrs += ATTR_ALLOC_CHUNK;
5148 = xrealloc (cur_attrs, (allocated_attrs
5149 * sizeof (struct attr_abbrev)));
5152 /* Record whether this compilation unit might have
5153 inter-compilation-unit references. If we don't know what form
5154 this attribute will have, then it might potentially be a
5155 DW_FORM_ref_addr, so we conservatively expect inter-CU
5158 if (abbrev_form == DW_FORM_ref_addr
5159 || abbrev_form == DW_FORM_indirect)
5160 cu->has_form_ref_addr = 1;
5162 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5163 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5164 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5165 abbrev_ptr += bytes_read;
5166 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5167 abbrev_ptr += bytes_read;
5170 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5171 (cur_abbrev->num_attrs
5172 * sizeof (struct attr_abbrev)));
5173 memcpy (cur_abbrev->attrs, cur_attrs,
5174 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5176 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5177 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5178 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5180 /* Get next abbreviation.
5181 Under Irix6 the abbreviations for a compilation unit are not
5182 always properly terminated with an abbrev number of 0.
5183 Exit loop if we encounter an abbreviation which we have
5184 already read (which means we are about to read the abbreviations
5185 for the next compile unit) or if the end of the abbreviation
5186 table is reached. */
5187 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5188 >= dwarf2_per_objfile->abbrev_size)
5190 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5191 abbrev_ptr += bytes_read;
5192 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5199 /* Release the memory used by the abbrev table for a compilation unit. */
5202 dwarf2_free_abbrev_table (void *ptr_to_cu)
5204 struct dwarf2_cu *cu = ptr_to_cu;
5206 obstack_free (&cu->abbrev_obstack, NULL);
5207 cu->dwarf2_abbrevs = NULL;
5210 /* Lookup an abbrev_info structure in the abbrev hash table. */
5212 static struct abbrev_info *
5213 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5215 unsigned int hash_number;
5216 struct abbrev_info *abbrev;
5218 hash_number = number % ABBREV_HASH_SIZE;
5219 abbrev = cu->dwarf2_abbrevs[hash_number];
5223 if (abbrev->number == number)
5226 abbrev = abbrev->next;
5231 /* Returns nonzero if TAG represents a type that we might generate a partial
5235 is_type_tag_for_partial (int tag)
5240 /* Some types that would be reasonable to generate partial symbols for,
5241 that we don't at present. */
5242 case DW_TAG_array_type:
5243 case DW_TAG_file_type:
5244 case DW_TAG_ptr_to_member_type:
5245 case DW_TAG_set_type:
5246 case DW_TAG_string_type:
5247 case DW_TAG_subroutine_type:
5249 case DW_TAG_base_type:
5250 case DW_TAG_class_type:
5251 case DW_TAG_enumeration_type:
5252 case DW_TAG_structure_type:
5253 case DW_TAG_subrange_type:
5254 case DW_TAG_typedef:
5255 case DW_TAG_union_type:
5262 /* Load all DIEs that are interesting for partial symbols into memory. */
5264 static struct partial_die_info *
5265 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5266 struct dwarf2_cu *cu)
5268 struct partial_die_info *part_die;
5269 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5270 struct abbrev_info *abbrev;
5271 unsigned int bytes_read;
5272 unsigned int load_all = 0;
5274 int nesting_level = 1;
5279 if (cu->per_cu && cu->per_cu->load_all_dies)
5283 = htab_create_alloc_ex (cu->header.length / 12,
5287 &cu->comp_unit_obstack,
5288 hashtab_obstack_allocate,
5289 dummy_obstack_deallocate);
5291 part_die = obstack_alloc (&cu->comp_unit_obstack,
5292 sizeof (struct partial_die_info));
5296 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5298 /* A NULL abbrev means the end of a series of children. */
5301 if (--nesting_level == 0)
5303 /* PART_DIE was probably the last thing allocated on the
5304 comp_unit_obstack, so we could call obstack_free
5305 here. We don't do that because the waste is small,
5306 and will be cleaned up when we're done with this
5307 compilation unit. This way, we're also more robust
5308 against other users of the comp_unit_obstack. */
5311 info_ptr += bytes_read;
5312 last_die = parent_die;
5313 parent_die = parent_die->die_parent;
5317 /* Check whether this DIE is interesting enough to save. Normally
5318 we would not be interested in members here, but there may be
5319 later variables referencing them via DW_AT_specification (for
5322 && !is_type_tag_for_partial (abbrev->tag)
5323 && abbrev->tag != DW_TAG_enumerator
5324 && abbrev->tag != DW_TAG_subprogram
5325 && abbrev->tag != DW_TAG_variable
5326 && abbrev->tag != DW_TAG_namespace
5327 && abbrev->tag != DW_TAG_member)
5329 /* Otherwise we skip to the next sibling, if any. */
5330 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5334 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5335 abfd, info_ptr, cu);
5337 /* This two-pass algorithm for processing partial symbols has a
5338 high cost in cache pressure. Thus, handle some simple cases
5339 here which cover the majority of C partial symbols. DIEs
5340 which neither have specification tags in them, nor could have
5341 specification tags elsewhere pointing at them, can simply be
5342 processed and discarded.
5344 This segment is also optional; scan_partial_symbols and
5345 add_partial_symbol will handle these DIEs if we chain
5346 them in normally. When compilers which do not emit large
5347 quantities of duplicate debug information are more common,
5348 this code can probably be removed. */
5350 /* Any complete simple types at the top level (pretty much all
5351 of them, for a language without namespaces), can be processed
5353 if (parent_die == NULL
5354 && part_die->has_specification == 0
5355 && part_die->is_declaration == 0
5356 && (part_die->tag == DW_TAG_typedef
5357 || part_die->tag == DW_TAG_base_type
5358 || part_die->tag == DW_TAG_subrange_type))
5360 if (building_psymtab && part_die->name != NULL)
5361 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5362 VAR_DOMAIN, LOC_TYPEDEF,
5363 &cu->objfile->static_psymbols,
5364 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5365 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5369 /* If we're at the second level, and we're an enumerator, and
5370 our parent has no specification (meaning possibly lives in a
5371 namespace elsewhere), then we can add the partial symbol now
5372 instead of queueing it. */
5373 if (part_die->tag == DW_TAG_enumerator
5374 && parent_die != NULL
5375 && parent_die->die_parent == NULL
5376 && parent_die->tag == DW_TAG_enumeration_type
5377 && parent_die->has_specification == 0)
5379 if (part_die->name == NULL)
5380 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5381 else if (building_psymtab)
5382 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5383 VAR_DOMAIN, LOC_CONST,
5384 (cu->language == language_cplus
5385 || cu->language == language_java)
5386 ? &cu->objfile->global_psymbols
5387 : &cu->objfile->static_psymbols,
5388 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5390 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5394 /* We'll save this DIE so link it in. */
5395 part_die->die_parent = parent_die;
5396 part_die->die_sibling = NULL;
5397 part_die->die_child = NULL;
5399 if (last_die && last_die == parent_die)
5400 last_die->die_child = part_die;
5402 last_die->die_sibling = part_die;
5404 last_die = part_die;
5406 if (first_die == NULL)
5407 first_die = part_die;
5409 /* Maybe add the DIE to the hash table. Not all DIEs that we
5410 find interesting need to be in the hash table, because we
5411 also have the parent/sibling/child chains; only those that we
5412 might refer to by offset later during partial symbol reading.
5414 For now this means things that might have be the target of a
5415 DW_AT_specification, DW_AT_abstract_origin, or
5416 DW_AT_extension. DW_AT_extension will refer only to
5417 namespaces; DW_AT_abstract_origin refers to functions (and
5418 many things under the function DIE, but we do not recurse
5419 into function DIEs during partial symbol reading) and
5420 possibly variables as well; DW_AT_specification refers to
5421 declarations. Declarations ought to have the DW_AT_declaration
5422 flag. It happens that GCC forgets to put it in sometimes, but
5423 only for functions, not for types.
5425 Adding more things than necessary to the hash table is harmless
5426 except for the performance cost. Adding too few will result in
5427 wasted time in find_partial_die, when we reread the compilation
5428 unit with load_all_dies set. */
5431 || abbrev->tag == DW_TAG_subprogram
5432 || abbrev->tag == DW_TAG_variable
5433 || abbrev->tag == DW_TAG_namespace
5434 || part_die->is_declaration)
5438 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5439 part_die->offset, INSERT);
5443 part_die = obstack_alloc (&cu->comp_unit_obstack,
5444 sizeof (struct partial_die_info));
5446 /* For some DIEs we want to follow their children (if any). For C
5447 we have no reason to follow the children of structures; for other
5448 languages we have to, both so that we can get at method physnames
5449 to infer fully qualified class names, and for DW_AT_specification. */
5450 if (last_die->has_children
5452 || last_die->tag == DW_TAG_namespace
5453 || last_die->tag == DW_TAG_enumeration_type
5454 || (cu->language != language_c
5455 && (last_die->tag == DW_TAG_class_type
5456 || last_die->tag == DW_TAG_structure_type
5457 || last_die->tag == DW_TAG_union_type))))
5460 parent_die = last_die;
5464 /* Otherwise we skip to the next sibling, if any. */
5465 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5467 /* Back to the top, do it again. */
5471 /* Read a minimal amount of information into the minimal die structure. */
5474 read_partial_die (struct partial_die_info *part_die,
5475 struct abbrev_info *abbrev,
5476 unsigned int abbrev_len, bfd *abfd,
5477 gdb_byte *info_ptr, struct dwarf2_cu *cu)
5479 unsigned int bytes_read, i;
5480 struct attribute attr;
5481 int has_low_pc_attr = 0;
5482 int has_high_pc_attr = 0;
5484 memset (part_die, 0, sizeof (struct partial_die_info));
5486 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5488 info_ptr += abbrev_len;
5493 part_die->tag = abbrev->tag;
5494 part_die->has_children = abbrev->has_children;
5496 for (i = 0; i < abbrev->num_attrs; ++i)
5498 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5500 /* Store the data if it is of an attribute we want to keep in a
5501 partial symbol table. */
5506 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5507 if (part_die->name == NULL)
5508 part_die->name = DW_STRING (&attr);
5510 case DW_AT_comp_dir:
5511 if (part_die->dirname == NULL)
5512 part_die->dirname = DW_STRING (&attr);
5514 case DW_AT_MIPS_linkage_name:
5515 part_die->name = DW_STRING (&attr);
5518 has_low_pc_attr = 1;
5519 part_die->lowpc = DW_ADDR (&attr);
5522 has_high_pc_attr = 1;
5523 part_die->highpc = DW_ADDR (&attr);
5525 case DW_AT_location:
5526 /* Support the .debug_loc offsets */
5527 if (attr_form_is_block (&attr))
5529 part_die->locdesc = DW_BLOCK (&attr);
5531 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5533 dwarf2_complex_location_expr_complaint ();
5537 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5538 "partial symbol information");
5541 case DW_AT_language:
5542 part_die->language = DW_UNSND (&attr);
5544 case DW_AT_external:
5545 part_die->is_external = DW_UNSND (&attr);
5547 case DW_AT_declaration:
5548 part_die->is_declaration = DW_UNSND (&attr);
5551 part_die->has_type = 1;
5553 case DW_AT_abstract_origin:
5554 case DW_AT_specification:
5555 case DW_AT_extension:
5556 part_die->has_specification = 1;
5557 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5560 /* Ignore absolute siblings, they might point outside of
5561 the current compile unit. */
5562 if (attr.form == DW_FORM_ref_addr)
5563 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5565 part_die->sibling = dwarf2_per_objfile->info_buffer
5566 + dwarf2_get_ref_die_offset (&attr, cu);
5568 case DW_AT_stmt_list:
5569 part_die->has_stmt_list = 1;
5570 part_die->line_offset = DW_UNSND (&attr);
5577 /* When using the GNU linker, .gnu.linkonce. sections are used to
5578 eliminate duplicate copies of functions and vtables and such.
5579 The linker will arbitrarily choose one and discard the others.
5580 The AT_*_pc values for such functions refer to local labels in
5581 these sections. If the section from that file was discarded, the
5582 labels are not in the output, so the relocs get a value of 0.
5583 If this is a discarded function, mark the pc bounds as invalid,
5584 so that GDB will ignore it. */
5585 if (has_low_pc_attr && has_high_pc_attr
5586 && part_die->lowpc < part_die->highpc
5587 && (part_die->lowpc != 0
5588 || dwarf2_per_objfile->has_section_at_zero))
5589 part_die->has_pc_info = 1;
5593 /* Find a cached partial DIE at OFFSET in CU. */
5595 static struct partial_die_info *
5596 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5598 struct partial_die_info *lookup_die = NULL;
5599 struct partial_die_info part_die;
5601 part_die.offset = offset;
5602 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5607 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5609 static struct partial_die_info *
5610 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5612 struct dwarf2_per_cu_data *per_cu = NULL;
5613 struct partial_die_info *pd = NULL;
5615 if (offset >= cu->header.offset
5616 && offset < cu->header.offset + cu->header.length)
5618 pd = find_partial_die_in_comp_unit (offset, cu);
5623 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5625 if (per_cu->cu == NULL)
5627 load_comp_unit (per_cu, cu->objfile);
5628 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5629 dwarf2_per_objfile->read_in_chain = per_cu;
5632 per_cu->cu->last_used = 0;
5633 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5635 if (pd == NULL && per_cu->load_all_dies == 0)
5637 struct cleanup *back_to;
5638 struct partial_die_info comp_unit_die;
5639 struct abbrev_info *abbrev;
5640 unsigned int bytes_read;
5643 per_cu->load_all_dies = 1;
5645 /* Re-read the DIEs. */
5646 back_to = make_cleanup (null_cleanup, 0);
5647 if (per_cu->cu->dwarf2_abbrevs == NULL)
5649 dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
5650 back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
5652 info_ptr = per_cu->cu->header.first_die_ptr;
5653 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
5654 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
5655 per_cu->cu->objfile->obfd, info_ptr,
5657 if (comp_unit_die.has_children)
5658 load_partial_dies (per_cu->cu->objfile->obfd, info_ptr, 0, per_cu->cu);
5659 do_cleanups (back_to);
5661 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5665 internal_error (__FILE__, __LINE__,
5666 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5667 offset, bfd_get_filename (cu->objfile->obfd));
5671 /* Adjust PART_DIE before generating a symbol for it. This function
5672 may set the is_external flag or change the DIE's name. */
5675 fixup_partial_die (struct partial_die_info *part_die,
5676 struct dwarf2_cu *cu)
5678 /* If we found a reference attribute and the DIE has no name, try
5679 to find a name in the referred to DIE. */
5681 if (part_die->name == NULL && part_die->has_specification)
5683 struct partial_die_info *spec_die;
5685 spec_die = find_partial_die (part_die->spec_offset, cu);
5687 fixup_partial_die (spec_die, cu);
5691 part_die->name = spec_die->name;
5693 /* Copy DW_AT_external attribute if it is set. */
5694 if (spec_die->is_external)
5695 part_die->is_external = spec_die->is_external;
5699 /* Set default names for some unnamed DIEs. */
5700 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5701 || part_die->tag == DW_TAG_class_type))
5702 part_die->name = "(anonymous class)";
5704 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5705 part_die->name = "(anonymous namespace)";
5707 if (part_die->tag == DW_TAG_structure_type
5708 || part_die->tag == DW_TAG_class_type
5709 || part_die->tag == DW_TAG_union_type)
5710 guess_structure_name (part_die, cu);
5713 /* Read the die from the .debug_info section buffer. Set DIEP to
5714 point to a newly allocated die with its information, except for its
5715 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5716 whether the die has children or not. */
5719 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5720 struct dwarf2_cu *cu, int *has_children)
5722 unsigned int abbrev_number, bytes_read, i, offset;
5723 struct abbrev_info *abbrev;
5724 struct die_info *die;
5726 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5727 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5728 info_ptr += bytes_read;
5731 die = dwarf_alloc_die ();
5733 die->abbrev = abbrev_number;
5740 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5743 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5745 bfd_get_filename (abfd));
5747 die = dwarf_alloc_die ();
5748 die->offset = offset;
5749 die->tag = abbrev->tag;
5750 die->abbrev = abbrev_number;
5753 die->num_attrs = abbrev->num_attrs;
5754 die->attrs = (struct attribute *)
5755 xmalloc (die->num_attrs * sizeof (struct attribute));
5757 for (i = 0; i < abbrev->num_attrs; ++i)
5759 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5760 abfd, info_ptr, cu);
5762 /* If this attribute is an absolute reference to a different
5763 compilation unit, make sure that compilation unit is loaded
5765 if (die->attrs[i].form == DW_FORM_ref_addr
5766 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5767 || (DW_ADDR (&die->attrs[i])
5768 >= cu->header.offset + cu->header.length)))
5770 struct dwarf2_per_cu_data *per_cu;
5771 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5774 /* Mark the dependence relation so that we don't flush PER_CU
5776 dwarf2_add_dependence (cu, per_cu);
5778 /* If it's already on the queue, we have nothing to do. */
5782 /* If the compilation unit is already loaded, just mark it as
5784 if (per_cu->cu != NULL)
5786 per_cu->cu->last_used = 0;
5790 /* Add it to the queue. */
5791 queue_comp_unit (per_cu);
5796 *has_children = abbrev->has_children;
5800 /* Read an attribute value described by an attribute form. */
5803 read_attribute_value (struct attribute *attr, unsigned form,
5804 bfd *abfd, gdb_byte *info_ptr,
5805 struct dwarf2_cu *cu)
5807 struct comp_unit_head *cu_header = &cu->header;
5808 unsigned int bytes_read;
5809 struct dwarf_block *blk;
5815 case DW_FORM_ref_addr:
5816 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5817 info_ptr += bytes_read;
5819 case DW_FORM_block2:
5820 blk = dwarf_alloc_block (cu);
5821 blk->size = read_2_bytes (abfd, info_ptr);
5823 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5824 info_ptr += blk->size;
5825 DW_BLOCK (attr) = blk;
5827 case DW_FORM_block4:
5828 blk = dwarf_alloc_block (cu);
5829 blk->size = read_4_bytes (abfd, info_ptr);
5831 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5832 info_ptr += blk->size;
5833 DW_BLOCK (attr) = blk;
5836 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5840 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5844 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5847 case DW_FORM_string:
5848 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5849 info_ptr += bytes_read;
5852 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5854 info_ptr += bytes_read;
5857 blk = dwarf_alloc_block (cu);
5858 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5859 info_ptr += bytes_read;
5860 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5861 info_ptr += blk->size;
5862 DW_BLOCK (attr) = blk;
5864 case DW_FORM_block1:
5865 blk = dwarf_alloc_block (cu);
5866 blk->size = read_1_byte (abfd, info_ptr);
5868 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5869 info_ptr += blk->size;
5870 DW_BLOCK (attr) = blk;
5873 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5877 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5881 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5882 info_ptr += bytes_read;
5885 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5886 info_ptr += bytes_read;
5889 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5893 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5897 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5901 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5904 case DW_FORM_ref_udata:
5905 DW_ADDR (attr) = (cu->header.offset
5906 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5907 info_ptr += bytes_read;
5909 case DW_FORM_indirect:
5910 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5911 info_ptr += bytes_read;
5912 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5915 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5916 dwarf_form_name (form),
5917 bfd_get_filename (abfd));
5922 /* Read an attribute described by an abbreviated attribute. */
5925 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5926 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
5928 attr->name = abbrev->name;
5929 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5932 /* read dwarf information from a buffer */
5935 read_1_byte (bfd *abfd, gdb_byte *buf)
5937 return bfd_get_8 (abfd, buf);
5941 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
5943 return bfd_get_signed_8 (abfd, buf);
5947 read_2_bytes (bfd *abfd, gdb_byte *buf)
5949 return bfd_get_16 (abfd, buf);
5953 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
5955 return bfd_get_signed_16 (abfd, buf);
5959 read_4_bytes (bfd *abfd, gdb_byte *buf)
5961 return bfd_get_32 (abfd, buf);
5965 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
5967 return bfd_get_signed_32 (abfd, buf);
5970 static unsigned long
5971 read_8_bytes (bfd *abfd, gdb_byte *buf)
5973 return bfd_get_64 (abfd, buf);
5977 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
5978 unsigned int *bytes_read)
5980 struct comp_unit_head *cu_header = &cu->header;
5981 CORE_ADDR retval = 0;
5983 if (cu_header->signed_addr_p)
5985 switch (cu_header->addr_size)
5988 retval = bfd_get_signed_16 (abfd, buf);
5991 retval = bfd_get_signed_32 (abfd, buf);
5994 retval = bfd_get_signed_64 (abfd, buf);
5997 internal_error (__FILE__, __LINE__,
5998 _("read_address: bad switch, signed [in module %s]"),
5999 bfd_get_filename (abfd));
6004 switch (cu_header->addr_size)
6007 retval = bfd_get_16 (abfd, buf);
6010 retval = bfd_get_32 (abfd, buf);
6013 retval = bfd_get_64 (abfd, buf);
6016 internal_error (__FILE__, __LINE__,
6017 _("read_address: bad switch, unsigned [in module %s]"),
6018 bfd_get_filename (abfd));
6022 *bytes_read = cu_header->addr_size;
6026 /* Read the initial length from a section. The (draft) DWARF 3
6027 specification allows the initial length to take up either 4 bytes
6028 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6029 bytes describe the length and all offsets will be 8 bytes in length
6032 An older, non-standard 64-bit format is also handled by this
6033 function. The older format in question stores the initial length
6034 as an 8-byte quantity without an escape value. Lengths greater
6035 than 2^32 aren't very common which means that the initial 4 bytes
6036 is almost always zero. Since a length value of zero doesn't make
6037 sense for the 32-bit format, this initial zero can be considered to
6038 be an escape value which indicates the presence of the older 64-bit
6039 format. As written, the code can't detect (old format) lengths
6040 greater than 4GB. If it becomes necessary to handle lengths
6041 somewhat larger than 4GB, we could allow other small values (such
6042 as the non-sensical values of 1, 2, and 3) to also be used as
6043 escape values indicating the presence of the old format.
6045 The value returned via bytes_read should be used to increment the
6046 relevant pointer after calling read_initial_length().
6048 As a side effect, this function sets the fields initial_length_size
6049 and offset_size in cu_header to the values appropriate for the
6050 length field. (The format of the initial length field determines
6051 the width of file offsets to be fetched later with read_offset().)
6053 [ Note: read_initial_length() and read_offset() are based on the
6054 document entitled "DWARF Debugging Information Format", revision
6055 3, draft 8, dated November 19, 2001. This document was obtained
6058 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6060 This document is only a draft and is subject to change. (So beware.)
6062 Details regarding the older, non-standard 64-bit format were
6063 determined empirically by examining 64-bit ELF files produced by
6064 the SGI toolchain on an IRIX 6.5 machine.
6066 - Kevin, July 16, 2002
6070 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
6071 unsigned int *bytes_read)
6073 LONGEST length = bfd_get_32 (abfd, buf);
6075 if (length == 0xffffffff)
6077 length = bfd_get_64 (abfd, buf + 4);
6080 else if (length == 0)
6082 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6083 length = bfd_get_64 (abfd, buf);
6093 gdb_assert (cu_header->initial_length_size == 0
6094 || cu_header->initial_length_size == 4
6095 || cu_header->initial_length_size == 8
6096 || cu_header->initial_length_size == 12);
6098 if (cu_header->initial_length_size != 0
6099 && cu_header->initial_length_size != *bytes_read)
6100 complaint (&symfile_complaints,
6101 _("intermixed 32-bit and 64-bit DWARF sections"));
6103 cu_header->initial_length_size = *bytes_read;
6104 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
6110 /* Read an offset from the data stream. The size of the offset is
6111 given by cu_header->offset_size. */
6114 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
6115 unsigned int *bytes_read)
6119 switch (cu_header->offset_size)
6122 retval = bfd_get_32 (abfd, buf);
6126 retval = bfd_get_64 (abfd, buf);
6130 internal_error (__FILE__, __LINE__,
6131 _("read_offset: bad switch [in module %s]"),
6132 bfd_get_filename (abfd));
6139 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
6141 /* If the size of a host char is 8 bits, we can return a pointer
6142 to the buffer, otherwise we have to copy the data to a buffer
6143 allocated on the temporary obstack. */
6144 gdb_assert (HOST_CHAR_BIT == 8);
6149 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6151 /* If the size of a host char is 8 bits, we can return a pointer
6152 to the string, otherwise we have to copy the string to a buffer
6153 allocated on the temporary obstack. */
6154 gdb_assert (HOST_CHAR_BIT == 8);
6157 *bytes_read_ptr = 1;
6160 *bytes_read_ptr = strlen ((char *) buf) + 1;
6161 return (char *) buf;
6165 read_indirect_string (bfd *abfd, gdb_byte *buf,
6166 const struct comp_unit_head *cu_header,
6167 unsigned int *bytes_read_ptr)
6169 LONGEST str_offset = read_offset (abfd, buf, cu_header,
6172 if (dwarf2_per_objfile->str_buffer == NULL)
6174 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6175 bfd_get_filename (abfd));
6178 if (str_offset >= dwarf2_per_objfile->str_size)
6180 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6181 bfd_get_filename (abfd));
6184 gdb_assert (HOST_CHAR_BIT == 8);
6185 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6187 return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6190 static unsigned long
6191 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6193 unsigned long result;
6194 unsigned int num_read;
6204 byte = bfd_get_8 (abfd, buf);
6207 result |= ((unsigned long)(byte & 127) << shift);
6208 if ((byte & 128) == 0)
6214 *bytes_read_ptr = num_read;
6219 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6222 int i, shift, num_read;
6231 byte = bfd_get_8 (abfd, buf);
6234 result |= ((long)(byte & 127) << shift);
6236 if ((byte & 128) == 0)
6241 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6242 result |= -(((long)1) << shift);
6243 *bytes_read_ptr = num_read;
6247 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6250 skip_leb128 (bfd *abfd, gdb_byte *buf)
6256 byte = bfd_get_8 (abfd, buf);
6258 if ((byte & 128) == 0)
6264 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6270 cu->language = language_c;
6272 case DW_LANG_C_plus_plus:
6273 cu->language = language_cplus;
6275 case DW_LANG_Fortran77:
6276 case DW_LANG_Fortran90:
6277 case DW_LANG_Fortran95:
6278 cu->language = language_fortran;
6280 case DW_LANG_Mips_Assembler:
6281 cu->language = language_asm;
6284 cu->language = language_java;
6288 cu->language = language_ada;
6290 case DW_LANG_Modula2:
6291 cu->language = language_m2;
6293 case DW_LANG_Cobol74:
6294 case DW_LANG_Cobol85:
6295 case DW_LANG_Pascal83:
6297 cu->language = language_minimal;
6300 cu->language_defn = language_def (cu->language);
6303 /* Return the named attribute or NULL if not there. */
6305 static struct attribute *
6306 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6309 struct attribute *spec = NULL;
6311 for (i = 0; i < die->num_attrs; ++i)
6313 if (die->attrs[i].name == name)
6314 return &die->attrs[i];
6315 if (die->attrs[i].name == DW_AT_specification
6316 || die->attrs[i].name == DW_AT_abstract_origin)
6317 spec = &die->attrs[i];
6321 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6326 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6327 and holds a non-zero value. This function should only be used for
6328 DW_FORM_flag attributes. */
6331 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6333 struct attribute *attr = dwarf2_attr (die, name, cu);
6335 return (attr && DW_UNSND (attr));
6339 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6341 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6342 which value is non-zero. However, we have to be careful with
6343 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6344 (via dwarf2_flag_true_p) follows this attribute. So we may
6345 end up accidently finding a declaration attribute that belongs
6346 to a different DIE referenced by the specification attribute,
6347 even though the given DIE does not have a declaration attribute. */
6348 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6349 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6352 /* Return the die giving the specification for DIE, if there is
6355 static struct die_info *
6356 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6358 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6360 if (spec_attr == NULL)
6363 return follow_die_ref (die, spec_attr, cu);
6366 /* Free the line_header structure *LH, and any arrays and strings it
6369 free_line_header (struct line_header *lh)
6371 if (lh->standard_opcode_lengths)
6372 xfree (lh->standard_opcode_lengths);
6374 /* Remember that all the lh->file_names[i].name pointers are
6375 pointers into debug_line_buffer, and don't need to be freed. */
6377 xfree (lh->file_names);
6379 /* Similarly for the include directory names. */
6380 if (lh->include_dirs)
6381 xfree (lh->include_dirs);
6387 /* Add an entry to LH's include directory table. */
6389 add_include_dir (struct line_header *lh, char *include_dir)
6391 /* Grow the array if necessary. */
6392 if (lh->include_dirs_size == 0)
6394 lh->include_dirs_size = 1; /* for testing */
6395 lh->include_dirs = xmalloc (lh->include_dirs_size
6396 * sizeof (*lh->include_dirs));
6398 else if (lh->num_include_dirs >= lh->include_dirs_size)
6400 lh->include_dirs_size *= 2;
6401 lh->include_dirs = xrealloc (lh->include_dirs,
6402 (lh->include_dirs_size
6403 * sizeof (*lh->include_dirs)));
6406 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6410 /* Add an entry to LH's file name table. */
6412 add_file_name (struct line_header *lh,
6414 unsigned int dir_index,
6415 unsigned int mod_time,
6416 unsigned int length)
6418 struct file_entry *fe;
6420 /* Grow the array if necessary. */
6421 if (lh->file_names_size == 0)
6423 lh->file_names_size = 1; /* for testing */
6424 lh->file_names = xmalloc (lh->file_names_size
6425 * sizeof (*lh->file_names));
6427 else if (lh->num_file_names >= lh->file_names_size)
6429 lh->file_names_size *= 2;
6430 lh->file_names = xrealloc (lh->file_names,
6431 (lh->file_names_size
6432 * sizeof (*lh->file_names)));
6435 fe = &lh->file_names[lh->num_file_names++];
6437 fe->dir_index = dir_index;
6438 fe->mod_time = mod_time;
6439 fe->length = length;
6444 /* Read the statement program header starting at OFFSET in
6445 .debug_line, according to the endianness of ABFD. Return a pointer
6446 to a struct line_header, allocated using xmalloc.
6448 NOTE: the strings in the include directory and file name tables of
6449 the returned object point into debug_line_buffer, and must not be
6451 static struct line_header *
6452 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6453 struct dwarf2_cu *cu)
6455 struct cleanup *back_to;
6456 struct line_header *lh;
6458 unsigned int bytes_read;
6460 char *cur_dir, *cur_file;
6462 if (dwarf2_per_objfile->line_buffer == NULL)
6464 complaint (&symfile_complaints, _("missing .debug_line section"));
6468 /* Make sure that at least there's room for the total_length field.
6469 That could be 12 bytes long, but we're just going to fudge that. */
6470 if (offset + 4 >= dwarf2_per_objfile->line_size)
6472 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6476 lh = xmalloc (sizeof (*lh));
6477 memset (lh, 0, sizeof (*lh));
6478 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6481 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6483 /* Read in the header. */
6485 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6486 line_ptr += bytes_read;
6487 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6488 + dwarf2_per_objfile->line_size))
6490 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6493 lh->statement_program_end = line_ptr + lh->total_length;
6494 lh->version = read_2_bytes (abfd, line_ptr);
6496 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6497 line_ptr += bytes_read;
6498 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6500 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6502 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6504 lh->line_range = read_1_byte (abfd, line_ptr);
6506 lh->opcode_base = read_1_byte (abfd, line_ptr);
6508 lh->standard_opcode_lengths
6509 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6511 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6512 for (i = 1; i < lh->opcode_base; ++i)
6514 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6518 /* Read directory table. */
6519 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6521 line_ptr += bytes_read;
6522 add_include_dir (lh, cur_dir);
6524 line_ptr += bytes_read;
6526 /* Read file name table. */
6527 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6529 unsigned int dir_index, mod_time, length;
6531 line_ptr += bytes_read;
6532 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6533 line_ptr += bytes_read;
6534 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6535 line_ptr += bytes_read;
6536 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6537 line_ptr += bytes_read;
6539 add_file_name (lh, cur_file, dir_index, mod_time, length);
6541 line_ptr += bytes_read;
6542 lh->statement_program_start = line_ptr;
6544 if (line_ptr > (dwarf2_per_objfile->line_buffer
6545 + dwarf2_per_objfile->line_size))
6546 complaint (&symfile_complaints,
6547 _("line number info header doesn't fit in `.debug_line' section"));
6549 discard_cleanups (back_to);
6553 /* This function exists to work around a bug in certain compilers
6554 (particularly GCC 2.95), in which the first line number marker of a
6555 function does not show up until after the prologue, right before
6556 the second line number marker. This function shifts ADDRESS down
6557 to the beginning of the function if necessary, and is called on
6558 addresses passed to record_line. */
6561 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6563 struct function_range *fn;
6565 /* Find the function_range containing address. */
6570 cu->cached_fn = cu->first_fn;
6574 if (fn->lowpc <= address && fn->highpc > address)
6580 while (fn && fn != cu->cached_fn)
6581 if (fn->lowpc <= address && fn->highpc > address)
6591 if (address != fn->lowpc)
6592 complaint (&symfile_complaints,
6593 _("misplaced first line number at 0x%lx for '%s'"),
6594 (unsigned long) address, fn->name);
6599 /* Decode the Line Number Program (LNP) for the given line_header
6600 structure and CU. The actual information extracted and the type
6601 of structures created from the LNP depends on the value of PST.
6603 1. If PST is NULL, then this procedure uses the data from the program
6604 to create all necessary symbol tables, and their linetables.
6605 The compilation directory of the file is passed in COMP_DIR,
6606 and must not be NULL.
6608 2. If PST is not NULL, this procedure reads the program to determine
6609 the list of files included by the unit represented by PST, and
6610 builds all the associated partial symbol tables. In this case,
6611 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6612 is not used to compute the full name of the symtab, and therefore
6613 omitting it when building the partial symtab does not introduce
6614 the potential for inconsistency - a partial symtab and its associated
6615 symbtab having a different fullname -). */
6618 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6619 struct dwarf2_cu *cu, struct partial_symtab *pst)
6623 unsigned int bytes_read;
6624 unsigned char op_code, extended_op, adj_opcode;
6626 struct objfile *objfile = cu->objfile;
6627 const int decode_for_pst_p = (pst != NULL);
6628 struct subfile *last_subfile = NULL;
6630 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6632 line_ptr = lh->statement_program_start;
6633 line_end = lh->statement_program_end;
6635 /* Read the statement sequences until there's nothing left. */
6636 while (line_ptr < line_end)
6638 /* state machine registers */
6639 CORE_ADDR address = 0;
6640 unsigned int file = 1;
6641 unsigned int line = 1;
6642 unsigned int column = 0;
6643 int is_stmt = lh->default_is_stmt;
6644 int basic_block = 0;
6645 int end_sequence = 0;
6647 if (!decode_for_pst_p && lh->num_file_names >= file)
6649 /* Start a subfile for the current file of the state machine. */
6650 /* lh->include_dirs and lh->file_names are 0-based, but the
6651 directory and file name numbers in the statement program
6653 struct file_entry *fe = &lh->file_names[file - 1];
6657 dir = lh->include_dirs[fe->dir_index - 1];
6659 dwarf2_start_subfile (fe->name, dir, comp_dir);
6662 /* Decode the table. */
6663 while (!end_sequence)
6665 op_code = read_1_byte (abfd, line_ptr);
6668 if (op_code >= lh->opcode_base)
6670 /* Special operand. */
6671 adj_opcode = op_code - lh->opcode_base;
6672 address += (adj_opcode / lh->line_range)
6673 * lh->minimum_instruction_length;
6674 line += lh->line_base + (adj_opcode % lh->line_range);
6675 lh->file_names[file - 1].included_p = 1;
6676 if (!decode_for_pst_p)
6678 if (last_subfile != current_subfile)
6681 record_line (last_subfile, 0, address);
6682 last_subfile = current_subfile;
6684 /* Append row to matrix using current values. */
6685 record_line (current_subfile, line,
6686 check_cu_functions (address, cu));
6690 else switch (op_code)
6692 case DW_LNS_extended_op:
6693 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6694 line_ptr += bytes_read;
6695 extended_op = read_1_byte (abfd, line_ptr);
6697 switch (extended_op)
6699 case DW_LNE_end_sequence:
6701 lh->file_names[file - 1].included_p = 1;
6702 if (!decode_for_pst_p)
6703 record_line (current_subfile, 0, address);
6705 case DW_LNE_set_address:
6706 address = read_address (abfd, line_ptr, cu, &bytes_read);
6707 line_ptr += bytes_read;
6708 address += baseaddr;
6710 case DW_LNE_define_file:
6713 unsigned int dir_index, mod_time, length;
6715 cur_file = read_string (abfd, line_ptr, &bytes_read);
6716 line_ptr += bytes_read;
6718 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6719 line_ptr += bytes_read;
6721 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6722 line_ptr += bytes_read;
6724 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6725 line_ptr += bytes_read;
6726 add_file_name (lh, cur_file, dir_index, mod_time, length);
6730 complaint (&symfile_complaints,
6731 _("mangled .debug_line section"));
6736 lh->file_names[file - 1].included_p = 1;
6737 if (!decode_for_pst_p)
6739 if (last_subfile != current_subfile)
6742 record_line (last_subfile, 0, address);
6743 last_subfile = current_subfile;
6745 record_line (current_subfile, line,
6746 check_cu_functions (address, cu));
6750 case DW_LNS_advance_pc:
6751 address += lh->minimum_instruction_length
6752 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6753 line_ptr += bytes_read;
6755 case DW_LNS_advance_line:
6756 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6757 line_ptr += bytes_read;
6759 case DW_LNS_set_file:
6761 /* The arrays lh->include_dirs and lh->file_names are
6762 0-based, but the directory and file name numbers in
6763 the statement program are 1-based. */
6764 struct file_entry *fe;
6767 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6768 line_ptr += bytes_read;
6769 fe = &lh->file_names[file - 1];
6771 dir = lh->include_dirs[fe->dir_index - 1];
6773 if (!decode_for_pst_p)
6775 last_subfile = current_subfile;
6776 dwarf2_start_subfile (fe->name, dir, comp_dir);
6780 case DW_LNS_set_column:
6781 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6782 line_ptr += bytes_read;
6784 case DW_LNS_negate_stmt:
6785 is_stmt = (!is_stmt);
6787 case DW_LNS_set_basic_block:
6790 /* Add to the address register of the state machine the
6791 address increment value corresponding to special opcode
6792 255. I.e., this value is scaled by the minimum
6793 instruction length since special opcode 255 would have
6794 scaled the the increment. */
6795 case DW_LNS_const_add_pc:
6796 address += (lh->minimum_instruction_length
6797 * ((255 - lh->opcode_base) / lh->line_range));
6799 case DW_LNS_fixed_advance_pc:
6800 address += read_2_bytes (abfd, line_ptr);
6805 /* Unknown standard opcode, ignore it. */
6808 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6810 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6811 line_ptr += bytes_read;
6818 if (decode_for_pst_p)
6822 /* Now that we're done scanning the Line Header Program, we can
6823 create the psymtab of each included file. */
6824 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6825 if (lh->file_names[file_index].included_p == 1)
6827 const struct file_entry fe = lh->file_names [file_index];
6828 char *include_name = fe.name;
6829 char *dir_name = NULL;
6830 char *pst_filename = pst->filename;
6833 dir_name = lh->include_dirs[fe.dir_index - 1];
6835 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6837 include_name = concat (dir_name, SLASH_STRING,
6838 include_name, (char *)NULL);
6839 make_cleanup (xfree, include_name);
6842 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6844 pst_filename = concat (pst->dirname, SLASH_STRING,
6845 pst_filename, (char *)NULL);
6846 make_cleanup (xfree, pst_filename);
6849 if (strcmp (include_name, pst_filename) != 0)
6850 dwarf2_create_include_psymtab (include_name, pst, objfile);
6855 /* Start a subfile for DWARF. FILENAME is the name of the file and
6856 DIRNAME the name of the source directory which contains FILENAME
6857 or NULL if not known. COMP_DIR is the compilation directory for the
6858 linetable's compilation unit or NULL if not known.
6859 This routine tries to keep line numbers from identical absolute and
6860 relative file names in a common subfile.
6862 Using the `list' example from the GDB testsuite, which resides in
6863 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6864 of /srcdir/list0.c yields the following debugging information for list0.c:
6866 DW_AT_name: /srcdir/list0.c
6867 DW_AT_comp_dir: /compdir
6868 files.files[0].name: list0.h
6869 files.files[0].dir: /srcdir
6870 files.files[1].name: list0.c
6871 files.files[1].dir: /srcdir
6873 The line number information for list0.c has to end up in a single
6874 subfile, so that `break /srcdir/list0.c:1' works as expected.
6875 start_subfile will ensure that this happens provided that we pass the
6876 concatenation of files.files[1].dir and files.files[1].name as the
6880 dwarf2_start_subfile (char *filename, char *dirname, char *comp_dir)
6884 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6885 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6886 second argument to start_subfile. To be consistent, we do the
6887 same here. In order not to lose the line information directory,
6888 we concatenate it to the filename when it makes sense.
6889 Note that the Dwarf3 standard says (speaking of filenames in line
6890 information): ``The directory index is ignored for file names
6891 that represent full path names''. Thus ignoring dirname in the
6892 `else' branch below isn't an issue. */
6894 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6895 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
6897 fullname = filename;
6899 start_subfile (fullname, comp_dir);
6901 if (fullname != filename)
6906 var_decode_location (struct attribute *attr, struct symbol *sym,
6907 struct dwarf2_cu *cu)
6909 struct objfile *objfile = cu->objfile;
6910 struct comp_unit_head *cu_header = &cu->header;
6912 /* NOTE drow/2003-01-30: There used to be a comment and some special
6913 code here to turn a symbol with DW_AT_external and a
6914 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6915 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6916 with some versions of binutils) where shared libraries could have
6917 relocations against symbols in their debug information - the
6918 minimal symbol would have the right address, but the debug info
6919 would not. It's no longer necessary, because we will explicitly
6920 apply relocations when we read in the debug information now. */
6922 /* A DW_AT_location attribute with no contents indicates that a
6923 variable has been optimized away. */
6924 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6926 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6930 /* Handle one degenerate form of location expression specially, to
6931 preserve GDB's previous behavior when section offsets are
6932 specified. If this is just a DW_OP_addr then mark this symbol
6935 if (attr_form_is_block (attr)
6936 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6937 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6941 SYMBOL_VALUE_ADDRESS (sym) =
6942 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6943 fixup_symbol_section (sym, objfile);
6944 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6945 SYMBOL_SECTION (sym));
6946 SYMBOL_CLASS (sym) = LOC_STATIC;
6950 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6951 expression evaluator, and use LOC_COMPUTED only when necessary
6952 (i.e. when the value of a register or memory location is
6953 referenced, or a thread-local block, etc.). Then again, it might
6954 not be worthwhile. I'm assuming that it isn't unless performance
6955 or memory numbers show me otherwise. */
6957 dwarf2_symbol_mark_computed (attr, sym, cu);
6958 SYMBOL_CLASS (sym) = LOC_COMPUTED;
6961 /* Given a pointer to a DWARF information entry, figure out if we need
6962 to make a symbol table entry for it, and if so, create a new entry
6963 and return a pointer to it.
6964 If TYPE is NULL, determine symbol type from the die, otherwise
6965 used the passed type. */
6967 static struct symbol *
6968 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6970 struct objfile *objfile = cu->objfile;
6971 struct symbol *sym = NULL;
6973 struct attribute *attr = NULL;
6974 struct attribute *attr2 = NULL;
6977 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6979 if (die->tag != DW_TAG_namespace)
6980 name = dwarf2_linkage_name (die, cu);
6982 name = TYPE_NAME (type);
6986 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6987 sizeof (struct symbol));
6988 OBJSTAT (objfile, n_syms++);
6989 memset (sym, 0, sizeof (struct symbol));
6991 /* Cache this symbol's name and the name's demangled form (if any). */
6992 SYMBOL_LANGUAGE (sym) = cu->language;
6993 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
6995 /* Default assumptions.
6996 Use the passed type or decode it from the die. */
6997 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6998 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7000 SYMBOL_TYPE (sym) = type;
7002 SYMBOL_TYPE (sym) = die_type (die, cu);
7003 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
7006 SYMBOL_LINE (sym) = DW_UNSND (attr);
7011 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
7014 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
7016 SYMBOL_CLASS (sym) = LOC_LABEL;
7018 case DW_TAG_subprogram:
7019 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7021 SYMBOL_CLASS (sym) = LOC_BLOCK;
7022 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7023 if (attr2 && (DW_UNSND (attr2) != 0))
7025 add_symbol_to_list (sym, &global_symbols);
7029 add_symbol_to_list (sym, cu->list_in_scope);
7032 case DW_TAG_variable:
7033 /* Compilation with minimal debug info may result in variables
7034 with missing type entries. Change the misleading `void' type
7035 to something sensible. */
7036 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
7037 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
7038 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
7039 "<variable, no debug info>",
7041 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7044 dwarf2_const_value (attr, sym, cu);
7045 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7046 if (attr2 && (DW_UNSND (attr2) != 0))
7047 add_symbol_to_list (sym, &global_symbols);
7049 add_symbol_to_list (sym, cu->list_in_scope);
7052 attr = dwarf2_attr (die, DW_AT_location, cu);
7055 var_decode_location (attr, sym, cu);
7056 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7057 if (attr2 && (DW_UNSND (attr2) != 0))
7058 add_symbol_to_list (sym, &global_symbols);
7060 add_symbol_to_list (sym, cu->list_in_scope);
7064 /* We do not know the address of this symbol.
7065 If it is an external symbol and we have type information
7066 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7067 The address of the variable will then be determined from
7068 the minimal symbol table whenever the variable is
7070 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7071 if (attr2 && (DW_UNSND (attr2) != 0)
7072 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
7074 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
7075 add_symbol_to_list (sym, &global_symbols);
7079 case DW_TAG_formal_parameter:
7080 attr = dwarf2_attr (die, DW_AT_location, cu);
7083 var_decode_location (attr, sym, cu);
7084 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7085 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
7086 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
7088 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7091 dwarf2_const_value (attr, sym, cu);
7093 add_symbol_to_list (sym, cu->list_in_scope);
7095 case DW_TAG_unspecified_parameters:
7096 /* From varargs functions; gdb doesn't seem to have any
7097 interest in this information, so just ignore it for now.
7100 case DW_TAG_class_type:
7101 case DW_TAG_structure_type:
7102 case DW_TAG_union_type:
7103 case DW_TAG_set_type:
7104 case DW_TAG_enumeration_type:
7105 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7106 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7108 /* Make sure that the symbol includes appropriate enclosing
7109 classes/namespaces in its name. These are calculated in
7110 read_structure_type, and the correct name is saved in
7113 if (cu->language == language_cplus
7114 || cu->language == language_java)
7116 struct type *type = SYMBOL_TYPE (sym);
7118 if (TYPE_TAG_NAME (type) != NULL)
7120 /* FIXME: carlton/2003-11-10: Should this use
7121 SYMBOL_SET_NAMES instead? (The same problem also
7122 arises further down in this function.) */
7123 /* The type's name is already allocated along with
7124 this objfile, so we don't need to duplicate it
7126 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
7131 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7132 really ever be static objects: otherwise, if you try
7133 to, say, break of a class's method and you're in a file
7134 which doesn't mention that class, it won't work unless
7135 the check for all static symbols in lookup_symbol_aux
7136 saves you. See the OtherFileClass tests in
7137 gdb.c++/namespace.exp. */
7139 struct pending **list_to_add;
7141 list_to_add = (cu->list_in_scope == &file_symbols
7142 && (cu->language == language_cplus
7143 || cu->language == language_java)
7144 ? &global_symbols : cu->list_in_scope);
7146 add_symbol_to_list (sym, list_to_add);
7148 /* The semantics of C++ state that "struct foo { ... }" also
7149 defines a typedef for "foo". A Java class declaration also
7150 defines a typedef for the class. Synthesize a typedef symbol
7151 so that "ptype foo" works as expected. */
7152 if (cu->language == language_cplus
7153 || cu->language == language_java)
7155 struct symbol *typedef_sym = (struct symbol *)
7156 obstack_alloc (&objfile->objfile_obstack,
7157 sizeof (struct symbol));
7158 *typedef_sym = *sym;
7159 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
7160 /* The symbol's name is already allocated along with
7161 this objfile, so we don't need to duplicate it for
7163 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
7164 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
7165 add_symbol_to_list (typedef_sym, list_to_add);
7169 case DW_TAG_typedef:
7170 if (processing_has_namespace_info
7171 && processing_current_prefix[0] != '\0')
7173 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7174 processing_current_prefix,
7177 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7178 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7179 add_symbol_to_list (sym, cu->list_in_scope);
7181 case DW_TAG_base_type:
7182 case DW_TAG_subrange_type:
7183 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7184 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7185 add_symbol_to_list (sym, cu->list_in_scope);
7187 case DW_TAG_enumerator:
7188 if (processing_has_namespace_info
7189 && processing_current_prefix[0] != '\0')
7191 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7192 processing_current_prefix,
7195 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7198 dwarf2_const_value (attr, sym, cu);
7201 /* NOTE: carlton/2003-11-10: See comment above in the
7202 DW_TAG_class_type, etc. block. */
7204 struct pending **list_to_add;
7206 list_to_add = (cu->list_in_scope == &file_symbols
7207 && (cu->language == language_cplus
7208 || cu->language == language_java)
7209 ? &global_symbols : cu->list_in_scope);
7211 add_symbol_to_list (sym, list_to_add);
7214 case DW_TAG_namespace:
7215 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7216 add_symbol_to_list (sym, &global_symbols);
7219 /* Not a tag we recognize. Hopefully we aren't processing
7220 trash data, but since we must specifically ignore things
7221 we don't recognize, there is nothing else we should do at
7223 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7224 dwarf_tag_name (die->tag));
7231 /* Copy constant value from an attribute to a symbol. */
7234 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7235 struct dwarf2_cu *cu)
7237 struct objfile *objfile = cu->objfile;
7238 struct comp_unit_head *cu_header = &cu->header;
7239 struct dwarf_block *blk;
7244 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7245 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7246 cu_header->addr_size,
7247 TYPE_LENGTH (SYMBOL_TYPE
7249 SYMBOL_VALUE_BYTES (sym) =
7250 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7251 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7252 it's body - store_unsigned_integer. */
7253 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7255 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7257 case DW_FORM_block1:
7258 case DW_FORM_block2:
7259 case DW_FORM_block4:
7261 blk = DW_BLOCK (attr);
7262 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7263 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7265 TYPE_LENGTH (SYMBOL_TYPE
7267 SYMBOL_VALUE_BYTES (sym) =
7268 obstack_alloc (&objfile->objfile_obstack, blk->size);
7269 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7270 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7273 /* The DW_AT_const_value attributes are supposed to carry the
7274 symbol's value "represented as it would be on the target
7275 architecture." By the time we get here, it's already been
7276 converted to host endianness, so we just need to sign- or
7277 zero-extend it as appropriate. */
7279 dwarf2_const_value_data (attr, sym, 8);
7282 dwarf2_const_value_data (attr, sym, 16);
7285 dwarf2_const_value_data (attr, sym, 32);
7288 dwarf2_const_value_data (attr, sym, 64);
7292 SYMBOL_VALUE (sym) = DW_SND (attr);
7293 SYMBOL_CLASS (sym) = LOC_CONST;
7297 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7298 SYMBOL_CLASS (sym) = LOC_CONST;
7302 complaint (&symfile_complaints,
7303 _("unsupported const value attribute form: '%s'"),
7304 dwarf_form_name (attr->form));
7305 SYMBOL_VALUE (sym) = 0;
7306 SYMBOL_CLASS (sym) = LOC_CONST;
7312 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7313 or zero-extend it as appropriate for the symbol's type. */
7315 dwarf2_const_value_data (struct attribute *attr,
7319 LONGEST l = DW_UNSND (attr);
7321 if (bits < sizeof (l) * 8)
7323 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7324 l &= ((LONGEST) 1 << bits) - 1;
7326 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7329 SYMBOL_VALUE (sym) = l;
7330 SYMBOL_CLASS (sym) = LOC_CONST;
7334 /* Return the type of the die in question using its DW_AT_type attribute. */
7336 static struct type *
7337 die_type (struct die_info *die, struct dwarf2_cu *cu)
7340 struct attribute *type_attr;
7341 struct die_info *type_die;
7343 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7346 /* A missing DW_AT_type represents a void type. */
7347 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7350 type_die = follow_die_ref (die, type_attr, cu);
7352 type = tag_type_to_type (type_die, cu);
7355 dump_die (type_die);
7356 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7362 /* Return the containing type of the die in question using its
7363 DW_AT_containing_type attribute. */
7365 static struct type *
7366 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7368 struct type *type = NULL;
7369 struct attribute *type_attr;
7370 struct die_info *type_die = NULL;
7372 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7375 type_die = follow_die_ref (die, type_attr, cu);
7376 type = tag_type_to_type (type_die, cu);
7381 dump_die (type_die);
7382 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7388 static struct type *
7389 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7397 read_type_die (die, cu);
7401 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7409 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7411 char *prefix = determine_prefix (die, cu);
7412 const char *old_prefix = processing_current_prefix;
7413 struct cleanup *back_to = make_cleanup (xfree, prefix);
7414 processing_current_prefix = prefix;
7418 case DW_TAG_class_type:
7419 case DW_TAG_structure_type:
7420 case DW_TAG_union_type:
7421 read_structure_type (die, cu);
7423 case DW_TAG_enumeration_type:
7424 read_enumeration_type (die, cu);
7426 case DW_TAG_subprogram:
7427 case DW_TAG_subroutine_type:
7428 read_subroutine_type (die, cu);
7430 case DW_TAG_array_type:
7431 read_array_type (die, cu);
7433 case DW_TAG_set_type:
7434 read_set_type (die, cu);
7436 case DW_TAG_pointer_type:
7437 read_tag_pointer_type (die, cu);
7439 case DW_TAG_ptr_to_member_type:
7440 read_tag_ptr_to_member_type (die, cu);
7442 case DW_TAG_reference_type:
7443 read_tag_reference_type (die, cu);
7445 case DW_TAG_const_type:
7446 read_tag_const_type (die, cu);
7448 case DW_TAG_volatile_type:
7449 read_tag_volatile_type (die, cu);
7451 case DW_TAG_string_type:
7452 read_tag_string_type (die, cu);
7454 case DW_TAG_typedef:
7455 read_typedef (die, cu);
7457 case DW_TAG_subrange_type:
7458 read_subrange_type (die, cu);
7460 case DW_TAG_base_type:
7461 read_base_type (die, cu);
7463 case DW_TAG_unspecified_type:
7464 read_unspecified_type (die, cu);
7467 complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
7468 dwarf_tag_name (die->tag));
7472 processing_current_prefix = old_prefix;
7473 do_cleanups (back_to);
7476 /* Return the name of the namespace/class that DIE is defined within,
7477 or "" if we can't tell. The caller should xfree the result. */
7479 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7480 therein) for an example of how to use this function to deal with
7481 DW_AT_specification. */
7484 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7486 struct die_info *parent;
7488 if (cu->language != language_cplus
7489 && cu->language != language_java)
7492 parent = die->parent;
7496 return xstrdup ("");
7500 switch (parent->tag) {
7501 case DW_TAG_namespace:
7503 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7504 before doing this check? */
7505 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7507 return xstrdup (TYPE_TAG_NAME (parent->type));
7512 char *parent_prefix = determine_prefix (parent, cu);
7513 char *retval = typename_concat (NULL, parent_prefix,
7514 namespace_name (parent, &dummy,
7517 xfree (parent_prefix);
7522 case DW_TAG_class_type:
7523 case DW_TAG_structure_type:
7525 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7527 return xstrdup (TYPE_TAG_NAME (parent->type));
7531 const char *old_prefix = processing_current_prefix;
7532 char *new_prefix = determine_prefix (parent, cu);
7535 processing_current_prefix = new_prefix;
7536 retval = determine_class_name (parent, cu);
7537 processing_current_prefix = old_prefix;
7544 return determine_prefix (parent, cu);
7549 /* Return a newly-allocated string formed by concatenating PREFIX and
7550 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7551 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7552 perform an obconcat, otherwise allocate storage for the result. The CU argument
7553 is used to determine the language and hence, the appropriate separator. */
7555 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7558 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7559 struct dwarf2_cu *cu)
7563 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7565 else if (cu->language == language_java)
7572 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7577 strcpy (retval, prefix);
7578 strcat (retval, sep);
7581 strcat (retval, suffix);
7587 /* We have an obstack. */
7588 return obconcat (obs, prefix, sep, suffix);
7592 static struct type *
7593 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7595 struct objfile *objfile = cu->objfile;
7597 /* FIXME - this should not produce a new (struct type *)
7598 every time. It should cache base types. */
7602 case DW_ATE_address:
7603 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7605 case DW_ATE_boolean:
7606 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7608 case DW_ATE_complex_float:
7611 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7615 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7621 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7625 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7632 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7635 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7639 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7643 case DW_ATE_signed_char:
7644 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7646 case DW_ATE_unsigned:
7650 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7653 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7657 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7661 case DW_ATE_unsigned_char:
7662 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7665 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7672 copy_die (struct die_info *old_die)
7674 struct die_info *new_die;
7677 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7678 memset (new_die, 0, sizeof (struct die_info));
7680 new_die->tag = old_die->tag;
7681 new_die->has_children = old_die->has_children;
7682 new_die->abbrev = old_die->abbrev;
7683 new_die->offset = old_die->offset;
7684 new_die->type = NULL;
7686 num_attrs = old_die->num_attrs;
7687 new_die->num_attrs = num_attrs;
7688 new_die->attrs = (struct attribute *)
7689 xmalloc (num_attrs * sizeof (struct attribute));
7691 for (i = 0; i < old_die->num_attrs; ++i)
7693 new_die->attrs[i].name = old_die->attrs[i].name;
7694 new_die->attrs[i].form = old_die->attrs[i].form;
7695 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7698 new_die->next = NULL;
7703 /* Return sibling of die, NULL if no sibling. */
7705 static struct die_info *
7706 sibling_die (struct die_info *die)
7708 return die->sibling;
7711 /* Get linkage name of a die, return NULL if not found. */
7714 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7716 struct attribute *attr;
7718 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7719 if (attr && DW_STRING (attr))
7720 return DW_STRING (attr);
7721 attr = dwarf2_attr (die, DW_AT_name, cu);
7722 if (attr && DW_STRING (attr))
7723 return DW_STRING (attr);
7727 /* Get name of a die, return NULL if not found. */
7730 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7732 struct attribute *attr;
7734 attr = dwarf2_attr (die, DW_AT_name, cu);
7735 if (attr && DW_STRING (attr))
7736 return DW_STRING (attr);
7740 /* Return the die that this die in an extension of, or NULL if there
7743 static struct die_info *
7744 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7746 struct attribute *attr;
7748 attr = dwarf2_attr (die, DW_AT_extension, cu);
7752 return follow_die_ref (die, attr, cu);
7755 /* Convert a DIE tag into its string name. */
7758 dwarf_tag_name (unsigned tag)
7762 case DW_TAG_padding:
7763 return "DW_TAG_padding";
7764 case DW_TAG_array_type:
7765 return "DW_TAG_array_type";
7766 case DW_TAG_class_type:
7767 return "DW_TAG_class_type";
7768 case DW_TAG_entry_point:
7769 return "DW_TAG_entry_point";
7770 case DW_TAG_enumeration_type:
7771 return "DW_TAG_enumeration_type";
7772 case DW_TAG_formal_parameter:
7773 return "DW_TAG_formal_parameter";
7774 case DW_TAG_imported_declaration:
7775 return "DW_TAG_imported_declaration";
7777 return "DW_TAG_label";
7778 case DW_TAG_lexical_block:
7779 return "DW_TAG_lexical_block";
7781 return "DW_TAG_member";
7782 case DW_TAG_pointer_type:
7783 return "DW_TAG_pointer_type";
7784 case DW_TAG_reference_type:
7785 return "DW_TAG_reference_type";
7786 case DW_TAG_compile_unit:
7787 return "DW_TAG_compile_unit";
7788 case DW_TAG_string_type:
7789 return "DW_TAG_string_type";
7790 case DW_TAG_structure_type:
7791 return "DW_TAG_structure_type";
7792 case DW_TAG_subroutine_type:
7793 return "DW_TAG_subroutine_type";
7794 case DW_TAG_typedef:
7795 return "DW_TAG_typedef";
7796 case DW_TAG_union_type:
7797 return "DW_TAG_union_type";
7798 case DW_TAG_unspecified_parameters:
7799 return "DW_TAG_unspecified_parameters";
7800 case DW_TAG_variant:
7801 return "DW_TAG_variant";
7802 case DW_TAG_common_block:
7803 return "DW_TAG_common_block";
7804 case DW_TAG_common_inclusion:
7805 return "DW_TAG_common_inclusion";
7806 case DW_TAG_inheritance:
7807 return "DW_TAG_inheritance";
7808 case DW_TAG_inlined_subroutine:
7809 return "DW_TAG_inlined_subroutine";
7811 return "DW_TAG_module";
7812 case DW_TAG_ptr_to_member_type:
7813 return "DW_TAG_ptr_to_member_type";
7814 case DW_TAG_set_type:
7815 return "DW_TAG_set_type";
7816 case DW_TAG_subrange_type:
7817 return "DW_TAG_subrange_type";
7818 case DW_TAG_with_stmt:
7819 return "DW_TAG_with_stmt";
7820 case DW_TAG_access_declaration:
7821 return "DW_TAG_access_declaration";
7822 case DW_TAG_base_type:
7823 return "DW_TAG_base_type";
7824 case DW_TAG_catch_block:
7825 return "DW_TAG_catch_block";
7826 case DW_TAG_const_type:
7827 return "DW_TAG_const_type";
7828 case DW_TAG_constant:
7829 return "DW_TAG_constant";
7830 case DW_TAG_enumerator:
7831 return "DW_TAG_enumerator";
7832 case DW_TAG_file_type:
7833 return "DW_TAG_file_type";
7835 return "DW_TAG_friend";
7836 case DW_TAG_namelist:
7837 return "DW_TAG_namelist";
7838 case DW_TAG_namelist_item:
7839 return "DW_TAG_namelist_item";
7840 case DW_TAG_packed_type:
7841 return "DW_TAG_packed_type";
7842 case DW_TAG_subprogram:
7843 return "DW_TAG_subprogram";
7844 case DW_TAG_template_type_param:
7845 return "DW_TAG_template_type_param";
7846 case DW_TAG_template_value_param:
7847 return "DW_TAG_template_value_param";
7848 case DW_TAG_thrown_type:
7849 return "DW_TAG_thrown_type";
7850 case DW_TAG_try_block:
7851 return "DW_TAG_try_block";
7852 case DW_TAG_variant_part:
7853 return "DW_TAG_variant_part";
7854 case DW_TAG_variable:
7855 return "DW_TAG_variable";
7856 case DW_TAG_volatile_type:
7857 return "DW_TAG_volatile_type";
7858 case DW_TAG_dwarf_procedure:
7859 return "DW_TAG_dwarf_procedure";
7860 case DW_TAG_restrict_type:
7861 return "DW_TAG_restrict_type";
7862 case DW_TAG_interface_type:
7863 return "DW_TAG_interface_type";
7864 case DW_TAG_namespace:
7865 return "DW_TAG_namespace";
7866 case DW_TAG_imported_module:
7867 return "DW_TAG_imported_module";
7868 case DW_TAG_unspecified_type:
7869 return "DW_TAG_unspecified_type";
7870 case DW_TAG_partial_unit:
7871 return "DW_TAG_partial_unit";
7872 case DW_TAG_imported_unit:
7873 return "DW_TAG_imported_unit";
7874 case DW_TAG_MIPS_loop:
7875 return "DW_TAG_MIPS_loop";
7876 case DW_TAG_format_label:
7877 return "DW_TAG_format_label";
7878 case DW_TAG_function_template:
7879 return "DW_TAG_function_template";
7880 case DW_TAG_class_template:
7881 return "DW_TAG_class_template";
7883 return "DW_TAG_<unknown>";
7887 /* Convert a DWARF attribute code into its string name. */
7890 dwarf_attr_name (unsigned attr)
7895 return "DW_AT_sibling";
7896 case DW_AT_location:
7897 return "DW_AT_location";
7899 return "DW_AT_name";
7900 case DW_AT_ordering:
7901 return "DW_AT_ordering";
7902 case DW_AT_subscr_data:
7903 return "DW_AT_subscr_data";
7904 case DW_AT_byte_size:
7905 return "DW_AT_byte_size";
7906 case DW_AT_bit_offset:
7907 return "DW_AT_bit_offset";
7908 case DW_AT_bit_size:
7909 return "DW_AT_bit_size";
7910 case DW_AT_element_list:
7911 return "DW_AT_element_list";
7912 case DW_AT_stmt_list:
7913 return "DW_AT_stmt_list";
7915 return "DW_AT_low_pc";
7917 return "DW_AT_high_pc";
7918 case DW_AT_language:
7919 return "DW_AT_language";
7921 return "DW_AT_member";
7923 return "DW_AT_discr";
7924 case DW_AT_discr_value:
7925 return "DW_AT_discr_value";
7926 case DW_AT_visibility:
7927 return "DW_AT_visibility";
7929 return "DW_AT_import";
7930 case DW_AT_string_length:
7931 return "DW_AT_string_length";
7932 case DW_AT_common_reference:
7933 return "DW_AT_common_reference";
7934 case DW_AT_comp_dir:
7935 return "DW_AT_comp_dir";
7936 case DW_AT_const_value:
7937 return "DW_AT_const_value";
7938 case DW_AT_containing_type:
7939 return "DW_AT_containing_type";
7940 case DW_AT_default_value:
7941 return "DW_AT_default_value";
7943 return "DW_AT_inline";
7944 case DW_AT_is_optional:
7945 return "DW_AT_is_optional";
7946 case DW_AT_lower_bound:
7947 return "DW_AT_lower_bound";
7948 case DW_AT_producer:
7949 return "DW_AT_producer";
7950 case DW_AT_prototyped:
7951 return "DW_AT_prototyped";
7952 case DW_AT_return_addr:
7953 return "DW_AT_return_addr";
7954 case DW_AT_start_scope:
7955 return "DW_AT_start_scope";
7956 case DW_AT_stride_size:
7957 return "DW_AT_stride_size";
7958 case DW_AT_upper_bound:
7959 return "DW_AT_upper_bound";
7960 case DW_AT_abstract_origin:
7961 return "DW_AT_abstract_origin";
7962 case DW_AT_accessibility:
7963 return "DW_AT_accessibility";
7964 case DW_AT_address_class:
7965 return "DW_AT_address_class";
7966 case DW_AT_artificial:
7967 return "DW_AT_artificial";
7968 case DW_AT_base_types:
7969 return "DW_AT_base_types";
7970 case DW_AT_calling_convention:
7971 return "DW_AT_calling_convention";
7973 return "DW_AT_count";
7974 case DW_AT_data_member_location:
7975 return "DW_AT_data_member_location";
7976 case DW_AT_decl_column:
7977 return "DW_AT_decl_column";
7978 case DW_AT_decl_file:
7979 return "DW_AT_decl_file";
7980 case DW_AT_decl_line:
7981 return "DW_AT_decl_line";
7982 case DW_AT_declaration:
7983 return "DW_AT_declaration";
7984 case DW_AT_discr_list:
7985 return "DW_AT_discr_list";
7986 case DW_AT_encoding:
7987 return "DW_AT_encoding";
7988 case DW_AT_external:
7989 return "DW_AT_external";
7990 case DW_AT_frame_base:
7991 return "DW_AT_frame_base";
7993 return "DW_AT_friend";
7994 case DW_AT_identifier_case:
7995 return "DW_AT_identifier_case";
7996 case DW_AT_macro_info:
7997 return "DW_AT_macro_info";
7998 case DW_AT_namelist_items:
7999 return "DW_AT_namelist_items";
8000 case DW_AT_priority:
8001 return "DW_AT_priority";
8003 return "DW_AT_segment";
8004 case DW_AT_specification:
8005 return "DW_AT_specification";
8006 case DW_AT_static_link:
8007 return "DW_AT_static_link";
8009 return "DW_AT_type";
8010 case DW_AT_use_location:
8011 return "DW_AT_use_location";
8012 case DW_AT_variable_parameter:
8013 return "DW_AT_variable_parameter";
8014 case DW_AT_virtuality:
8015 return "DW_AT_virtuality";
8016 case DW_AT_vtable_elem_location:
8017 return "DW_AT_vtable_elem_location";
8018 case DW_AT_allocated:
8019 return "DW_AT_allocated";
8020 case DW_AT_associated:
8021 return "DW_AT_associated";
8022 case DW_AT_data_location:
8023 return "DW_AT_data_location";
8025 return "DW_AT_stride";
8026 case DW_AT_entry_pc:
8027 return "DW_AT_entry_pc";
8028 case DW_AT_use_UTF8:
8029 return "DW_AT_use_UTF8";
8030 case DW_AT_extension:
8031 return "DW_AT_extension";
8033 return "DW_AT_ranges";
8034 case DW_AT_trampoline:
8035 return "DW_AT_trampoline";
8036 case DW_AT_call_column:
8037 return "DW_AT_call_column";
8038 case DW_AT_call_file:
8039 return "DW_AT_call_file";
8040 case DW_AT_call_line:
8041 return "DW_AT_call_line";
8043 case DW_AT_MIPS_fde:
8044 return "DW_AT_MIPS_fde";
8045 case DW_AT_MIPS_loop_begin:
8046 return "DW_AT_MIPS_loop_begin";
8047 case DW_AT_MIPS_tail_loop_begin:
8048 return "DW_AT_MIPS_tail_loop_begin";
8049 case DW_AT_MIPS_epilog_begin:
8050 return "DW_AT_MIPS_epilog_begin";
8051 case DW_AT_MIPS_loop_unroll_factor:
8052 return "DW_AT_MIPS_loop_unroll_factor";
8053 case DW_AT_MIPS_software_pipeline_depth:
8054 return "DW_AT_MIPS_software_pipeline_depth";
8056 case DW_AT_MIPS_linkage_name:
8057 return "DW_AT_MIPS_linkage_name";
8059 case DW_AT_sf_names:
8060 return "DW_AT_sf_names";
8061 case DW_AT_src_info:
8062 return "DW_AT_src_info";
8063 case DW_AT_mac_info:
8064 return "DW_AT_mac_info";
8065 case DW_AT_src_coords:
8066 return "DW_AT_src_coords";
8067 case DW_AT_body_begin:
8068 return "DW_AT_body_begin";
8069 case DW_AT_body_end:
8070 return "DW_AT_body_end";
8071 case DW_AT_GNU_vector:
8072 return "DW_AT_GNU_vector";
8074 return "DW_AT_<unknown>";
8078 /* Convert a DWARF value form code into its string name. */
8081 dwarf_form_name (unsigned form)
8086 return "DW_FORM_addr";
8087 case DW_FORM_block2:
8088 return "DW_FORM_block2";
8089 case DW_FORM_block4:
8090 return "DW_FORM_block4";
8092 return "DW_FORM_data2";
8094 return "DW_FORM_data4";
8096 return "DW_FORM_data8";
8097 case DW_FORM_string:
8098 return "DW_FORM_string";
8100 return "DW_FORM_block";
8101 case DW_FORM_block1:
8102 return "DW_FORM_block1";
8104 return "DW_FORM_data1";
8106 return "DW_FORM_flag";
8108 return "DW_FORM_sdata";
8110 return "DW_FORM_strp";
8112 return "DW_FORM_udata";
8113 case DW_FORM_ref_addr:
8114 return "DW_FORM_ref_addr";
8116 return "DW_FORM_ref1";
8118 return "DW_FORM_ref2";
8120 return "DW_FORM_ref4";
8122 return "DW_FORM_ref8";
8123 case DW_FORM_ref_udata:
8124 return "DW_FORM_ref_udata";
8125 case DW_FORM_indirect:
8126 return "DW_FORM_indirect";
8128 return "DW_FORM_<unknown>";
8132 /* Convert a DWARF stack opcode into its string name. */
8135 dwarf_stack_op_name (unsigned op)
8140 return "DW_OP_addr";
8142 return "DW_OP_deref";
8144 return "DW_OP_const1u";
8146 return "DW_OP_const1s";
8148 return "DW_OP_const2u";
8150 return "DW_OP_const2s";
8152 return "DW_OP_const4u";
8154 return "DW_OP_const4s";
8156 return "DW_OP_const8u";
8158 return "DW_OP_const8s";
8160 return "DW_OP_constu";
8162 return "DW_OP_consts";
8166 return "DW_OP_drop";
8168 return "DW_OP_over";
8170 return "DW_OP_pick";
8172 return "DW_OP_swap";
8176 return "DW_OP_xderef";
8184 return "DW_OP_minus";
8196 return "DW_OP_plus";
8197 case DW_OP_plus_uconst:
8198 return "DW_OP_plus_uconst";
8204 return "DW_OP_shra";
8222 return "DW_OP_skip";
8224 return "DW_OP_lit0";
8226 return "DW_OP_lit1";
8228 return "DW_OP_lit2";
8230 return "DW_OP_lit3";
8232 return "DW_OP_lit4";
8234 return "DW_OP_lit5";
8236 return "DW_OP_lit6";
8238 return "DW_OP_lit7";
8240 return "DW_OP_lit8";
8242 return "DW_OP_lit9";
8244 return "DW_OP_lit10";
8246 return "DW_OP_lit11";
8248 return "DW_OP_lit12";
8250 return "DW_OP_lit13";
8252 return "DW_OP_lit14";
8254 return "DW_OP_lit15";
8256 return "DW_OP_lit16";
8258 return "DW_OP_lit17";
8260 return "DW_OP_lit18";
8262 return "DW_OP_lit19";
8264 return "DW_OP_lit20";
8266 return "DW_OP_lit21";
8268 return "DW_OP_lit22";
8270 return "DW_OP_lit23";
8272 return "DW_OP_lit24";
8274 return "DW_OP_lit25";
8276 return "DW_OP_lit26";
8278 return "DW_OP_lit27";
8280 return "DW_OP_lit28";
8282 return "DW_OP_lit29";
8284 return "DW_OP_lit30";
8286 return "DW_OP_lit31";
8288 return "DW_OP_reg0";
8290 return "DW_OP_reg1";
8292 return "DW_OP_reg2";
8294 return "DW_OP_reg3";
8296 return "DW_OP_reg4";
8298 return "DW_OP_reg5";
8300 return "DW_OP_reg6";
8302 return "DW_OP_reg7";
8304 return "DW_OP_reg8";
8306 return "DW_OP_reg9";
8308 return "DW_OP_reg10";
8310 return "DW_OP_reg11";
8312 return "DW_OP_reg12";
8314 return "DW_OP_reg13";
8316 return "DW_OP_reg14";
8318 return "DW_OP_reg15";
8320 return "DW_OP_reg16";
8322 return "DW_OP_reg17";
8324 return "DW_OP_reg18";
8326 return "DW_OP_reg19";
8328 return "DW_OP_reg20";
8330 return "DW_OP_reg21";
8332 return "DW_OP_reg22";
8334 return "DW_OP_reg23";
8336 return "DW_OP_reg24";
8338 return "DW_OP_reg25";
8340 return "DW_OP_reg26";
8342 return "DW_OP_reg27";
8344 return "DW_OP_reg28";
8346 return "DW_OP_reg29";
8348 return "DW_OP_reg30";
8350 return "DW_OP_reg31";
8352 return "DW_OP_breg0";
8354 return "DW_OP_breg1";
8356 return "DW_OP_breg2";
8358 return "DW_OP_breg3";
8360 return "DW_OP_breg4";
8362 return "DW_OP_breg5";
8364 return "DW_OP_breg6";
8366 return "DW_OP_breg7";
8368 return "DW_OP_breg8";
8370 return "DW_OP_breg9";
8372 return "DW_OP_breg10";
8374 return "DW_OP_breg11";
8376 return "DW_OP_breg12";
8378 return "DW_OP_breg13";
8380 return "DW_OP_breg14";
8382 return "DW_OP_breg15";
8384 return "DW_OP_breg16";
8386 return "DW_OP_breg17";
8388 return "DW_OP_breg18";
8390 return "DW_OP_breg19";
8392 return "DW_OP_breg20";
8394 return "DW_OP_breg21";
8396 return "DW_OP_breg22";
8398 return "DW_OP_breg23";
8400 return "DW_OP_breg24";
8402 return "DW_OP_breg25";
8404 return "DW_OP_breg26";
8406 return "DW_OP_breg27";
8408 return "DW_OP_breg28";
8410 return "DW_OP_breg29";
8412 return "DW_OP_breg30";
8414 return "DW_OP_breg31";
8416 return "DW_OP_regx";
8418 return "DW_OP_fbreg";
8420 return "DW_OP_bregx";
8422 return "DW_OP_piece";
8423 case DW_OP_deref_size:
8424 return "DW_OP_deref_size";
8425 case DW_OP_xderef_size:
8426 return "DW_OP_xderef_size";
8429 /* DWARF 3 extensions. */
8430 case DW_OP_push_object_address:
8431 return "DW_OP_push_object_address";
8433 return "DW_OP_call2";
8435 return "DW_OP_call4";
8436 case DW_OP_call_ref:
8437 return "DW_OP_call_ref";
8438 /* GNU extensions. */
8439 case DW_OP_GNU_push_tls_address:
8440 return "DW_OP_GNU_push_tls_address";
8442 return "OP_<unknown>";
8447 dwarf_bool_name (unsigned mybool)
8455 /* Convert a DWARF type code into its string name. */
8458 dwarf_type_encoding_name (unsigned enc)
8462 case DW_ATE_address:
8463 return "DW_ATE_address";
8464 case DW_ATE_boolean:
8465 return "DW_ATE_boolean";
8466 case DW_ATE_complex_float:
8467 return "DW_ATE_complex_float";
8469 return "DW_ATE_float";
8471 return "DW_ATE_signed";
8472 case DW_ATE_signed_char:
8473 return "DW_ATE_signed_char";
8474 case DW_ATE_unsigned:
8475 return "DW_ATE_unsigned";
8476 case DW_ATE_unsigned_char:
8477 return "DW_ATE_unsigned_char";
8478 case DW_ATE_imaginary_float:
8479 return "DW_ATE_imaginary_float";
8481 return "DW_ATE_<unknown>";
8485 /* Convert a DWARF call frame info operation to its string name. */
8489 dwarf_cfi_name (unsigned cfi_opc)
8493 case DW_CFA_advance_loc:
8494 return "DW_CFA_advance_loc";
8496 return "DW_CFA_offset";
8497 case DW_CFA_restore:
8498 return "DW_CFA_restore";
8500 return "DW_CFA_nop";
8501 case DW_CFA_set_loc:
8502 return "DW_CFA_set_loc";
8503 case DW_CFA_advance_loc1:
8504 return "DW_CFA_advance_loc1";
8505 case DW_CFA_advance_loc2:
8506 return "DW_CFA_advance_loc2";
8507 case DW_CFA_advance_loc4:
8508 return "DW_CFA_advance_loc4";
8509 case DW_CFA_offset_extended:
8510 return "DW_CFA_offset_extended";
8511 case DW_CFA_restore_extended:
8512 return "DW_CFA_restore_extended";
8513 case DW_CFA_undefined:
8514 return "DW_CFA_undefined";
8515 case DW_CFA_same_value:
8516 return "DW_CFA_same_value";
8517 case DW_CFA_register:
8518 return "DW_CFA_register";
8519 case DW_CFA_remember_state:
8520 return "DW_CFA_remember_state";
8521 case DW_CFA_restore_state:
8522 return "DW_CFA_restore_state";
8523 case DW_CFA_def_cfa:
8524 return "DW_CFA_def_cfa";
8525 case DW_CFA_def_cfa_register:
8526 return "DW_CFA_def_cfa_register";
8527 case DW_CFA_def_cfa_offset:
8528 return "DW_CFA_def_cfa_offset";
8531 case DW_CFA_def_cfa_expression:
8532 return "DW_CFA_def_cfa_expression";
8533 case DW_CFA_expression:
8534 return "DW_CFA_expression";
8535 case DW_CFA_offset_extended_sf:
8536 return "DW_CFA_offset_extended_sf";
8537 case DW_CFA_def_cfa_sf:
8538 return "DW_CFA_def_cfa_sf";
8539 case DW_CFA_def_cfa_offset_sf:
8540 return "DW_CFA_def_cfa_offset_sf";
8542 /* SGI/MIPS specific */
8543 case DW_CFA_MIPS_advance_loc8:
8544 return "DW_CFA_MIPS_advance_loc8";
8546 /* GNU extensions */
8547 case DW_CFA_GNU_window_save:
8548 return "DW_CFA_GNU_window_save";
8549 case DW_CFA_GNU_args_size:
8550 return "DW_CFA_GNU_args_size";
8551 case DW_CFA_GNU_negative_offset_extended:
8552 return "DW_CFA_GNU_negative_offset_extended";
8555 return "DW_CFA_<unknown>";
8561 dump_die (struct die_info *die)
8565 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8566 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8567 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8568 dwarf_bool_name (die->child != NULL));
8570 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8571 for (i = 0; i < die->num_attrs; ++i)
8573 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8574 dwarf_attr_name (die->attrs[i].name),
8575 dwarf_form_name (die->attrs[i].form));
8576 switch (die->attrs[i].form)
8578 case DW_FORM_ref_addr:
8580 fprintf_unfiltered (gdb_stderr, "address: ");
8581 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8583 case DW_FORM_block2:
8584 case DW_FORM_block4:
8586 case DW_FORM_block1:
8587 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8592 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8593 (long) (DW_ADDR (&die->attrs[i])));
8601 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8603 case DW_FORM_string:
8605 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8606 DW_STRING (&die->attrs[i])
8607 ? DW_STRING (&die->attrs[i]) : "");
8610 if (DW_UNSND (&die->attrs[i]))
8611 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8613 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8615 case DW_FORM_indirect:
8616 /* the reader will have reduced the indirect form to
8617 the "base form" so this form should not occur */
8618 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8621 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8622 die->attrs[i].form);
8624 fprintf_unfiltered (gdb_stderr, "\n");
8629 dump_die_list (struct die_info *die)
8634 if (die->child != NULL)
8635 dump_die_list (die->child);
8636 if (die->sibling != NULL)
8637 dump_die_list (die->sibling);
8642 store_in_ref_table (unsigned int offset, struct die_info *die,
8643 struct dwarf2_cu *cu)
8646 struct die_info *old;
8648 h = (offset % REF_HASH_SIZE);
8649 old = cu->die_ref_table[h];
8650 die->next_ref = old;
8651 cu->die_ref_table[h] = die;
8655 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8657 unsigned int result = 0;
8661 case DW_FORM_ref_addr:
8666 case DW_FORM_ref_udata:
8667 result = DW_ADDR (attr);
8670 complaint (&symfile_complaints,
8671 _("unsupported die ref attribute form: '%s'"),
8672 dwarf_form_name (attr->form));
8677 /* Return the constant value held by the given attribute. Return -1
8678 if the value held by the attribute is not constant. */
8681 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8683 if (attr->form == DW_FORM_sdata)
8684 return DW_SND (attr);
8685 else if (attr->form == DW_FORM_udata
8686 || attr->form == DW_FORM_data1
8687 || attr->form == DW_FORM_data2
8688 || attr->form == DW_FORM_data4
8689 || attr->form == DW_FORM_data8)
8690 return DW_UNSND (attr);
8693 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8694 dwarf_form_name (attr->form));
8695 return default_value;
8699 static struct die_info *
8700 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8701 struct dwarf2_cu *cu)
8703 struct die_info *die;
8704 unsigned int offset;
8706 struct die_info temp_die;
8707 struct dwarf2_cu *target_cu;
8709 offset = dwarf2_get_ref_die_offset (attr, cu);
8711 if (DW_ADDR (attr) < cu->header.offset
8712 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
8714 struct dwarf2_per_cu_data *per_cu;
8715 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
8717 target_cu = per_cu->cu;
8722 h = (offset % REF_HASH_SIZE);
8723 die = target_cu->die_ref_table[h];
8726 if (die->offset == offset)
8728 die = die->next_ref;
8731 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8732 "at 0x%lx [in module %s]"),
8733 (long) src_die->offset, (long) offset, cu->objfile->name);
8738 static struct type *
8739 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
8740 struct dwarf2_cu *cu)
8742 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
8744 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8745 typeid, objfile->name);
8748 /* Look for this particular type in the fundamental type vector. If
8749 one is not found, create and install one appropriate for the
8750 current language and the current target machine. */
8752 if (cu->ftypes[typeid] == NULL)
8754 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8757 return (cu->ftypes[typeid]);
8760 /* Decode simple location descriptions.
8761 Given a pointer to a dwarf block that defines a location, compute
8762 the location and return the value.
8764 NOTE drow/2003-11-18: This function is called in two situations
8765 now: for the address of static or global variables (partial symbols
8766 only) and for offsets into structures which are expected to be
8767 (more or less) constant. The partial symbol case should go away,
8768 and only the constant case should remain. That will let this
8769 function complain more accurately. A few special modes are allowed
8770 without complaint for global variables (for instance, global
8771 register values and thread-local values).
8773 A location description containing no operations indicates that the
8774 object is optimized out. The return value is 0 for that case.
8775 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8776 callers will only want a very basic result and this can become a
8779 Note that stack[0] is unused except as a default error return.
8780 Note that stack overflow is not yet handled. */
8783 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8785 struct objfile *objfile = cu->objfile;
8786 struct comp_unit_head *cu_header = &cu->header;
8788 int size = blk->size;
8789 gdb_byte *data = blk->data;
8790 CORE_ADDR stack[64];
8792 unsigned int bytes_read, unsnd;
8836 stack[++stacki] = op - DW_OP_lit0;
8871 stack[++stacki] = op - DW_OP_reg0;
8873 dwarf2_complex_location_expr_complaint ();
8877 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8879 stack[++stacki] = unsnd;
8881 dwarf2_complex_location_expr_complaint ();
8885 stack[++stacki] = read_address (objfile->obfd, &data[i],
8891 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8896 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8901 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8906 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8911 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8916 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8921 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8927 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8932 stack[stacki + 1] = stack[stacki];
8937 stack[stacki - 1] += stack[stacki];
8941 case DW_OP_plus_uconst:
8942 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8947 stack[stacki - 1] -= stack[stacki];
8952 /* If we're not the last op, then we definitely can't encode
8953 this using GDB's address_class enum. This is valid for partial
8954 global symbols, although the variable's address will be bogus
8957 dwarf2_complex_location_expr_complaint ();
8960 case DW_OP_GNU_push_tls_address:
8961 /* The top of the stack has the offset from the beginning
8962 of the thread control block at which the variable is located. */
8963 /* Nothing should follow this operator, so the top of stack would
8965 /* This is valid for partial global symbols, but the variable's
8966 address will be bogus in the psymtab. */
8968 dwarf2_complex_location_expr_complaint ();
8972 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
8973 dwarf_stack_op_name (op));
8974 return (stack[stacki]);
8977 return (stack[stacki]);
8980 /* memory allocation interface */
8982 static struct dwarf_block *
8983 dwarf_alloc_block (struct dwarf2_cu *cu)
8985 struct dwarf_block *blk;
8987 blk = (struct dwarf_block *)
8988 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8992 static struct abbrev_info *
8993 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8995 struct abbrev_info *abbrev;
8997 abbrev = (struct abbrev_info *)
8998 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
8999 memset (abbrev, 0, sizeof (struct abbrev_info));
9003 static struct die_info *
9004 dwarf_alloc_die (void)
9006 struct die_info *die;
9008 die = (struct die_info *) xmalloc (sizeof (struct die_info));
9009 memset (die, 0, sizeof (struct die_info));
9014 /* Macro support. */
9017 /* Return the full name of file number I in *LH's file name table.
9018 Use COMP_DIR as the name of the current directory of the
9019 compilation. The result is allocated using xmalloc; the caller is
9020 responsible for freeing it. */
9022 file_full_name (int file, struct line_header *lh, const char *comp_dir)
9024 /* Is the file number a valid index into the line header's file name
9025 table? Remember that file numbers start with one, not zero. */
9026 if (1 <= file && file <= lh->num_file_names)
9028 struct file_entry *fe = &lh->file_names[file - 1];
9030 if (IS_ABSOLUTE_PATH (fe->name))
9031 return xstrdup (fe->name);
9039 dir = lh->include_dirs[fe->dir_index - 1];
9045 dir_len = strlen (dir);
9046 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
9047 strcpy (full_name, dir);
9048 full_name[dir_len] = '/';
9049 strcpy (full_name + dir_len + 1, fe->name);
9053 return xstrdup (fe->name);
9058 /* The compiler produced a bogus file number. We can at least
9059 record the macro definitions made in the file, even if we
9060 won't be able to find the file by name. */
9062 sprintf (fake_name, "<bad macro file number %d>", file);
9064 complaint (&symfile_complaints,
9065 _("bad file number in macro information (%d)"),
9068 return xstrdup (fake_name);
9073 static struct macro_source_file *
9074 macro_start_file (int file, int line,
9075 struct macro_source_file *current_file,
9076 const char *comp_dir,
9077 struct line_header *lh, struct objfile *objfile)
9079 /* The full name of this source file. */
9080 char *full_name = file_full_name (file, lh, comp_dir);
9082 /* We don't create a macro table for this compilation unit
9083 at all until we actually get a filename. */
9084 if (! pending_macros)
9085 pending_macros = new_macro_table (&objfile->objfile_obstack,
9086 objfile->macro_cache);
9089 /* If we have no current file, then this must be the start_file
9090 directive for the compilation unit's main source file. */
9091 current_file = macro_set_main (pending_macros, full_name);
9093 current_file = macro_include (current_file, line, full_name);
9097 return current_file;
9101 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9102 followed by a null byte. */
9104 copy_string (const char *buf, int len)
9106 char *s = xmalloc (len + 1);
9107 memcpy (s, buf, len);
9115 consume_improper_spaces (const char *p, const char *body)
9119 complaint (&symfile_complaints,
9120 _("macro definition contains spaces in formal argument list:\n`%s'"),
9132 parse_macro_definition (struct macro_source_file *file, int line,
9137 /* The body string takes one of two forms. For object-like macro
9138 definitions, it should be:
9140 <macro name> " " <definition>
9142 For function-like macro definitions, it should be:
9144 <macro name> "() " <definition>
9146 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9148 Spaces may appear only where explicitly indicated, and in the
9151 The Dwarf 2 spec says that an object-like macro's name is always
9152 followed by a space, but versions of GCC around March 2002 omit
9153 the space when the macro's definition is the empty string.
9155 The Dwarf 2 spec says that there should be no spaces between the
9156 formal arguments in a function-like macro's formal argument list,
9157 but versions of GCC around March 2002 include spaces after the
9161 /* Find the extent of the macro name. The macro name is terminated
9162 by either a space or null character (for an object-like macro) or
9163 an opening paren (for a function-like macro). */
9164 for (p = body; *p; p++)
9165 if (*p == ' ' || *p == '(')
9168 if (*p == ' ' || *p == '\0')
9170 /* It's an object-like macro. */
9171 int name_len = p - body;
9172 char *name = copy_string (body, name_len);
9173 const char *replacement;
9176 replacement = body + name_len + 1;
9179 dwarf2_macro_malformed_definition_complaint (body);
9180 replacement = body + name_len;
9183 macro_define_object (file, line, name, replacement);
9189 /* It's a function-like macro. */
9190 char *name = copy_string (body, p - body);
9193 char **argv = xmalloc (argv_size * sizeof (*argv));
9197 p = consume_improper_spaces (p, body);
9199 /* Parse the formal argument list. */
9200 while (*p && *p != ')')
9202 /* Find the extent of the current argument name. */
9203 const char *arg_start = p;
9205 while (*p && *p != ',' && *p != ')' && *p != ' ')
9208 if (! *p || p == arg_start)
9209 dwarf2_macro_malformed_definition_complaint (body);
9212 /* Make sure argv has room for the new argument. */
9213 if (argc >= argv_size)
9216 argv = xrealloc (argv, argv_size * sizeof (*argv));
9219 argv[argc++] = copy_string (arg_start, p - arg_start);
9222 p = consume_improper_spaces (p, body);
9224 /* Consume the comma, if present. */
9229 p = consume_improper_spaces (p, body);
9238 /* Perfectly formed definition, no complaints. */
9239 macro_define_function (file, line, name,
9240 argc, (const char **) argv,
9242 else if (*p == '\0')
9244 /* Complain, but do define it. */
9245 dwarf2_macro_malformed_definition_complaint (body);
9246 macro_define_function (file, line, name,
9247 argc, (const char **) argv,
9251 /* Just complain. */
9252 dwarf2_macro_malformed_definition_complaint (body);
9255 /* Just complain. */
9256 dwarf2_macro_malformed_definition_complaint (body);
9262 for (i = 0; i < argc; i++)
9268 dwarf2_macro_malformed_definition_complaint (body);
9273 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9274 char *comp_dir, bfd *abfd,
9275 struct dwarf2_cu *cu)
9277 gdb_byte *mac_ptr, *mac_end;
9278 struct macro_source_file *current_file = 0;
9280 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9282 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9286 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9287 mac_end = dwarf2_per_objfile->macinfo_buffer
9288 + dwarf2_per_objfile->macinfo_size;
9292 enum dwarf_macinfo_record_type macinfo_type;
9294 /* Do we at least have room for a macinfo type byte? */
9295 if (mac_ptr >= mac_end)
9297 dwarf2_macros_too_long_complaint ();
9301 macinfo_type = read_1_byte (abfd, mac_ptr);
9304 switch (macinfo_type)
9306 /* A zero macinfo type indicates the end of the macro
9311 case DW_MACINFO_define:
9312 case DW_MACINFO_undef:
9314 unsigned int bytes_read;
9318 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9319 mac_ptr += bytes_read;
9320 body = read_string (abfd, mac_ptr, &bytes_read);
9321 mac_ptr += bytes_read;
9324 complaint (&symfile_complaints,
9325 _("debug info gives macro %s outside of any file: %s"),
9327 DW_MACINFO_define ? "definition" : macinfo_type ==
9328 DW_MACINFO_undef ? "undefinition" :
9329 "something-or-other", body);
9332 if (macinfo_type == DW_MACINFO_define)
9333 parse_macro_definition (current_file, line, body);
9334 else if (macinfo_type == DW_MACINFO_undef)
9335 macro_undef (current_file, line, body);
9340 case DW_MACINFO_start_file:
9342 unsigned int bytes_read;
9345 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9346 mac_ptr += bytes_read;
9347 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9348 mac_ptr += bytes_read;
9350 current_file = macro_start_file (file, line,
9351 current_file, comp_dir,
9356 case DW_MACINFO_end_file:
9358 complaint (&symfile_complaints,
9359 _("macro debug info has an unmatched `close_file' directive"));
9362 current_file = current_file->included_by;
9365 enum dwarf_macinfo_record_type next_type;
9367 /* GCC circa March 2002 doesn't produce the zero
9368 type byte marking the end of the compilation
9369 unit. Complain if it's not there, but exit no
9372 /* Do we at least have room for a macinfo type byte? */
9373 if (mac_ptr >= mac_end)
9375 dwarf2_macros_too_long_complaint ();
9379 /* We don't increment mac_ptr here, so this is just
9381 next_type = read_1_byte (abfd, mac_ptr);
9383 complaint (&symfile_complaints,
9384 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9391 case DW_MACINFO_vendor_ext:
9393 unsigned int bytes_read;
9397 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9398 mac_ptr += bytes_read;
9399 string = read_string (abfd, mac_ptr, &bytes_read);
9400 mac_ptr += bytes_read;
9402 /* We don't recognize any vendor extensions. */
9409 /* Check if the attribute's form is a DW_FORM_block*
9410 if so return true else false. */
9412 attr_form_is_block (struct attribute *attr)
9414 return (attr == NULL ? 0 :
9415 attr->form == DW_FORM_block1
9416 || attr->form == DW_FORM_block2
9417 || attr->form == DW_FORM_block4
9418 || attr->form == DW_FORM_block);
9422 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9423 struct dwarf2_cu *cu)
9425 if ((attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9426 /* ".debug_loc" may not exist at all, or the offset may be outside
9427 the section. If so, fall through to the complaint in the
9429 && DW_UNSND (attr) < dwarf2_per_objfile->loc_size)
9431 struct dwarf2_loclist_baton *baton;
9433 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9434 sizeof (struct dwarf2_loclist_baton));
9435 baton->objfile = cu->objfile;
9437 /* We don't know how long the location list is, but make sure we
9438 don't run off the edge of the section. */
9439 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9440 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9441 baton->base_address = cu->header.base_address;
9442 if (cu->header.base_known == 0)
9443 complaint (&symfile_complaints,
9444 _("Location list used without specifying the CU base address."));
9446 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9447 SYMBOL_LOCATION_BATON (sym) = baton;
9451 struct dwarf2_locexpr_baton *baton;
9453 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9454 sizeof (struct dwarf2_locexpr_baton));
9455 baton->objfile = cu->objfile;
9457 if (attr_form_is_block (attr))
9459 /* Note that we're just copying the block's data pointer
9460 here, not the actual data. We're still pointing into the
9461 info_buffer for SYM's objfile; right now we never release
9462 that buffer, but when we do clean up properly this may
9464 baton->size = DW_BLOCK (attr)->size;
9465 baton->data = DW_BLOCK (attr)->data;
9469 dwarf2_invalid_attrib_class_complaint ("location description",
9470 SYMBOL_NATURAL_NAME (sym));
9475 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9476 SYMBOL_LOCATION_BATON (sym) = baton;
9480 /* Locate the compilation unit from CU's objfile which contains the
9481 DIE at OFFSET. Raises an error on failure. */
9483 static struct dwarf2_per_cu_data *
9484 dwarf2_find_containing_comp_unit (unsigned long offset,
9485 struct objfile *objfile)
9487 struct dwarf2_per_cu_data *this_cu;
9491 high = dwarf2_per_objfile->n_comp_units - 1;
9494 int mid = low + (high - low) / 2;
9495 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9500 gdb_assert (low == high);
9501 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9504 error (_("Dwarf Error: could not find partial DIE containing "
9505 "offset 0x%lx [in module %s]"),
9506 (long) offset, bfd_get_filename (objfile->obfd));
9508 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9509 return dwarf2_per_objfile->all_comp_units[low-1];
9513 this_cu = dwarf2_per_objfile->all_comp_units[low];
9514 if (low == dwarf2_per_objfile->n_comp_units - 1
9515 && offset >= this_cu->offset + this_cu->length)
9516 error (_("invalid dwarf2 offset %ld"), offset);
9517 gdb_assert (offset < this_cu->offset + this_cu->length);
9522 /* Locate the compilation unit from OBJFILE which is located at exactly
9523 OFFSET. Raises an error on failure. */
9525 static struct dwarf2_per_cu_data *
9526 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9528 struct dwarf2_per_cu_data *this_cu;
9529 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9530 if (this_cu->offset != offset)
9531 error (_("no compilation unit with offset %ld."), offset);
9535 /* Release one cached compilation unit, CU. We unlink it from the tree
9536 of compilation units, but we don't remove it from the read_in_chain;
9537 the caller is responsible for that. */
9540 free_one_comp_unit (void *data)
9542 struct dwarf2_cu *cu = data;
9544 if (cu->per_cu != NULL)
9545 cu->per_cu->cu = NULL;
9548 obstack_free (&cu->comp_unit_obstack, NULL);
9550 free_die_list (cu->dies);
9555 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9556 when we're finished with it. We can't free the pointer itself, but be
9557 sure to unlink it from the cache. Also release any associated storage
9558 and perform cache maintenance.
9560 Only used during partial symbol parsing. */
9563 free_stack_comp_unit (void *data)
9565 struct dwarf2_cu *cu = data;
9567 obstack_free (&cu->comp_unit_obstack, NULL);
9568 cu->partial_dies = NULL;
9570 if (cu->per_cu != NULL)
9572 /* This compilation unit is on the stack in our caller, so we
9573 should not xfree it. Just unlink it. */
9574 cu->per_cu->cu = NULL;
9577 /* If we had a per-cu pointer, then we may have other compilation
9578 units loaded, so age them now. */
9579 age_cached_comp_units ();
9583 /* Free all cached compilation units. */
9586 free_cached_comp_units (void *data)
9588 struct dwarf2_per_cu_data *per_cu, **last_chain;
9590 per_cu = dwarf2_per_objfile->read_in_chain;
9591 last_chain = &dwarf2_per_objfile->read_in_chain;
9592 while (per_cu != NULL)
9594 struct dwarf2_per_cu_data *next_cu;
9596 next_cu = per_cu->cu->read_in_chain;
9598 free_one_comp_unit (per_cu->cu);
9599 *last_chain = next_cu;
9605 /* Increase the age counter on each cached compilation unit, and free
9606 any that are too old. */
9609 age_cached_comp_units (void)
9611 struct dwarf2_per_cu_data *per_cu, **last_chain;
9613 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9614 per_cu = dwarf2_per_objfile->read_in_chain;
9615 while (per_cu != NULL)
9617 per_cu->cu->last_used ++;
9618 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9619 dwarf2_mark (per_cu->cu);
9620 per_cu = per_cu->cu->read_in_chain;
9623 per_cu = dwarf2_per_objfile->read_in_chain;
9624 last_chain = &dwarf2_per_objfile->read_in_chain;
9625 while (per_cu != NULL)
9627 struct dwarf2_per_cu_data *next_cu;
9629 next_cu = per_cu->cu->read_in_chain;
9631 if (!per_cu->cu->mark)
9633 free_one_comp_unit (per_cu->cu);
9634 *last_chain = next_cu;
9637 last_chain = &per_cu->cu->read_in_chain;
9643 /* Remove a single compilation unit from the cache. */
9646 free_one_cached_comp_unit (void *target_cu)
9648 struct dwarf2_per_cu_data *per_cu, **last_chain;
9650 per_cu = dwarf2_per_objfile->read_in_chain;
9651 last_chain = &dwarf2_per_objfile->read_in_chain;
9652 while (per_cu != NULL)
9654 struct dwarf2_per_cu_data *next_cu;
9656 next_cu = per_cu->cu->read_in_chain;
9658 if (per_cu->cu == target_cu)
9660 free_one_comp_unit (per_cu->cu);
9661 *last_chain = next_cu;
9665 last_chain = &per_cu->cu->read_in_chain;
9671 /* A pair of DIE offset and GDB type pointer. We store these
9672 in a hash table separate from the DIEs, and preserve them
9673 when the DIEs are flushed out of cache. */
9675 struct dwarf2_offset_and_type
9677 unsigned int offset;
9681 /* Hash function for a dwarf2_offset_and_type. */
9684 offset_and_type_hash (const void *item)
9686 const struct dwarf2_offset_and_type *ofs = item;
9690 /* Equality function for a dwarf2_offset_and_type. */
9693 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9695 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9696 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9697 return ofs_lhs->offset == ofs_rhs->offset;
9700 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9701 table if necessary. */
9704 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
9706 struct dwarf2_offset_and_type **slot, ofs;
9710 if (cu->per_cu == NULL)
9713 if (cu->per_cu->type_hash == NULL)
9714 cu->per_cu->type_hash
9715 = htab_create_alloc_ex (cu->header.length / 24,
9716 offset_and_type_hash,
9719 &cu->objfile->objfile_obstack,
9720 hashtab_obstack_allocate,
9721 dummy_obstack_deallocate);
9723 ofs.offset = die->offset;
9725 slot = (struct dwarf2_offset_and_type **)
9726 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
9727 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
9731 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9732 have a saved type. */
9734 static struct type *
9735 get_die_type (struct die_info *die, htab_t type_hash)
9737 struct dwarf2_offset_and_type *slot, ofs;
9739 ofs.offset = die->offset;
9740 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
9747 /* Restore the types of the DIE tree starting at START_DIE from the hash
9748 table saved in CU. */
9751 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
9753 struct die_info *die;
9755 if (cu->per_cu->type_hash == NULL)
9758 for (die = start_die; die != NULL; die = die->sibling)
9760 die->type = get_die_type (die, cu->per_cu->type_hash);
9761 if (die->child != NULL)
9762 reset_die_and_siblings_types (die->child, cu);
9766 /* Set the mark field in CU and in every other compilation unit in the
9767 cache that we must keep because we are keeping CU. */
9769 /* Add a dependence relationship from CU to REF_PER_CU. */
9772 dwarf2_add_dependence (struct dwarf2_cu *cu,
9773 struct dwarf2_per_cu_data *ref_per_cu)
9777 if (cu->dependencies == NULL)
9779 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
9780 NULL, &cu->comp_unit_obstack,
9781 hashtab_obstack_allocate,
9782 dummy_obstack_deallocate);
9784 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
9789 /* Set the mark field in CU and in every other compilation unit in the
9790 cache that we must keep because we are keeping CU. */
9793 dwarf2_mark_helper (void **slot, void *data)
9795 struct dwarf2_per_cu_data *per_cu;
9797 per_cu = (struct dwarf2_per_cu_data *) *slot;
9798 if (per_cu->cu->mark)
9800 per_cu->cu->mark = 1;
9802 if (per_cu->cu->dependencies != NULL)
9803 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
9809 dwarf2_mark (struct dwarf2_cu *cu)
9814 if (cu->dependencies != NULL)
9815 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
9819 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
9823 per_cu->cu->mark = 0;
9824 per_cu = per_cu->cu->read_in_chain;
9828 /* Trivial hash function for partial_die_info: the hash value of a DIE
9829 is its offset in .debug_info for this objfile. */
9832 partial_die_hash (const void *item)
9834 const struct partial_die_info *part_die = item;
9835 return part_die->offset;
9838 /* Trivial comparison function for partial_die_info structures: two DIEs
9839 are equal if they have the same offset. */
9842 partial_die_eq (const void *item_lhs, const void *item_rhs)
9844 const struct partial_die_info *part_die_lhs = item_lhs;
9845 const struct partial_die_info *part_die_rhs = item_rhs;
9846 return part_die_lhs->offset == part_die_rhs->offset;
9849 static struct cmd_list_element *set_dwarf2_cmdlist;
9850 static struct cmd_list_element *show_dwarf2_cmdlist;
9853 set_dwarf2_cmd (char *args, int from_tty)
9855 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
9859 show_dwarf2_cmd (char *args, int from_tty)
9861 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
9864 void _initialize_dwarf2_read (void);
9867 _initialize_dwarf2_read (void)
9869 dwarf2_objfile_data_key = register_objfile_data ();
9871 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
9872 Set DWARF 2 specific variables.\n\
9873 Configure DWARF 2 variables such as the cache size"),
9874 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
9875 0/*allow-unknown*/, &maintenance_set_cmdlist);
9877 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
9878 Show DWARF 2 specific variables\n\
9879 Show DWARF 2 variables such as the cache size"),
9880 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
9881 0/*allow-unknown*/, &maintenance_show_cmdlist);
9883 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
9884 &dwarf2_max_cache_age, _("\
9885 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9886 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9887 A higher limit means that cached compilation units will be stored\n\
9888 in memory longer, and more total memory will be used. Zero disables\n\
9889 caching, which can slow down startup."),
9891 show_dwarf2_max_cache_age,
9892 &set_dwarf2_cmdlist,
9893 &show_dwarf2_cmdlist);