1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or (at
18 your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 51 Franklin Street, Fifth Floor,
28 Boston, MA 02110-1301, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
52 #include "gdb_string.h"
53 #include "gdb_assert.h"
54 #include <sys/types.h>
56 /* A note on memory usage for this file.
58 At the present time, this code reads the debug info sections into
59 the objfile's objfile_obstack. A definite improvement for startup
60 time, on platforms which do not emit relocations for debug
61 sections, would be to use mmap instead. The object's complete
62 debug information is loaded into memory, partly to simplify
63 absolute DIE references.
65 Whether using obstacks or mmap, the sections should remain loaded
66 until the objfile is released, and pointers into the section data
67 can be used for any other data associated to the objfile (symbol
68 names, type names, location expressions to name a few). */
71 /* .debug_info header for a compilation unit
72 Because of alignment constraints, this structure has padding and cannot
73 be mapped directly onto the beginning of the .debug_info section. */
74 typedef struct comp_unit_header
76 unsigned int length; /* length of the .debug_info
78 unsigned short version; /* version number -- 2 for DWARF
80 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
81 unsigned char addr_size; /* byte size of an address -- 4 */
84 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
87 /* .debug_pubnames header
88 Because of alignment constraints, this structure has padding and cannot
89 be mapped directly onto the beginning of the .debug_info section. */
90 typedef struct pubnames_header
92 unsigned int length; /* length of the .debug_pubnames
94 unsigned char version; /* version number -- 2 for DWARF
96 unsigned int info_offset; /* offset into .debug_info section */
97 unsigned int info_size; /* byte size of .debug_info section
101 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
103 /* .debug_pubnames header
104 Because of alignment constraints, this structure has padding and cannot
105 be mapped directly onto the beginning of the .debug_info section. */
106 typedef struct aranges_header
108 unsigned int length; /* byte len of the .debug_aranges
110 unsigned short version; /* version number -- 2 for DWARF
112 unsigned int info_offset; /* offset into .debug_info section */
113 unsigned char addr_size; /* byte size of an address */
114 unsigned char seg_size; /* byte size of segment descriptor */
117 #define _ACTUAL_ARANGES_HEADER_SIZE 12
119 /* .debug_line statement program prologue
120 Because of alignment constraints, this structure has padding and cannot
121 be mapped directly onto the beginning of the .debug_info section. */
122 typedef struct statement_prologue
124 unsigned int total_length; /* byte length of the statement
126 unsigned short version; /* version number -- 2 for DWARF
128 unsigned int prologue_length; /* # bytes between prologue &
130 unsigned char minimum_instruction_length; /* byte size of
132 unsigned char default_is_stmt; /* initial value of is_stmt
135 unsigned char line_range;
136 unsigned char opcode_base; /* number assigned to first special
138 unsigned char *standard_opcode_lengths;
142 static const struct objfile_data *dwarf2_objfile_data_key;
144 struct dwarf2_per_objfile
146 /* Sizes of debugging sections. */
147 unsigned int info_size;
148 unsigned int abbrev_size;
149 unsigned int line_size;
150 unsigned int pubnames_size;
151 unsigned int aranges_size;
152 unsigned int loc_size;
153 unsigned int macinfo_size;
154 unsigned int str_size;
155 unsigned int ranges_size;
156 unsigned int frame_size;
157 unsigned int eh_frame_size;
159 /* Loaded data from the sections. */
160 gdb_byte *info_buffer;
161 gdb_byte *abbrev_buffer;
162 gdb_byte *line_buffer;
163 gdb_byte *str_buffer;
164 gdb_byte *macinfo_buffer;
165 gdb_byte *ranges_buffer;
166 gdb_byte *loc_buffer;
168 /* A list of all the compilation units. This is used to locate
169 the target compilation unit of a particular reference. */
170 struct dwarf2_per_cu_data **all_comp_units;
172 /* The number of compilation units in ALL_COMP_UNITS. */
175 /* A chain of compilation units that are currently read in, so that
176 they can be freed later. */
177 struct dwarf2_per_cu_data *read_in_chain;
179 /* A flag indicating wether this objfile has a section loaded at a
181 int has_section_at_zero;
184 static struct dwarf2_per_objfile *dwarf2_per_objfile;
186 static asection *dwarf_info_section;
187 static asection *dwarf_abbrev_section;
188 static asection *dwarf_line_section;
189 static asection *dwarf_pubnames_section;
190 static asection *dwarf_aranges_section;
191 static asection *dwarf_loc_section;
192 static asection *dwarf_macinfo_section;
193 static asection *dwarf_str_section;
194 static asection *dwarf_ranges_section;
195 asection *dwarf_frame_section;
196 asection *dwarf_eh_frame_section;
198 /* names of the debugging sections */
200 #define INFO_SECTION ".debug_info"
201 #define ABBREV_SECTION ".debug_abbrev"
202 #define LINE_SECTION ".debug_line"
203 #define PUBNAMES_SECTION ".debug_pubnames"
204 #define ARANGES_SECTION ".debug_aranges"
205 #define LOC_SECTION ".debug_loc"
206 #define MACINFO_SECTION ".debug_macinfo"
207 #define STR_SECTION ".debug_str"
208 #define RANGES_SECTION ".debug_ranges"
209 #define FRAME_SECTION ".debug_frame"
210 #define EH_FRAME_SECTION ".eh_frame"
212 /* local data types */
214 /* We hold several abbreviation tables in memory at the same time. */
215 #ifndef ABBREV_HASH_SIZE
216 #define ABBREV_HASH_SIZE 121
219 /* The data in a compilation unit header, after target2host
220 translation, looks like this. */
221 struct comp_unit_head
223 unsigned long length;
225 unsigned int abbrev_offset;
226 unsigned char addr_size;
227 unsigned char signed_addr_p;
229 /* Size of file offsets; either 4 or 8. */
230 unsigned int offset_size;
232 /* Size of the length field; either 4 or 12. */
233 unsigned int initial_length_size;
235 /* Offset to the first byte of this compilation unit header in the
236 .debug_info section, for resolving relative reference dies. */
239 /* Pointer to this compilation unit header in the .debug_info
241 gdb_byte *cu_head_ptr;
243 /* Pointer to the first die of this compilation unit. This will be
244 the first byte following the compilation unit header. */
245 gdb_byte *first_die_ptr;
247 /* Pointer to the next compilation unit header in the program. */
248 struct comp_unit_head *next;
250 /* Base address of this compilation unit. */
251 CORE_ADDR base_address;
253 /* Non-zero if base_address has been set. */
257 /* Fixed size for the DIE hash table. */
258 #ifndef REF_HASH_SIZE
259 #define REF_HASH_SIZE 1021
262 /* Internal state when decoding a particular compilation unit. */
265 /* The objfile containing this compilation unit. */
266 struct objfile *objfile;
268 /* The header of the compilation unit.
270 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
271 should logically be moved to the dwarf2_cu structure. */
272 struct comp_unit_head header;
274 struct function_range *first_fn, *last_fn, *cached_fn;
276 /* The language we are debugging. */
277 enum language language;
278 const struct language_defn *language_defn;
280 const char *producer;
282 /* The generic symbol table building routines have separate lists for
283 file scope symbols and all all other scopes (local scopes). So
284 we need to select the right one to pass to add_symbol_to_list().
285 We do it by keeping a pointer to the correct list in list_in_scope.
287 FIXME: The original dwarf code just treated the file scope as the
288 first local scope, and all other local scopes as nested local
289 scopes, and worked fine. Check to see if we really need to
290 distinguish these in buildsym.c. */
291 struct pending **list_in_scope;
293 /* Maintain an array of referenced fundamental types for the current
294 compilation unit being read. For DWARF version 1, we have to construct
295 the fundamental types on the fly, since no information about the
296 fundamental types is supplied. Each such fundamental type is created by
297 calling a language dependent routine to create the type, and then a
298 pointer to that type is then placed in the array at the index specified
299 by it's FT_<TYPENAME> value. The array has a fixed size set by the
300 FT_NUM_MEMBERS compile time constant, which is the number of predefined
301 fundamental types gdb knows how to construct. */
302 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
304 /* DWARF abbreviation table associated with this compilation unit. */
305 struct abbrev_info **dwarf2_abbrevs;
307 /* Storage for the abbrev table. */
308 struct obstack abbrev_obstack;
310 /* Hash table holding all the loaded partial DIEs. */
313 /* Storage for things with the same lifetime as this read-in compilation
314 unit, including partial DIEs. */
315 struct obstack comp_unit_obstack;
317 /* When multiple dwarf2_cu structures are living in memory, this field
318 chains them all together, so that they can be released efficiently.
319 We will probably also want a generation counter so that most-recently-used
320 compilation units are cached... */
321 struct dwarf2_per_cu_data *read_in_chain;
323 /* Backchain to our per_cu entry if the tree has been built. */
324 struct dwarf2_per_cu_data *per_cu;
326 /* How many compilation units ago was this CU last referenced? */
329 /* A hash table of die offsets for following references. */
330 struct die_info *die_ref_table[REF_HASH_SIZE];
332 /* Full DIEs if read in. */
333 struct die_info *dies;
335 /* A set of pointers to dwarf2_per_cu_data objects for compilation
336 units referenced by this one. Only set during full symbol processing;
337 partial symbol tables do not have dependencies. */
340 /* Header data from the line table, during full symbol processing. */
341 struct line_header *line_header;
343 /* Mark used when releasing cached dies. */
344 unsigned int mark : 1;
346 /* This flag will be set if this compilation unit might include
347 inter-compilation-unit references. */
348 unsigned int has_form_ref_addr : 1;
350 /* This flag will be set if this compilation unit includes any
351 DW_TAG_namespace DIEs. If we know that there are explicit
352 DIEs for namespaces, we don't need to try to infer them
353 from mangled names. */
354 unsigned int has_namespace_info : 1;
357 /* Persistent data held for a compilation unit, even when not
358 processing it. We put a pointer to this structure in the
359 read_symtab_private field of the psymtab. If we encounter
360 inter-compilation-unit references, we also maintain a sorted
361 list of all compilation units. */
363 struct dwarf2_per_cu_data
365 /* The start offset and length of this compilation unit. 2**30-1
366 bytes should suffice to store the length of any compilation unit
367 - if it doesn't, GDB will fall over anyway. */
368 unsigned long offset;
369 unsigned long length : 30;
371 /* Flag indicating this compilation unit will be read in before
372 any of the current compilation units are processed. */
373 unsigned long queued : 1;
375 /* This flag will be set if we need to load absolutely all DIEs
376 for this compilation unit, instead of just the ones we think
377 are interesting. It gets set if we look for a DIE in the
378 hash table and don't find it. */
379 unsigned int load_all_dies : 1;
381 /* Set iff currently read in. */
382 struct dwarf2_cu *cu;
384 /* If full symbols for this CU have been read in, then this field
385 holds a map of DIE offsets to types. It isn't always possible
386 to reconstruct this information later, so we have to preserve
390 /* The partial symbol table associated with this compilation unit,
391 or NULL for partial units (which do not have an associated
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. */
434 struct symtab *symtab; /* The associated symbol table, if any. */
437 /* The start and end of the statement program following this
438 header. These point into dwarf2_per_objfile->line_buffer. */
439 gdb_byte *statement_program_start, *statement_program_end;
442 /* When we construct a partial symbol table entry we only
443 need this much information. */
444 struct partial_die_info
446 /* Offset of this DIE. */
449 /* DWARF-2 tag for this DIE. */
450 ENUM_BITFIELD(dwarf_tag) tag : 16;
452 /* Language code associated with this DIE. This is only used
453 for the compilation unit DIE. */
454 unsigned int language : 8;
456 /* Assorted flags describing the data found in this DIE. */
457 unsigned int has_children : 1;
458 unsigned int is_external : 1;
459 unsigned int is_declaration : 1;
460 unsigned int has_type : 1;
461 unsigned int has_specification : 1;
462 unsigned int has_stmt_list : 1;
463 unsigned int has_pc_info : 1;
465 /* Flag set if the SCOPE field of this structure has been
467 unsigned int scope_set : 1;
469 /* Flag set if the DIE has a byte_size attribute. */
470 unsigned int has_byte_size : 1;
472 /* The name of this DIE. Normally the value of DW_AT_name, but
473 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
478 /* The scope to prepend to our children. This is generally
479 allocated on the comp_unit_obstack, so will disappear
480 when this compilation unit leaves the cache. */
483 /* The location description associated with this DIE, if any. */
484 struct dwarf_block *locdesc;
486 /* If HAS_PC_INFO, the PC range associated with this DIE. */
490 /* Pointer into the info_buffer pointing at the target of
491 DW_AT_sibling, if any. */
494 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
495 DW_AT_specification (or DW_AT_abstract_origin or
497 unsigned int spec_offset;
499 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
500 unsigned int line_offset;
502 /* Pointers to this DIE's parent, first child, and next sibling,
504 struct partial_die_info *die_parent, *die_child, *die_sibling;
507 /* This data structure holds the information of an abbrev. */
510 unsigned int number; /* number identifying abbrev */
511 enum dwarf_tag tag; /* dwarf tag */
512 unsigned short has_children; /* boolean */
513 unsigned short num_attrs; /* number of attributes */
514 struct attr_abbrev *attrs; /* an array of attribute descriptions */
515 struct abbrev_info *next; /* next in chain */
520 enum dwarf_attribute name;
521 enum dwarf_form form;
524 /* This data structure holds a complete die structure. */
527 enum dwarf_tag tag; /* Tag indicating type of die */
528 unsigned int abbrev; /* Abbrev number */
529 unsigned int offset; /* Offset in .debug_info section */
530 unsigned int num_attrs; /* Number of attributes */
531 struct attribute *attrs; /* An array of attributes */
532 struct die_info *next_ref; /* Next die in ref hash table */
534 /* The dies in a compilation unit form an n-ary tree. PARENT
535 points to this die's parent; CHILD points to the first child of
536 this node; and all the children of a given node are chained
537 together via their SIBLING fields, terminated by a die whose
539 struct die_info *child; /* Its first child, if any. */
540 struct die_info *sibling; /* Its next sibling, if any. */
541 struct die_info *parent; /* Its parent, if any. */
543 struct type *type; /* Cached type information */
546 /* Attributes have a name and a value */
549 enum dwarf_attribute name;
550 enum dwarf_form form;
554 struct dwarf_block *blk;
562 struct function_range
565 CORE_ADDR lowpc, highpc;
567 struct function_range *next;
570 /* Get at parts of an attribute structure */
572 #define DW_STRING(attr) ((attr)->u.str)
573 #define DW_UNSND(attr) ((attr)->u.unsnd)
574 #define DW_BLOCK(attr) ((attr)->u.blk)
575 #define DW_SND(attr) ((attr)->u.snd)
576 #define DW_ADDR(attr) ((attr)->u.addr)
578 /* Blocks are a bunch of untyped bytes. */
585 #ifndef ATTR_ALLOC_CHUNK
586 #define ATTR_ALLOC_CHUNK 4
589 /* Allocate fields for structs, unions and enums in this size. */
590 #ifndef DW_FIELD_ALLOC_CHUNK
591 #define DW_FIELD_ALLOC_CHUNK 4
594 /* A zeroed version of a partial die for initialization purposes. */
595 static struct partial_die_info zeroed_partial_die;
597 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
598 but this would require a corresponding change in unpack_field_as_long
600 static int bits_per_byte = 8;
602 /* The routines that read and process dies for a C struct or C++ class
603 pass lists of data member fields and lists of member function fields
604 in an instance of a field_info structure, as defined below. */
607 /* List of data member and baseclasses fields. */
610 struct nextfield *next;
617 /* Number of fields. */
620 /* Number of baseclasses. */
623 /* Set if the accesibility of one of the fields is not public. */
624 int non_public_fields;
626 /* Member function fields array, entries are allocated in the order they
627 are encountered in the object file. */
630 struct nextfnfield *next;
631 struct fn_field fnfield;
635 /* Member function fieldlist array, contains name of possibly overloaded
636 member function, number of overloaded member functions and a pointer
637 to the head of the member function field chain. */
642 struct nextfnfield *head;
646 /* Number of entries in the fnfieldlists array. */
650 /* One item on the queue of compilation units to read in full symbols
652 struct dwarf2_queue_item
654 struct dwarf2_per_cu_data *per_cu;
655 struct dwarf2_queue_item *next;
658 /* The current queue. */
659 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
661 /* Loaded secondary compilation units are kept in memory until they
662 have not been referenced for the processing of this many
663 compilation units. Set this to zero to disable caching. Cache
664 sizes of up to at least twenty will improve startup time for
665 typical inter-CU-reference binaries, at an obvious memory cost. */
666 static int dwarf2_max_cache_age = 5;
668 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
669 struct cmd_list_element *c, const char *value)
671 fprintf_filtered (file, _("\
672 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
677 /* Various complaints about symbol reading that don't abort the process */
680 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
682 complaint (&symfile_complaints,
683 _("statement list doesn't fit in .debug_line section"));
687 dwarf2_debug_line_missing_file_complaint (void)
689 complaint (&symfile_complaints,
690 _(".debug_line section has line data without a file"));
694 dwarf2_complex_location_expr_complaint (void)
696 complaint (&symfile_complaints, _("location expression too complex"));
700 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
703 complaint (&symfile_complaints,
704 _("const value length mismatch for '%s', got %d, expected %d"), arg1,
709 dwarf2_macros_too_long_complaint (void)
711 complaint (&symfile_complaints,
712 _("macro info runs off end of `.debug_macinfo' section"));
716 dwarf2_macro_malformed_definition_complaint (const char *arg1)
718 complaint (&symfile_complaints,
719 _("macro debug info contains a malformed macro definition:\n`%s'"),
724 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
726 complaint (&symfile_complaints,
727 _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
730 /* local function prototypes */
732 static void dwarf2_locate_sections (bfd *, asection *, void *);
735 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
738 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
741 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
742 struct partial_die_info *,
743 struct partial_symtab *);
745 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
747 static void scan_partial_symbols (struct partial_die_info *,
748 CORE_ADDR *, CORE_ADDR *,
751 static void add_partial_symbol (struct partial_die_info *,
754 static int pdi_needs_namespace (enum dwarf_tag tag);
756 static void add_partial_namespace (struct partial_die_info *pdi,
757 CORE_ADDR *lowpc, CORE_ADDR *highpc,
758 struct dwarf2_cu *cu);
760 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
761 struct dwarf2_cu *cu);
763 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
766 struct dwarf2_cu *cu);
768 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
770 static void psymtab_to_symtab_1 (struct partial_symtab *);
772 gdb_byte *dwarf2_read_section (struct objfile *, asection *);
774 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
776 static void dwarf2_free_abbrev_table (void *);
778 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
781 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
784 static struct partial_die_info *load_partial_dies (bfd *, gdb_byte *, int,
787 static gdb_byte *read_partial_die (struct partial_die_info *,
788 struct abbrev_info *abbrev, unsigned int,
789 bfd *, gdb_byte *, struct dwarf2_cu *);
791 static struct partial_die_info *find_partial_die (unsigned long,
794 static void fixup_partial_die (struct partial_die_info *,
797 static gdb_byte *read_full_die (struct die_info **, bfd *, gdb_byte *,
798 struct dwarf2_cu *, int *);
800 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
801 bfd *, gdb_byte *, struct dwarf2_cu *);
803 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
804 bfd *, gdb_byte *, struct dwarf2_cu *);
806 static unsigned int read_1_byte (bfd *, gdb_byte *);
808 static int read_1_signed_byte (bfd *, gdb_byte *);
810 static unsigned int read_2_bytes (bfd *, gdb_byte *);
812 static unsigned int read_4_bytes (bfd *, gdb_byte *);
814 static unsigned long read_8_bytes (bfd *, gdb_byte *);
816 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
819 static LONGEST read_initial_length (bfd *, gdb_byte *,
820 struct comp_unit_head *, unsigned int *);
822 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
825 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
827 static char *read_string (bfd *, gdb_byte *, unsigned int *);
829 static char *read_indirect_string (bfd *, gdb_byte *,
830 const struct comp_unit_head *,
833 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
835 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
837 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
839 static void set_cu_language (unsigned int, struct dwarf2_cu *);
841 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
844 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
845 struct dwarf2_cu *cu);
847 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
849 static struct die_info *die_specification (struct die_info *die,
852 static void free_line_header (struct line_header *lh);
854 static void add_file_name (struct line_header *, char *, unsigned int,
855 unsigned int, unsigned int);
857 static struct line_header *(dwarf_decode_line_header
858 (unsigned int offset,
859 bfd *abfd, struct dwarf2_cu *cu));
861 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
862 struct dwarf2_cu *, struct partial_symtab *);
864 static void dwarf2_start_subfile (char *, char *, char *);
866 static struct symbol *new_symbol (struct die_info *, struct type *,
869 static void dwarf2_const_value (struct attribute *, struct symbol *,
872 static void dwarf2_const_value_data (struct attribute *attr,
876 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
878 static struct type *die_containing_type (struct die_info *,
881 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
883 static void read_type_die (struct die_info *, struct dwarf2_cu *);
885 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
887 static char *typename_concat (struct obstack *,
892 static void read_typedef (struct die_info *, struct dwarf2_cu *);
894 static void read_base_type (struct die_info *, struct dwarf2_cu *);
896 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
898 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
900 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
902 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
904 static int dwarf2_get_pc_bounds (struct die_info *,
905 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
907 static void get_scope_pc_bounds (struct die_info *,
908 CORE_ADDR *, CORE_ADDR *,
911 static void dwarf2_add_field (struct field_info *, struct die_info *,
914 static void dwarf2_attach_fields_to_type (struct field_info *,
915 struct type *, struct dwarf2_cu *);
917 static void dwarf2_add_member_fn (struct field_info *,
918 struct die_info *, struct type *,
921 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
922 struct type *, struct dwarf2_cu *);
924 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
926 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
928 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
930 static void read_common_block (struct die_info *, struct dwarf2_cu *);
932 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
934 static const char *namespace_name (struct die_info *die,
935 int *is_anonymous, struct dwarf2_cu *);
937 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
939 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
941 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
943 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
945 static void read_array_type (struct die_info *, struct dwarf2_cu *);
947 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
950 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
952 static void read_tag_ptr_to_member_type (struct die_info *,
955 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
957 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
959 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
961 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
963 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
965 static struct die_info *read_comp_unit (gdb_byte *, bfd *, struct dwarf2_cu *);
967 static struct die_info *read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
969 gdb_byte **new_info_ptr,
970 struct die_info *parent);
972 static struct die_info *read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
974 gdb_byte **new_info_ptr,
975 struct die_info *parent);
977 static void free_die_list (struct die_info *);
979 static void process_die (struct die_info *, struct dwarf2_cu *);
981 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
983 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
985 static struct die_info *dwarf2_extension (struct die_info *die,
988 static char *dwarf_tag_name (unsigned int);
990 static char *dwarf_attr_name (unsigned int);
992 static char *dwarf_form_name (unsigned int);
994 static char *dwarf_stack_op_name (unsigned int);
996 static char *dwarf_bool_name (unsigned int);
998 static char *dwarf_type_encoding_name (unsigned int);
1001 static char *dwarf_cfi_name (unsigned int);
1003 struct die_info *copy_die (struct die_info *);
1006 static struct die_info *sibling_die (struct die_info *);
1008 static void dump_die (struct die_info *);
1010 static void dump_die_list (struct die_info *);
1012 static void store_in_ref_table (unsigned int, struct die_info *,
1013 struct dwarf2_cu *);
1015 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
1016 struct dwarf2_cu *);
1018 static int dwarf2_get_attr_constant_value (struct attribute *, int);
1020 static struct die_info *follow_die_ref (struct die_info *,
1022 struct dwarf2_cu *);
1024 static struct type *dwarf2_fundamental_type (struct objfile *, int,
1025 struct dwarf2_cu *);
1027 /* memory allocation interface */
1029 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1031 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1033 static struct die_info *dwarf_alloc_die (void);
1035 static void initialize_cu_func_list (struct dwarf2_cu *);
1037 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1038 struct dwarf2_cu *);
1040 static void dwarf_decode_macros (struct line_header *, unsigned int,
1041 char *, bfd *, struct dwarf2_cu *);
1043 static int attr_form_is_block (struct attribute *);
1045 static void dwarf2_symbol_mark_computed (struct attribute *attr,
1047 struct dwarf2_cu *cu);
1049 static gdb_byte *skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
1050 struct dwarf2_cu *cu);
1052 static void free_stack_comp_unit (void *);
1054 static hashval_t partial_die_hash (const void *item);
1056 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1058 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1059 (unsigned long offset, struct objfile *objfile);
1061 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1062 (unsigned long offset, struct objfile *objfile);
1064 static void free_one_comp_unit (void *);
1066 static void free_cached_comp_units (void *);
1068 static void age_cached_comp_units (void);
1070 static void free_one_cached_comp_unit (void *);
1072 static void set_die_type (struct die_info *, struct type *,
1073 struct dwarf2_cu *);
1075 static void reset_die_and_siblings_types (struct die_info *,
1076 struct dwarf2_cu *);
1078 static void create_all_comp_units (struct objfile *);
1080 static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *,
1083 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1085 static void dwarf2_add_dependence (struct dwarf2_cu *,
1086 struct dwarf2_per_cu_data *);
1088 static void dwarf2_mark (struct dwarf2_cu *);
1090 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1092 static void read_set_type (struct die_info *, struct dwarf2_cu *);
1095 /* Try to locate the sections we need for DWARF 2 debugging
1096 information and return true if we have enough to do something. */
1099 dwarf2_has_info (struct objfile *objfile)
1101 struct dwarf2_per_objfile *data;
1103 /* Initialize per-objfile state. */
1104 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1105 memset (data, 0, sizeof (*data));
1106 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1107 dwarf2_per_objfile = data;
1109 dwarf_info_section = 0;
1110 dwarf_abbrev_section = 0;
1111 dwarf_line_section = 0;
1112 dwarf_str_section = 0;
1113 dwarf_macinfo_section = 0;
1114 dwarf_frame_section = 0;
1115 dwarf_eh_frame_section = 0;
1116 dwarf_ranges_section = 0;
1117 dwarf_loc_section = 0;
1119 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1120 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
1123 /* This function is mapped across the sections and remembers the
1124 offset and size of each of the debugging sections we are interested
1128 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *ignore_ptr)
1130 if (strcmp (sectp->name, INFO_SECTION) == 0)
1132 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1133 dwarf_info_section = sectp;
1135 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1137 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1138 dwarf_abbrev_section = sectp;
1140 else if (strcmp (sectp->name, LINE_SECTION) == 0)
1142 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1143 dwarf_line_section = sectp;
1145 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1147 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1148 dwarf_pubnames_section = sectp;
1150 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1152 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1153 dwarf_aranges_section = sectp;
1155 else if (strcmp (sectp->name, LOC_SECTION) == 0)
1157 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1158 dwarf_loc_section = sectp;
1160 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1162 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1163 dwarf_macinfo_section = sectp;
1165 else if (strcmp (sectp->name, STR_SECTION) == 0)
1167 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1168 dwarf_str_section = sectp;
1170 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1172 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1173 dwarf_frame_section = sectp;
1175 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1177 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1178 if (aflag & SEC_HAS_CONTENTS)
1180 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1181 dwarf_eh_frame_section = sectp;
1184 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1186 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1187 dwarf_ranges_section = sectp;
1190 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1191 && bfd_section_vma (abfd, sectp) == 0)
1192 dwarf2_per_objfile->has_section_at_zero = 1;
1195 /* Build a partial symbol table. */
1198 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1200 /* We definitely need the .debug_info and .debug_abbrev sections */
1202 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1203 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1205 if (dwarf_line_section)
1206 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1208 dwarf2_per_objfile->line_buffer = NULL;
1210 if (dwarf_str_section)
1211 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1213 dwarf2_per_objfile->str_buffer = NULL;
1215 if (dwarf_macinfo_section)
1216 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1217 dwarf_macinfo_section);
1219 dwarf2_per_objfile->macinfo_buffer = NULL;
1221 if (dwarf_ranges_section)
1222 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1224 dwarf2_per_objfile->ranges_buffer = NULL;
1226 if (dwarf_loc_section)
1227 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1229 dwarf2_per_objfile->loc_buffer = NULL;
1232 || (objfile->global_psymbols.size == 0
1233 && objfile->static_psymbols.size == 0))
1235 init_psymbol_list (objfile, 1024);
1239 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1241 /* Things are significantly easier if we have .debug_aranges and
1242 .debug_pubnames sections */
1244 dwarf2_build_psymtabs_easy (objfile, mainline);
1248 /* only test this case for now */
1250 /* In this case we have to work a bit harder */
1251 dwarf2_build_psymtabs_hard (objfile, mainline);
1256 /* Build the partial symbol table from the information in the
1257 .debug_pubnames and .debug_aranges sections. */
1260 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1262 bfd *abfd = objfile->obfd;
1263 char *aranges_buffer, *pubnames_buffer;
1264 char *aranges_ptr, *pubnames_ptr;
1265 unsigned int entry_length, version, info_offset, info_size;
1267 pubnames_buffer = dwarf2_read_section (objfile,
1268 dwarf_pubnames_section);
1269 pubnames_ptr = pubnames_buffer;
1270 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1272 struct comp_unit_head cu_header;
1273 unsigned int bytes_read;
1275 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1277 pubnames_ptr += bytes_read;
1278 version = read_1_byte (abfd, pubnames_ptr);
1280 info_offset = read_4_bytes (abfd, pubnames_ptr);
1282 info_size = read_4_bytes (abfd, pubnames_ptr);
1286 aranges_buffer = dwarf2_read_section (objfile,
1287 dwarf_aranges_section);
1292 /* Read in the comp unit header information from the debug_info at
1296 read_comp_unit_head (struct comp_unit_head *cu_header,
1297 gdb_byte *info_ptr, bfd *abfd)
1300 unsigned int bytes_read;
1301 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1303 info_ptr += bytes_read;
1304 cu_header->version = read_2_bytes (abfd, info_ptr);
1306 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1308 info_ptr += bytes_read;
1309 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1311 signed_addr = bfd_get_sign_extend_vma (abfd);
1312 if (signed_addr < 0)
1313 internal_error (__FILE__, __LINE__,
1314 _("read_comp_unit_head: dwarf from non elf file"));
1315 cu_header->signed_addr_p = signed_addr;
1320 partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
1323 gdb_byte *beg_of_comp_unit = info_ptr;
1325 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1327 if (header->version != 2 && header->version != 3)
1328 error (_("Dwarf Error: wrong version in compilation unit header "
1329 "(is %d, should be %d) [in module %s]"), header->version,
1330 2, bfd_get_filename (abfd));
1332 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1333 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1334 "(offset 0x%lx + 6) [in module %s]"),
1335 (long) header->abbrev_offset,
1336 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1337 bfd_get_filename (abfd));
1339 if (beg_of_comp_unit + header->length + header->initial_length_size
1340 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1341 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1342 "(offset 0x%lx + 0) [in module %s]"),
1343 (long) header->length,
1344 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1345 bfd_get_filename (abfd));
1350 /* Allocate a new partial symtab for file named NAME and mark this new
1351 partial symtab as being an include of PST. */
1354 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1355 struct objfile *objfile)
1357 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1359 subpst->section_offsets = pst->section_offsets;
1360 subpst->textlow = 0;
1361 subpst->texthigh = 0;
1363 subpst->dependencies = (struct partial_symtab **)
1364 obstack_alloc (&objfile->objfile_obstack,
1365 sizeof (struct partial_symtab *));
1366 subpst->dependencies[0] = pst;
1367 subpst->number_of_dependencies = 1;
1369 subpst->globals_offset = 0;
1370 subpst->n_global_syms = 0;
1371 subpst->statics_offset = 0;
1372 subpst->n_static_syms = 0;
1373 subpst->symtab = NULL;
1374 subpst->read_symtab = pst->read_symtab;
1377 /* No private part is necessary for include psymtabs. This property
1378 can be used to differentiate between such include psymtabs and
1379 the regular ones. */
1380 subpst->read_symtab_private = NULL;
1383 /* Read the Line Number Program data and extract the list of files
1384 included by the source file represented by PST. Build an include
1385 partial symtab for each of these included files.
1387 This procedure assumes that there *is* a Line Number Program in
1388 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1389 before calling this procedure. */
1392 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1393 struct partial_die_info *pdi,
1394 struct partial_symtab *pst)
1396 struct objfile *objfile = cu->objfile;
1397 bfd *abfd = objfile->obfd;
1398 struct line_header *lh;
1400 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1402 return; /* No linetable, so no includes. */
1404 dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1406 free_line_header (lh);
1410 /* Build the partial symbol table by doing a quick pass through the
1411 .debug_info and .debug_abbrev sections. */
1414 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1416 /* Instead of reading this into a big buffer, we should probably use
1417 mmap() on architectures that support it. (FIXME) */
1418 bfd *abfd = objfile->obfd;
1420 gdb_byte *beg_of_comp_unit;
1421 struct partial_die_info comp_unit_die;
1422 struct partial_symtab *pst;
1423 struct cleanup *back_to;
1424 CORE_ADDR lowpc, highpc, baseaddr;
1426 info_ptr = dwarf2_per_objfile->info_buffer;
1428 /* Any cached compilation units will be linked by the per-objfile
1429 read_in_chain. Make sure to free them when we're done. */
1430 back_to = make_cleanup (free_cached_comp_units, NULL);
1432 create_all_comp_units (objfile);
1434 /* Since the objects we're extracting from .debug_info vary in
1435 length, only the individual functions to extract them (like
1436 read_comp_unit_head and load_partial_die) can really know whether
1437 the buffer is large enough to hold another complete object.
1439 At the moment, they don't actually check that. If .debug_info
1440 holds just one extra byte after the last compilation unit's dies,
1441 then read_comp_unit_head will happily read off the end of the
1442 buffer. read_partial_die is similarly casual. Those functions
1445 For this loop condition, simply checking whether there's any data
1446 left at all should be sufficient. */
1447 while (info_ptr < (dwarf2_per_objfile->info_buffer
1448 + dwarf2_per_objfile->info_size))
1450 struct cleanup *back_to_inner;
1451 struct dwarf2_cu cu;
1452 struct abbrev_info *abbrev;
1453 unsigned int bytes_read;
1454 struct dwarf2_per_cu_data *this_cu;
1456 beg_of_comp_unit = info_ptr;
1458 memset (&cu, 0, sizeof (cu));
1460 obstack_init (&cu.comp_unit_obstack);
1462 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1464 cu.objfile = objfile;
1465 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1467 /* Complete the cu_header */
1468 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1469 cu.header.first_die_ptr = info_ptr;
1470 cu.header.cu_head_ptr = beg_of_comp_unit;
1472 cu.list_in_scope = &file_symbols;
1474 /* Read the abbrevs for this compilation unit into a table */
1475 dwarf2_read_abbrevs (abfd, &cu);
1476 make_cleanup (dwarf2_free_abbrev_table, &cu);
1478 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile);
1480 /* Read the compilation unit die */
1481 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1482 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1483 abfd, info_ptr, &cu);
1485 if (comp_unit_die.tag == DW_TAG_partial_unit)
1487 info_ptr = (beg_of_comp_unit + cu.header.length
1488 + cu.header.initial_length_size);
1489 do_cleanups (back_to_inner);
1493 /* Set the language we're debugging */
1494 set_cu_language (comp_unit_die.language, &cu);
1496 /* Allocate a new partial symbol table structure */
1497 pst = start_psymtab_common (objfile, objfile->section_offsets,
1498 comp_unit_die.name ? comp_unit_die.name : "",
1499 comp_unit_die.lowpc,
1500 objfile->global_psymbols.next,
1501 objfile->static_psymbols.next);
1503 if (comp_unit_die.dirname)
1504 pst->dirname = xstrdup (comp_unit_die.dirname);
1506 pst->read_symtab_private = (char *) this_cu;
1508 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1510 /* Store the function that reads in the rest of the symbol table */
1511 pst->read_symtab = dwarf2_psymtab_to_symtab;
1513 /* If this compilation unit was already read in, free the
1514 cached copy in order to read it in again. This is
1515 necessary because we skipped some symbols when we first
1516 read in the compilation unit (see load_partial_dies).
1517 This problem could be avoided, but the benefit is
1519 if (this_cu->cu != NULL)
1520 free_one_cached_comp_unit (this_cu->cu);
1522 cu.per_cu = this_cu;
1524 /* Note that this is a pointer to our stack frame, being
1525 added to a global data structure. It will be cleaned up
1526 in free_stack_comp_unit when we finish with this
1527 compilation unit. */
1530 this_cu->psymtab = pst;
1532 /* Check if comp unit has_children.
1533 If so, read the rest of the partial symbols from this comp unit.
1534 If not, there's no more debug_info for this comp unit. */
1535 if (comp_unit_die.has_children)
1537 struct partial_die_info *first_die;
1539 lowpc = ((CORE_ADDR) -1);
1540 highpc = ((CORE_ADDR) 0);
1542 first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1544 scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1546 /* If we didn't find a lowpc, set it to highpc to avoid
1547 complaints from `maint check'. */
1548 if (lowpc == ((CORE_ADDR) -1))
1551 /* If the compilation unit didn't have an explicit address range,
1552 then use the information extracted from its child dies. */
1553 if (! comp_unit_die.has_pc_info)
1555 comp_unit_die.lowpc = lowpc;
1556 comp_unit_die.highpc = highpc;
1559 pst->textlow = comp_unit_die.lowpc + baseaddr;
1560 pst->texthigh = comp_unit_die.highpc + baseaddr;
1562 pst->n_global_syms = objfile->global_psymbols.next -
1563 (objfile->global_psymbols.list + pst->globals_offset);
1564 pst->n_static_syms = objfile->static_psymbols.next -
1565 (objfile->static_psymbols.list + pst->statics_offset);
1566 sort_pst_symbols (pst);
1568 /* If there is already a psymtab or symtab for a file of this
1569 name, remove it. (If there is a symtab, more drastic things
1570 also happen.) This happens in VxWorks. */
1571 free_named_symtabs (pst->filename);
1573 info_ptr = beg_of_comp_unit + cu.header.length
1574 + cu.header.initial_length_size;
1576 if (comp_unit_die.has_stmt_list)
1578 /* Get the list of files included in the current compilation unit,
1579 and build a psymtab for each of them. */
1580 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1583 do_cleanups (back_to_inner);
1585 do_cleanups (back_to);
1588 /* Load the DIEs for a secondary CU into memory. */
1591 load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile)
1593 bfd *abfd = objfile->obfd;
1594 gdb_byte *info_ptr, *beg_of_comp_unit;
1595 struct partial_die_info comp_unit_die;
1596 struct dwarf2_cu *cu;
1597 struct abbrev_info *abbrev;
1598 unsigned int bytes_read;
1599 struct cleanup *back_to;
1601 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset;
1602 beg_of_comp_unit = info_ptr;
1604 cu = xmalloc (sizeof (struct dwarf2_cu));
1605 memset (cu, 0, sizeof (struct dwarf2_cu));
1607 obstack_init (&cu->comp_unit_obstack);
1609 cu->objfile = objfile;
1610 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd);
1612 /* Complete the cu_header. */
1613 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1614 cu->header.first_die_ptr = info_ptr;
1615 cu->header.cu_head_ptr = beg_of_comp_unit;
1617 /* Read the abbrevs for this compilation unit into a table. */
1618 dwarf2_read_abbrevs (abfd, cu);
1619 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
1621 /* Read the compilation unit die. */
1622 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1623 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1624 abfd, info_ptr, cu);
1626 /* Set the language we're debugging. */
1627 set_cu_language (comp_unit_die.language, cu);
1629 /* Link this compilation unit into the compilation unit tree. */
1631 cu->per_cu = this_cu;
1633 /* Check if comp unit has_children.
1634 If so, read the rest of the partial symbols from this comp unit.
1635 If not, there's no more debug_info for this comp unit. */
1636 if (comp_unit_die.has_children)
1637 load_partial_dies (abfd, info_ptr, 0, cu);
1639 do_cleanups (back_to);
1642 /* Create a list of all compilation units in OBJFILE. We do this only
1643 if an inter-comp-unit reference is found; presumably if there is one,
1644 there will be many, and one will occur early in the .debug_info section.
1645 So there's no point in building this list incrementally. */
1648 create_all_comp_units (struct objfile *objfile)
1652 struct dwarf2_per_cu_data **all_comp_units;
1653 gdb_byte *info_ptr = dwarf2_per_objfile->info_buffer;
1657 all_comp_units = xmalloc (n_allocated
1658 * sizeof (struct dwarf2_per_cu_data *));
1660 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1662 struct comp_unit_head cu_header;
1663 gdb_byte *beg_of_comp_unit;
1664 struct dwarf2_per_cu_data *this_cu;
1665 unsigned long offset;
1666 unsigned int bytes_read;
1668 offset = info_ptr - dwarf2_per_objfile->info_buffer;
1670 /* Read just enough information to find out where the next
1671 compilation unit is. */
1672 cu_header.initial_length_size = 0;
1673 cu_header.length = read_initial_length (objfile->obfd, info_ptr,
1674 &cu_header, &bytes_read);
1676 /* Save the compilation unit for later lookup. */
1677 this_cu = obstack_alloc (&objfile->objfile_obstack,
1678 sizeof (struct dwarf2_per_cu_data));
1679 memset (this_cu, 0, sizeof (*this_cu));
1680 this_cu->offset = offset;
1681 this_cu->length = cu_header.length + cu_header.initial_length_size;
1683 if (n_comp_units == n_allocated)
1686 all_comp_units = xrealloc (all_comp_units,
1688 * sizeof (struct dwarf2_per_cu_data *));
1690 all_comp_units[n_comp_units++] = this_cu;
1692 info_ptr = info_ptr + this_cu->length;
1695 dwarf2_per_objfile->all_comp_units
1696 = obstack_alloc (&objfile->objfile_obstack,
1697 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1698 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
1699 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1700 xfree (all_comp_units);
1701 dwarf2_per_objfile->n_comp_units = n_comp_units;
1704 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1705 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1709 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1710 CORE_ADDR *highpc, struct dwarf2_cu *cu)
1712 struct objfile *objfile = cu->objfile;
1713 bfd *abfd = objfile->obfd;
1714 struct partial_die_info *pdi;
1716 /* Now, march along the PDI's, descending into ones which have
1717 interesting children but skipping the children of the other ones,
1718 until we reach the end of the compilation unit. */
1724 fixup_partial_die (pdi, cu);
1726 /* Anonymous namespaces have no name but have interesting
1727 children, so we need to look at them. Ditto for anonymous
1730 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1731 || pdi->tag == DW_TAG_enumeration_type)
1735 case DW_TAG_subprogram:
1736 if (pdi->has_pc_info)
1738 if (pdi->lowpc < *lowpc)
1740 *lowpc = pdi->lowpc;
1742 if (pdi->highpc > *highpc)
1744 *highpc = pdi->highpc;
1746 if (!pdi->is_declaration)
1748 add_partial_symbol (pdi, cu);
1752 case DW_TAG_variable:
1753 case DW_TAG_typedef:
1754 case DW_TAG_union_type:
1755 if (!pdi->is_declaration)
1757 add_partial_symbol (pdi, cu);
1760 case DW_TAG_class_type:
1761 case DW_TAG_structure_type:
1762 if (!pdi->is_declaration)
1764 add_partial_symbol (pdi, cu);
1767 case DW_TAG_enumeration_type:
1768 if (!pdi->is_declaration)
1769 add_partial_enumeration (pdi, cu);
1771 case DW_TAG_base_type:
1772 case DW_TAG_subrange_type:
1773 /* File scope base type definitions are added to the partial
1775 add_partial_symbol (pdi, cu);
1777 case DW_TAG_namespace:
1778 add_partial_namespace (pdi, lowpc, highpc, cu);
1785 /* If the die has a sibling, skip to the sibling. */
1787 pdi = pdi->die_sibling;
1791 /* Functions used to compute the fully scoped name of a partial DIE.
1793 Normally, this is simple. For C++, the parent DIE's fully scoped
1794 name is concatenated with "::" and the partial DIE's name. For
1795 Java, the same thing occurs except that "." is used instead of "::".
1796 Enumerators are an exception; they use the scope of their parent
1797 enumeration type, i.e. the name of the enumeration type is not
1798 prepended to the enumerator.
1800 There are two complexities. One is DW_AT_specification; in this
1801 case "parent" means the parent of the target of the specification,
1802 instead of the direct parent of the DIE. The other is compilers
1803 which do not emit DW_TAG_namespace; in this case we try to guess
1804 the fully qualified name of structure types from their members'
1805 linkage names. This must be done using the DIE's children rather
1806 than the children of any DW_AT_specification target. We only need
1807 to do this for structures at the top level, i.e. if the target of
1808 any DW_AT_specification (if any; otherwise the DIE itself) does not
1811 /* Compute the scope prefix associated with PDI's parent, in
1812 compilation unit CU. The result will be allocated on CU's
1813 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1814 field. NULL is returned if no prefix is necessary. */
1816 partial_die_parent_scope (struct partial_die_info *pdi,
1817 struct dwarf2_cu *cu)
1819 char *grandparent_scope;
1820 struct partial_die_info *parent, *real_pdi;
1822 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1823 then this means the parent of the specification DIE. */
1826 while (real_pdi->has_specification)
1827 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
1829 parent = real_pdi->die_parent;
1833 if (parent->scope_set)
1834 return parent->scope;
1836 fixup_partial_die (parent, cu);
1838 grandparent_scope = partial_die_parent_scope (parent, cu);
1840 if (parent->tag == DW_TAG_namespace
1841 || parent->tag == DW_TAG_structure_type
1842 || parent->tag == DW_TAG_class_type
1843 || parent->tag == DW_TAG_union_type)
1845 if (grandparent_scope == NULL)
1846 parent->scope = parent->name;
1848 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
1851 else if (parent->tag == DW_TAG_enumeration_type)
1852 /* Enumerators should not get the name of the enumeration as a prefix. */
1853 parent->scope = grandparent_scope;
1856 /* FIXME drow/2004-04-01: What should we be doing with
1857 function-local names? For partial symbols, we should probably be
1859 complaint (&symfile_complaints,
1860 _("unhandled containing DIE tag %d for DIE at %d"),
1861 parent->tag, pdi->offset);
1862 parent->scope = grandparent_scope;
1865 parent->scope_set = 1;
1866 return parent->scope;
1869 /* Return the fully scoped name associated with PDI, from compilation unit
1870 CU. The result will be allocated with malloc. */
1872 partial_die_full_name (struct partial_die_info *pdi,
1873 struct dwarf2_cu *cu)
1877 parent_scope = partial_die_parent_scope (pdi, cu);
1878 if (parent_scope == NULL)
1881 return typename_concat (NULL, parent_scope, pdi->name, cu);
1885 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1887 struct objfile *objfile = cu->objfile;
1889 char *actual_name = NULL;
1890 const char *my_prefix;
1891 const struct partial_symbol *psym = NULL;
1893 int built_actual_name = 0;
1895 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1897 if (pdi_needs_namespace (pdi->tag))
1899 actual_name = partial_die_full_name (pdi, cu);
1901 built_actual_name = 1;
1904 if (actual_name == NULL)
1905 actual_name = pdi->name;
1909 case DW_TAG_subprogram:
1910 if (pdi->is_external)
1912 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1913 mst_text, objfile); */
1914 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1915 VAR_DOMAIN, LOC_BLOCK,
1916 &objfile->global_psymbols,
1917 0, pdi->lowpc + baseaddr,
1918 cu->language, objfile);
1922 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1923 mst_file_text, objfile); */
1924 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1925 VAR_DOMAIN, LOC_BLOCK,
1926 &objfile->static_psymbols,
1927 0, pdi->lowpc + baseaddr,
1928 cu->language, objfile);
1931 case DW_TAG_variable:
1932 if (pdi->is_external)
1935 Don't enter into the minimal symbol tables as there is
1936 a minimal symbol table entry from the ELF symbols already.
1937 Enter into partial symbol table if it has a location
1938 descriptor or a type.
1939 If the location descriptor is missing, new_symbol will create
1940 a LOC_UNRESOLVED symbol, the address of the variable will then
1941 be determined from the minimal symbol table whenever the variable
1943 The address for the partial symbol table entry is not
1944 used by GDB, but it comes in handy for debugging partial symbol
1948 addr = decode_locdesc (pdi->locdesc, cu);
1949 if (pdi->locdesc || pdi->has_type)
1950 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1951 VAR_DOMAIN, LOC_STATIC,
1952 &objfile->global_psymbols,
1954 cu->language, objfile);
1958 /* Static Variable. Skip symbols without location descriptors. */
1959 if (pdi->locdesc == NULL)
1961 if (built_actual_name)
1962 xfree (actual_name);
1965 addr = decode_locdesc (pdi->locdesc, cu);
1966 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1967 mst_file_data, objfile); */
1968 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1969 VAR_DOMAIN, LOC_STATIC,
1970 &objfile->static_psymbols,
1972 cu->language, objfile);
1975 case DW_TAG_typedef:
1976 case DW_TAG_base_type:
1977 case DW_TAG_subrange_type:
1978 add_psymbol_to_list (actual_name, strlen (actual_name),
1979 VAR_DOMAIN, LOC_TYPEDEF,
1980 &objfile->static_psymbols,
1981 0, (CORE_ADDR) 0, cu->language, objfile);
1983 case DW_TAG_namespace:
1984 add_psymbol_to_list (actual_name, strlen (actual_name),
1985 VAR_DOMAIN, LOC_TYPEDEF,
1986 &objfile->global_psymbols,
1987 0, (CORE_ADDR) 0, cu->language, objfile);
1989 case DW_TAG_class_type:
1990 case DW_TAG_structure_type:
1991 case DW_TAG_union_type:
1992 case DW_TAG_enumeration_type:
1993 /* Skip external references. The DWARF standard says in the section
1994 about "Structure, Union, and Class Type Entries": "An incomplete
1995 structure, union or class type is represented by a structure,
1996 union or class entry that does not have a byte size attribute
1997 and that has a DW_AT_declaration attribute." */
1998 if (!pdi->has_byte_size && pdi->is_declaration)
2000 if (built_actual_name)
2001 xfree (actual_name);
2005 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2006 static vs. global. */
2007 add_psymbol_to_list (actual_name, strlen (actual_name),
2008 STRUCT_DOMAIN, LOC_TYPEDEF,
2009 (cu->language == language_cplus
2010 || cu->language == language_java)
2011 ? &objfile->global_psymbols
2012 : &objfile->static_psymbols,
2013 0, (CORE_ADDR) 0, cu->language, objfile);
2015 if (cu->language == language_cplus
2016 || cu->language == language_java
2017 || cu->language == language_ada)
2019 /* For C++ and Java, these implicitly act as typedefs as well. */
2020 add_psymbol_to_list (actual_name, strlen (actual_name),
2021 VAR_DOMAIN, LOC_TYPEDEF,
2022 &objfile->global_psymbols,
2023 0, (CORE_ADDR) 0, cu->language, objfile);
2026 case DW_TAG_enumerator:
2027 add_psymbol_to_list (actual_name, strlen (actual_name),
2028 VAR_DOMAIN, LOC_CONST,
2029 (cu->language == language_cplus
2030 || cu->language == language_java)
2031 ? &objfile->global_psymbols
2032 : &objfile->static_psymbols,
2033 0, (CORE_ADDR) 0, cu->language, objfile);
2039 /* Check to see if we should scan the name for possible namespace
2040 info. Only do this if this is C++, if we don't have namespace
2041 debugging info in the file, if the psym is of an appropriate type
2042 (otherwise we'll have psym == NULL), and if we actually had a
2043 mangled name to begin with. */
2045 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2046 cases which do not set PSYM above? */
2048 if (cu->language == language_cplus
2049 && cu->has_namespace_info == 0
2051 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2052 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2055 if (built_actual_name)
2056 xfree (actual_name);
2059 /* Determine whether a die of type TAG living in a C++ class or
2060 namespace needs to have the name of the scope prepended to the
2061 name listed in the die. */
2064 pdi_needs_namespace (enum dwarf_tag tag)
2068 case DW_TAG_namespace:
2069 case DW_TAG_typedef:
2070 case DW_TAG_class_type:
2071 case DW_TAG_structure_type:
2072 case DW_TAG_union_type:
2073 case DW_TAG_enumeration_type:
2074 case DW_TAG_enumerator:
2081 /* Read a partial die corresponding to a namespace; also, add a symbol
2082 corresponding to that namespace to the symbol table. NAMESPACE is
2083 the name of the enclosing namespace. */
2086 add_partial_namespace (struct partial_die_info *pdi,
2087 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2088 struct dwarf2_cu *cu)
2090 struct objfile *objfile = cu->objfile;
2092 /* Add a symbol for the namespace. */
2094 add_partial_symbol (pdi, cu);
2096 /* Now scan partial symbols in that namespace. */
2098 if (pdi->has_children)
2099 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
2102 /* See if we can figure out if the class lives in a namespace. We do
2103 this by looking for a member function; its demangled name will
2104 contain namespace info, if there is any. */
2107 guess_structure_name (struct partial_die_info *struct_pdi,
2108 struct dwarf2_cu *cu)
2110 if ((cu->language == language_cplus
2111 || cu->language == language_java)
2112 && cu->has_namespace_info == 0
2113 && struct_pdi->has_children)
2115 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2116 what template types look like, because the demangler
2117 frequently doesn't give the same name as the debug info. We
2118 could fix this by only using the demangled name to get the
2119 prefix (but see comment in read_structure_type). */
2121 struct partial_die_info *child_pdi = struct_pdi->die_child;
2122 struct partial_die_info *real_pdi;
2124 /* If this DIE (this DIE's specification, if any) has a parent, then
2125 we should not do this. We'll prepend the parent's fully qualified
2126 name when we create the partial symbol. */
2128 real_pdi = struct_pdi;
2129 while (real_pdi->has_specification)
2130 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2132 if (real_pdi->die_parent != NULL)
2135 while (child_pdi != NULL)
2137 if (child_pdi->tag == DW_TAG_subprogram)
2139 char *actual_class_name
2140 = language_class_name_from_physname (cu->language_defn,
2142 if (actual_class_name != NULL)
2145 = obsavestring (actual_class_name,
2146 strlen (actual_class_name),
2147 &cu->comp_unit_obstack);
2148 xfree (actual_class_name);
2153 child_pdi = child_pdi->die_sibling;
2158 /* Read a partial die corresponding to an enumeration type. */
2161 add_partial_enumeration (struct partial_die_info *enum_pdi,
2162 struct dwarf2_cu *cu)
2164 struct objfile *objfile = cu->objfile;
2165 bfd *abfd = objfile->obfd;
2166 struct partial_die_info *pdi;
2168 if (enum_pdi->name != NULL)
2169 add_partial_symbol (enum_pdi, cu);
2171 pdi = enum_pdi->die_child;
2174 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2175 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2177 add_partial_symbol (pdi, cu);
2178 pdi = pdi->die_sibling;
2182 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2183 Return the corresponding abbrev, or NULL if the number is zero (indicating
2184 an empty DIE). In either case *BYTES_READ will be set to the length of
2185 the initial number. */
2187 static struct abbrev_info *
2188 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
2189 struct dwarf2_cu *cu)
2191 bfd *abfd = cu->objfile->obfd;
2192 unsigned int abbrev_number;
2193 struct abbrev_info *abbrev;
2195 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2197 if (abbrev_number == 0)
2200 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2203 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2204 bfd_get_filename (abfd));
2210 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2211 pointer to the end of a series of DIEs, terminated by an empty
2212 DIE. Any children of the skipped DIEs will also be skipped. */
2215 skip_children (gdb_byte *info_ptr, struct dwarf2_cu *cu)
2217 struct abbrev_info *abbrev;
2218 unsigned int bytes_read;
2222 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2224 return info_ptr + bytes_read;
2226 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
2230 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2231 should point just after the initial uleb128 of a DIE, and the
2232 abbrev corresponding to that skipped uleb128 should be passed in
2233 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2237 skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
2238 struct dwarf2_cu *cu)
2240 unsigned int bytes_read;
2241 struct attribute attr;
2242 bfd *abfd = cu->objfile->obfd;
2243 unsigned int form, i;
2245 for (i = 0; i < abbrev->num_attrs; i++)
2247 /* The only abbrev we care about is DW_AT_sibling. */
2248 if (abbrev->attrs[i].name == DW_AT_sibling)
2250 read_attribute (&attr, &abbrev->attrs[i],
2251 abfd, info_ptr, cu);
2252 if (attr.form == DW_FORM_ref_addr)
2253 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2255 return dwarf2_per_objfile->info_buffer
2256 + dwarf2_get_ref_die_offset (&attr, cu);
2259 /* If it isn't DW_AT_sibling, skip this attribute. */
2260 form = abbrev->attrs[i].form;
2265 case DW_FORM_ref_addr:
2266 info_ptr += cu->header.addr_size;
2285 case DW_FORM_string:
2286 read_string (abfd, info_ptr, &bytes_read);
2287 info_ptr += bytes_read;
2290 info_ptr += cu->header.offset_size;
2293 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2294 info_ptr += bytes_read;
2296 case DW_FORM_block1:
2297 info_ptr += 1 + read_1_byte (abfd, info_ptr);
2299 case DW_FORM_block2:
2300 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2302 case DW_FORM_block4:
2303 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2307 case DW_FORM_ref_udata:
2308 info_ptr = skip_leb128 (abfd, info_ptr);
2310 case DW_FORM_indirect:
2311 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2312 info_ptr += bytes_read;
2313 /* We need to continue parsing from here, so just go back to
2315 goto skip_attribute;
2318 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2319 dwarf_form_name (form),
2320 bfd_get_filename (abfd));
2324 if (abbrev->has_children)
2325 return skip_children (info_ptr, cu);
2330 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2331 the next DIE after ORIG_PDI. */
2334 locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr,
2335 bfd *abfd, struct dwarf2_cu *cu)
2337 /* Do we know the sibling already? */
2339 if (orig_pdi->sibling)
2340 return orig_pdi->sibling;
2342 /* Are there any children to deal with? */
2344 if (!orig_pdi->has_children)
2347 /* Skip the children the long way. */
2349 return skip_children (info_ptr, cu);
2352 /* Expand this partial symbol table into a full symbol table. */
2355 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2357 /* FIXME: This is barely more than a stub. */
2362 warning (_("bug: psymtab for %s is already read in."), pst->filename);
2368 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
2369 gdb_flush (gdb_stdout);
2372 /* Restore our global data. */
2373 dwarf2_per_objfile = objfile_data (pst->objfile,
2374 dwarf2_objfile_data_key);
2376 psymtab_to_symtab_1 (pst);
2378 /* Finish up the debug error message. */
2380 printf_filtered (_("done.\n"));
2385 /* Add PER_CU to the queue. */
2388 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
2390 struct dwarf2_queue_item *item;
2393 item = xmalloc (sizeof (*item));
2394 item->per_cu = per_cu;
2397 if (dwarf2_queue == NULL)
2398 dwarf2_queue = item;
2400 dwarf2_queue_tail->next = item;
2402 dwarf2_queue_tail = item;
2405 /* Process the queue. */
2408 process_queue (struct objfile *objfile)
2410 struct dwarf2_queue_item *item, *next_item;
2412 /* Initially, there is just one item on the queue. Load its DIEs,
2413 and the DIEs of any other compilation units it requires,
2416 for (item = dwarf2_queue; item != NULL; item = item->next)
2418 /* Read in this compilation unit. This may add new items to
2419 the end of the queue. */
2420 load_full_comp_unit (item->per_cu, objfile);
2422 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
2423 dwarf2_per_objfile->read_in_chain = item->per_cu;
2425 /* If this compilation unit has already had full symbols created,
2426 reset the TYPE fields in each DIE. */
2427 if (item->per_cu->type_hash)
2428 reset_die_and_siblings_types (item->per_cu->cu->dies,
2432 /* Now everything left on the queue needs to be read in. Process
2433 them, one at a time, removing from the queue as we finish. */
2434 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
2436 if (item->per_cu->psymtab && !item->per_cu->psymtab->readin)
2437 process_full_comp_unit (item->per_cu);
2439 item->per_cu->queued = 0;
2440 next_item = item->next;
2444 dwarf2_queue_tail = NULL;
2447 /* Free all allocated queue entries. This function only releases anything if
2448 an error was thrown; if the queue was processed then it would have been
2449 freed as we went along. */
2452 dwarf2_release_queue (void *dummy)
2454 struct dwarf2_queue_item *item, *last;
2456 item = dwarf2_queue;
2459 /* Anything still marked queued is likely to be in an
2460 inconsistent state, so discard it. */
2461 if (item->per_cu->queued)
2463 if (item->per_cu->cu != NULL)
2464 free_one_cached_comp_unit (item->per_cu->cu);
2465 item->per_cu->queued = 0;
2473 dwarf2_queue = dwarf2_queue_tail = NULL;
2476 /* Read in full symbols for PST, and anything it depends on. */
2479 psymtab_to_symtab_1 (struct partial_symtab *pst)
2481 struct dwarf2_per_cu_data *per_cu;
2482 struct cleanup *back_to;
2485 for (i = 0; i < pst->number_of_dependencies; i++)
2486 if (!pst->dependencies[i]->readin)
2488 /* Inform about additional files that need to be read in. */
2491 /* FIXME: i18n: Need to make this a single string. */
2492 fputs_filtered (" ", gdb_stdout);
2494 fputs_filtered ("and ", gdb_stdout);
2496 printf_filtered ("%s...", pst->dependencies[i]->filename);
2497 wrap_here (""); /* Flush output */
2498 gdb_flush (gdb_stdout);
2500 psymtab_to_symtab_1 (pst->dependencies[i]);
2503 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
2507 /* It's an include file, no symbols to read for it.
2508 Everything is in the parent symtab. */
2513 back_to = make_cleanup (dwarf2_release_queue, NULL);
2515 queue_comp_unit (per_cu);
2517 process_queue (pst->objfile);
2519 /* Age the cache, releasing compilation units that have not
2520 been used recently. */
2521 age_cached_comp_units ();
2523 do_cleanups (back_to);
2526 /* Load the DIEs associated with PST and PER_CU into memory. */
2528 static struct dwarf2_cu *
2529 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
2531 bfd *abfd = objfile->obfd;
2532 struct dwarf2_cu *cu;
2533 unsigned long offset;
2535 struct cleanup *back_to, *free_cu_cleanup;
2536 struct attribute *attr;
2539 /* Set local variables from the partial symbol table info. */
2540 offset = per_cu->offset;
2542 info_ptr = dwarf2_per_objfile->info_buffer + offset;
2544 cu = xmalloc (sizeof (struct dwarf2_cu));
2545 memset (cu, 0, sizeof (struct dwarf2_cu));
2547 /* If an error occurs while loading, release our storage. */
2548 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
2550 cu->objfile = objfile;
2552 /* read in the comp_unit header */
2553 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
2555 /* Read the abbrevs for this compilation unit */
2556 dwarf2_read_abbrevs (abfd, cu);
2557 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2559 cu->header.offset = offset;
2561 cu->per_cu = per_cu;
2564 /* We use this obstack for block values in dwarf_alloc_block. */
2565 obstack_init (&cu->comp_unit_obstack);
2567 cu->dies = read_comp_unit (info_ptr, abfd, cu);
2569 /* We try not to read any attributes in this function, because not
2570 all objfiles needed for references have been loaded yet, and symbol
2571 table processing isn't initialized. But we have to set the CU language,
2572 or we won't be able to build types correctly. */
2573 attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
2575 set_cu_language (DW_UNSND (attr), cu);
2577 set_cu_language (language_minimal, cu);
2579 do_cleanups (back_to);
2581 /* We've successfully allocated this compilation unit. Let our caller
2582 clean it up when finished with it. */
2583 discard_cleanups (free_cu_cleanup);
2588 /* Generate full symbol information for PST and CU, whose DIEs have
2589 already been loaded into memory. */
2592 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2594 struct partial_symtab *pst = per_cu->psymtab;
2595 struct dwarf2_cu *cu = per_cu->cu;
2596 struct objfile *objfile = pst->objfile;
2597 bfd *abfd = objfile->obfd;
2598 CORE_ADDR lowpc, highpc;
2599 struct symtab *symtab;
2600 struct cleanup *back_to;
2601 struct attribute *attr;
2604 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2606 /* We're in the global namespace. */
2607 processing_current_prefix = "";
2610 back_to = make_cleanup (really_free_pendings, NULL);
2612 cu->list_in_scope = &file_symbols;
2614 /* Find the base address of the compilation unit for range lists and
2615 location lists. It will normally be specified by DW_AT_low_pc.
2616 In DWARF-3 draft 4, the base address could be overridden by
2617 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2618 compilation units with discontinuous ranges. */
2620 cu->header.base_known = 0;
2621 cu->header.base_address = 0;
2623 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
2626 cu->header.base_address = DW_ADDR (attr);
2627 cu->header.base_known = 1;
2631 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
2634 cu->header.base_address = DW_ADDR (attr);
2635 cu->header.base_known = 1;
2639 /* Do line number decoding in read_file_scope () */
2640 process_die (cu->dies, cu);
2642 /* Some compilers don't define a DW_AT_high_pc attribute for the
2643 compilation unit. If the DW_AT_high_pc is missing, synthesize
2644 it, by scanning the DIE's below the compilation unit. */
2645 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
2647 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2649 /* Set symtab language to language from DW_AT_language.
2650 If the compilation is from a C file generated by language preprocessors,
2651 do not set the language if it was already deduced by start_subfile. */
2653 && !(cu->language == language_c && symtab->language != language_c))
2655 symtab->language = cu->language;
2657 pst->symtab = symtab;
2660 do_cleanups (back_to);
2663 /* Process a die and its children. */
2666 process_die (struct die_info *die, struct dwarf2_cu *cu)
2670 case DW_TAG_padding:
2672 case DW_TAG_compile_unit:
2673 read_file_scope (die, cu);
2675 case DW_TAG_subprogram:
2676 read_subroutine_type (die, cu);
2677 read_func_scope (die, cu);
2679 case DW_TAG_inlined_subroutine:
2680 /* FIXME: These are ignored for now.
2681 They could be used to set breakpoints on all inlined instances
2682 of a function and make GDB `next' properly over inlined functions. */
2684 case DW_TAG_lexical_block:
2685 case DW_TAG_try_block:
2686 case DW_TAG_catch_block:
2687 read_lexical_block_scope (die, cu);
2689 case DW_TAG_class_type:
2690 case DW_TAG_structure_type:
2691 case DW_TAG_union_type:
2692 read_structure_type (die, cu);
2693 process_structure_scope (die, cu);
2695 case DW_TAG_enumeration_type:
2696 read_enumeration_type (die, cu);
2697 process_enumeration_scope (die, cu);
2700 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2701 a symbol or process any children. Therefore it doesn't do anything
2702 that won't be done on-demand by read_type_die. */
2703 case DW_TAG_subroutine_type:
2704 read_subroutine_type (die, cu);
2706 case DW_TAG_set_type:
2707 read_set_type (die, cu);
2709 case DW_TAG_array_type:
2710 read_array_type (die, cu);
2712 case DW_TAG_pointer_type:
2713 read_tag_pointer_type (die, cu);
2715 case DW_TAG_ptr_to_member_type:
2716 read_tag_ptr_to_member_type (die, cu);
2718 case DW_TAG_reference_type:
2719 read_tag_reference_type (die, cu);
2721 case DW_TAG_string_type:
2722 read_tag_string_type (die, cu);
2726 case DW_TAG_base_type:
2727 read_base_type (die, cu);
2728 /* Add a typedef symbol for the type definition, if it has a
2730 new_symbol (die, die->type, cu);
2732 case DW_TAG_subrange_type:
2733 read_subrange_type (die, cu);
2734 /* Add a typedef symbol for the type definition, if it has a
2736 new_symbol (die, die->type, cu);
2738 case DW_TAG_common_block:
2739 read_common_block (die, cu);
2741 case DW_TAG_common_inclusion:
2743 case DW_TAG_namespace:
2744 processing_has_namespace_info = 1;
2745 read_namespace (die, cu);
2747 case DW_TAG_imported_declaration:
2748 case DW_TAG_imported_module:
2749 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2750 information contained in these. DW_TAG_imported_declaration
2751 dies shouldn't have children; DW_TAG_imported_module dies
2752 shouldn't in the C++ case, but conceivably could in the
2753 Fortran case, so we'll have to replace this gdb_assert if
2754 Fortran compilers start generating that info. */
2755 processing_has_namespace_info = 1;
2756 gdb_assert (die->child == NULL);
2759 new_symbol (die, NULL, cu);
2765 initialize_cu_func_list (struct dwarf2_cu *cu)
2767 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2771 free_cu_line_header (void *arg)
2773 struct dwarf2_cu *cu = arg;
2775 free_line_header (cu->line_header);
2776 cu->line_header = NULL;
2780 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2782 struct objfile *objfile = cu->objfile;
2783 struct comp_unit_head *cu_header = &cu->header;
2784 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2785 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2786 CORE_ADDR highpc = ((CORE_ADDR) 0);
2787 struct attribute *attr;
2789 char *comp_dir = NULL;
2790 struct die_info *child_die;
2791 bfd *abfd = objfile->obfd;
2792 struct line_header *line_header = 0;
2795 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2797 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2799 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2800 from finish_block. */
2801 if (lowpc == ((CORE_ADDR) -1))
2806 attr = dwarf2_attr (die, DW_AT_name, cu);
2809 name = DW_STRING (attr);
2812 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2814 comp_dir = DW_STRING (attr);
2815 else if (name != NULL && IS_ABSOLUTE_PATH (name))
2817 comp_dir = ldirname (name);
2818 if (comp_dir != NULL)
2819 make_cleanup (xfree, comp_dir);
2821 if (comp_dir != NULL)
2823 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2824 directory, get rid of it. */
2825 char *cp = strchr (comp_dir, ':');
2827 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2834 attr = dwarf2_attr (die, DW_AT_language, cu);
2837 set_cu_language (DW_UNSND (attr), cu);
2840 attr = dwarf2_attr (die, DW_AT_producer, cu);
2842 cu->producer = DW_STRING (attr);
2844 /* We assume that we're processing GCC output. */
2845 processing_gcc_compilation = 2;
2847 /* The compilation unit may be in a different language or objfile,
2848 zero out all remembered fundamental types. */
2849 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2851 start_symtab (name, comp_dir, lowpc);
2852 record_debugformat ("DWARF 2");
2853 record_producer (cu->producer);
2855 initialize_cu_func_list (cu);
2857 /* Decode line number information if present. We do this before
2858 processing child DIEs, so that the line header table is available
2859 for DW_AT_decl_file. */
2860 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2863 unsigned int line_offset = DW_UNSND (attr);
2864 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2867 cu->line_header = line_header;
2868 make_cleanup (free_cu_line_header, cu);
2869 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2873 /* Process all dies in compilation unit. */
2874 if (die->child != NULL)
2876 child_die = die->child;
2877 while (child_die && child_die->tag)
2879 process_die (child_die, cu);
2880 child_die = sibling_die (child_die);
2884 /* Decode macro information, if present. Dwarf 2 macro information
2885 refers to information in the line number info statement program
2886 header, so we can only read it if we've read the header
2888 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2889 if (attr && line_header)
2891 unsigned int macro_offset = DW_UNSND (attr);
2892 dwarf_decode_macros (line_header, macro_offset,
2893 comp_dir, abfd, cu);
2895 do_cleanups (back_to);
2899 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2900 struct dwarf2_cu *cu)
2902 struct function_range *thisfn;
2904 thisfn = (struct function_range *)
2905 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2906 thisfn->name = name;
2907 thisfn->lowpc = lowpc;
2908 thisfn->highpc = highpc;
2909 thisfn->seen_line = 0;
2910 thisfn->next = NULL;
2912 if (cu->last_fn == NULL)
2913 cu->first_fn = thisfn;
2915 cu->last_fn->next = thisfn;
2917 cu->last_fn = thisfn;
2921 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2923 struct objfile *objfile = cu->objfile;
2924 struct context_stack *new;
2927 struct die_info *child_die;
2928 struct attribute *attr;
2930 const char *previous_prefix = processing_current_prefix;
2931 struct cleanup *back_to = NULL;
2934 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2936 name = dwarf2_linkage_name (die, cu);
2938 /* Ignore functions with missing or empty names and functions with
2939 missing or invalid low and high pc attributes. */
2940 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2943 if (cu->language == language_cplus
2944 || cu->language == language_java)
2946 struct die_info *spec_die = die_specification (die, cu);
2948 /* NOTE: carlton/2004-01-23: We have to be careful in the
2949 presence of DW_AT_specification. For example, with GCC 3.4,
2954 // Definition of N::foo.
2958 then we'll have a tree of DIEs like this:
2960 1: DW_TAG_compile_unit
2961 2: DW_TAG_namespace // N
2962 3: DW_TAG_subprogram // declaration of N::foo
2963 4: DW_TAG_subprogram // definition of N::foo
2964 DW_AT_specification // refers to die #3
2966 Thus, when processing die #4, we have to pretend that we're
2967 in the context of its DW_AT_specification, namely the contex
2970 if (spec_die != NULL)
2972 char *specification_prefix = determine_prefix (spec_die, cu);
2973 processing_current_prefix = specification_prefix;
2974 back_to = make_cleanup (xfree, specification_prefix);
2981 /* Record the function range for dwarf_decode_lines. */
2982 add_to_cu_func_list (name, lowpc, highpc, cu);
2984 new = push_context (0, lowpc);
2985 new->name = new_symbol (die, die->type, cu);
2987 /* If there is a location expression for DW_AT_frame_base, record
2989 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2991 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2992 expression is being recorded directly in the function's symbol
2993 and not in a separate frame-base object. I guess this hack is
2994 to avoid adding some sort of frame-base adjunct/annex to the
2995 function's symbol :-(. The problem with doing this is that it
2996 results in a function symbol with a location expression that
2997 has nothing to do with the location of the function, ouch! The
2998 relationship should be: a function's symbol has-a frame base; a
2999 frame-base has-a location expression. */
3000 dwarf2_symbol_mark_computed (attr, new->name, cu);
3002 cu->list_in_scope = &local_symbols;
3004 if (die->child != NULL)
3006 child_die = die->child;
3007 while (child_die && child_die->tag)
3009 process_die (child_die, cu);
3010 child_die = sibling_die (child_die);
3014 new = pop_context ();
3015 /* Make a block for the local symbols within. */
3016 finish_block (new->name, &local_symbols, new->old_blocks,
3017 lowpc, highpc, objfile);
3019 /* In C++, we can have functions nested inside functions (e.g., when
3020 a function declares a class that has methods). This means that
3021 when we finish processing a function scope, we may need to go
3022 back to building a containing block's symbol lists. */
3023 local_symbols = new->locals;
3024 param_symbols = new->params;
3026 /* If we've finished processing a top-level function, subsequent
3027 symbols go in the file symbol list. */
3028 if (outermost_context_p ())
3029 cu->list_in_scope = &file_symbols;
3031 processing_current_prefix = previous_prefix;
3032 if (back_to != NULL)
3033 do_cleanups (back_to);
3036 /* Process all the DIES contained within a lexical block scope. Start
3037 a new scope, process the dies, and then close the scope. */
3040 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
3042 struct objfile *objfile = cu->objfile;
3043 struct context_stack *new;
3044 CORE_ADDR lowpc, highpc;
3045 struct die_info *child_die;
3048 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3050 /* Ignore blocks with missing or invalid low and high pc attributes. */
3051 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3052 as multiple lexical blocks? Handling children in a sane way would
3053 be nasty. Might be easier to properly extend generic blocks to
3055 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
3060 push_context (0, lowpc);
3061 if (die->child != NULL)
3063 child_die = die->child;
3064 while (child_die && child_die->tag)
3066 process_die (child_die, cu);
3067 child_die = sibling_die (child_die);
3070 new = pop_context ();
3072 if (local_symbols != NULL)
3074 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3077 local_symbols = new->locals;
3080 /* Get low and high pc attributes from a die. Return 1 if the attributes
3081 are present and valid, otherwise, return 0. Return -1 if the range is
3082 discontinuous, i.e. derived from DW_AT_ranges information. */
3084 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
3085 CORE_ADDR *highpc, struct dwarf2_cu *cu)
3087 struct objfile *objfile = cu->objfile;
3088 struct comp_unit_head *cu_header = &cu->header;
3089 struct attribute *attr;
3090 bfd *obfd = objfile->obfd;
3095 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
3098 high = DW_ADDR (attr);
3099 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3101 low = DW_ADDR (attr);
3103 /* Found high w/o low attribute. */
3106 /* Found consecutive range of addresses. */
3111 attr = dwarf2_attr (die, DW_AT_ranges, cu);
3114 unsigned int addr_size = cu_header->addr_size;
3115 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3116 /* Value of the DW_AT_ranges attribute is the offset in the
3117 .debug_ranges section. */
3118 unsigned int offset = DW_UNSND (attr);
3119 /* Base address selection entry. */
3127 found_base = cu_header->base_known;
3128 base = cu_header->base_address;
3130 if (offset >= dwarf2_per_objfile->ranges_size)
3132 complaint (&symfile_complaints,
3133 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3137 buffer = dwarf2_per_objfile->ranges_buffer + offset;
3139 /* Read in the largest possible address. */
3140 marker = read_address (obfd, buffer, cu, &dummy);
3141 if ((marker & mask) == mask)
3143 /* If we found the largest possible address, then
3144 read the base address. */
3145 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3146 buffer += 2 * addr_size;
3147 offset += 2 * addr_size;
3155 CORE_ADDR range_beginning, range_end;
3157 range_beginning = read_address (obfd, buffer, cu, &dummy);
3158 buffer += addr_size;
3159 range_end = read_address (obfd, buffer, cu, &dummy);
3160 buffer += addr_size;
3161 offset += 2 * addr_size;
3163 /* An end of list marker is a pair of zero addresses. */
3164 if (range_beginning == 0 && range_end == 0)
3165 /* Found the end of list entry. */
3168 /* Each base address selection entry is a pair of 2 values.
3169 The first is the largest possible address, the second is
3170 the base address. Check for a base address here. */
3171 if ((range_beginning & mask) == mask)
3173 /* If we found the largest possible address, then
3174 read the base address. */
3175 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3182 /* We have no valid base address for the ranges
3184 complaint (&symfile_complaints,
3185 _("Invalid .debug_ranges data (no base address)"));
3189 range_beginning += base;
3192 /* FIXME: This is recording everything as a low-high
3193 segment of consecutive addresses. We should have a
3194 data structure for discontiguous block ranges
3198 low = range_beginning;
3204 if (range_beginning < low)
3205 low = range_beginning;
3206 if (range_end > high)
3212 /* If the first entry is an end-of-list marker, the range
3213 describes an empty scope, i.e. no instructions. */
3223 /* When using the GNU linker, .gnu.linkonce. sections are used to
3224 eliminate duplicate copies of functions and vtables and such.
3225 The linker will arbitrarily choose one and discard the others.
3226 The AT_*_pc values for such functions refer to local labels in
3227 these sections. If the section from that file was discarded, the
3228 labels are not in the output, so the relocs get a value of 0.
3229 If this is a discarded function, mark the pc bounds as invalid,
3230 so that GDB will ignore it. */
3231 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
3239 /* Get the low and high pc's represented by the scope DIE, and store
3240 them in *LOWPC and *HIGHPC. If the correct values can't be
3241 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3244 get_scope_pc_bounds (struct die_info *die,
3245 CORE_ADDR *lowpc, CORE_ADDR *highpc,
3246 struct dwarf2_cu *cu)
3248 CORE_ADDR best_low = (CORE_ADDR) -1;
3249 CORE_ADDR best_high = (CORE_ADDR) 0;
3250 CORE_ADDR current_low, current_high;
3252 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
3254 best_low = current_low;
3255 best_high = current_high;
3259 struct die_info *child = die->child;
3261 while (child && child->tag)
3263 switch (child->tag) {
3264 case DW_TAG_subprogram:
3265 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
3267 best_low = min (best_low, current_low);
3268 best_high = max (best_high, current_high);
3271 case DW_TAG_namespace:
3272 /* FIXME: carlton/2004-01-16: Should we do this for
3273 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3274 that current GCC's always emit the DIEs corresponding
3275 to definitions of methods of classes as children of a
3276 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3277 the DIEs giving the declarations, which could be
3278 anywhere). But I don't see any reason why the
3279 standards says that they have to be there. */
3280 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
3282 if (current_low != ((CORE_ADDR) -1))
3284 best_low = min (best_low, current_low);
3285 best_high = max (best_high, current_high);
3293 child = sibling_die (child);
3298 *highpc = best_high;
3301 /* Add an aggregate field to the field list. */
3304 dwarf2_add_field (struct field_info *fip, struct die_info *die,
3305 struct dwarf2_cu *cu)
3307 struct objfile *objfile = cu->objfile;
3308 struct nextfield *new_field;
3309 struct attribute *attr;
3311 char *fieldname = "";
3313 /* Allocate a new field list entry and link it in. */
3314 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3315 make_cleanup (xfree, new_field);
3316 memset (new_field, 0, sizeof (struct nextfield));
3317 new_field->next = fip->fields;
3318 fip->fields = new_field;
3321 /* Handle accessibility and virtuality of field.
3322 The default accessibility for members is public, the default
3323 accessibility for inheritance is private. */
3324 if (die->tag != DW_TAG_inheritance)
3325 new_field->accessibility = DW_ACCESS_public;
3327 new_field->accessibility = DW_ACCESS_private;
3328 new_field->virtuality = DW_VIRTUALITY_none;
3330 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3332 new_field->accessibility = DW_UNSND (attr);
3333 if (new_field->accessibility != DW_ACCESS_public)
3334 fip->non_public_fields = 1;
3335 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
3337 new_field->virtuality = DW_UNSND (attr);
3339 fp = &new_field->field;
3341 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
3343 /* Data member other than a C++ static data member. */
3345 /* Get type of field. */
3346 fp->type = die_type (die, cu);
3348 FIELD_STATIC_KIND (*fp) = 0;
3350 /* Get bit size of field (zero if none). */
3351 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
3354 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
3358 FIELD_BITSIZE (*fp) = 0;
3361 /* Get bit offset of field. */
3362 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3365 FIELD_BITPOS (*fp) =
3366 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
3369 FIELD_BITPOS (*fp) = 0;
3370 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
3373 if (BITS_BIG_ENDIAN)
3375 /* For big endian bits, the DW_AT_bit_offset gives the
3376 additional bit offset from the MSB of the containing
3377 anonymous object to the MSB of the field. We don't
3378 have to do anything special since we don't need to
3379 know the size of the anonymous object. */
3380 FIELD_BITPOS (*fp) += DW_UNSND (attr);
3384 /* For little endian bits, compute the bit offset to the
3385 MSB of the anonymous object, subtract off the number of
3386 bits from the MSB of the field to the MSB of the
3387 object, and then subtract off the number of bits of
3388 the field itself. The result is the bit offset of
3389 the LSB of the field. */
3391 int bit_offset = DW_UNSND (attr);
3393 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3396 /* The size of the anonymous object containing
3397 the bit field is explicit, so use the
3398 indicated size (in bytes). */
3399 anonymous_size = DW_UNSND (attr);
3403 /* The size of the anonymous object containing
3404 the bit field must be inferred from the type
3405 attribute of the data member containing the
3407 anonymous_size = TYPE_LENGTH (fp->type);
3409 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
3410 - bit_offset - FIELD_BITSIZE (*fp);
3414 /* Get name of field. */
3415 attr = dwarf2_attr (die, DW_AT_name, cu);
3416 if (attr && DW_STRING (attr))
3417 fieldname = DW_STRING (attr);
3419 /* The name is already allocated along with this objfile, so we don't
3420 need to duplicate it for the type. */
3421 fp->name = fieldname;
3423 /* Change accessibility for artificial fields (e.g. virtual table
3424 pointer or virtual base class pointer) to private. */
3425 if (dwarf2_attr (die, DW_AT_artificial, cu))
3427 new_field->accessibility = DW_ACCESS_private;
3428 fip->non_public_fields = 1;
3431 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
3433 /* C++ static member. */
3435 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3436 is a declaration, but all versions of G++ as of this writing
3437 (so through at least 3.2.1) incorrectly generate
3438 DW_TAG_variable tags. */
3442 /* Get name of field. */
3443 attr = dwarf2_attr (die, DW_AT_name, cu);
3444 if (attr && DW_STRING (attr))
3445 fieldname = DW_STRING (attr);
3449 /* Get physical name. */
3450 physname = dwarf2_linkage_name (die, cu);
3452 /* The name is already allocated along with this objfile, so we don't
3453 need to duplicate it for the type. */
3454 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
3455 FIELD_TYPE (*fp) = die_type (die, cu);
3456 FIELD_NAME (*fp) = fieldname;
3458 else if (die->tag == DW_TAG_inheritance)
3460 /* C++ base class field. */
3461 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3463 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
3465 FIELD_BITSIZE (*fp) = 0;
3466 FIELD_STATIC_KIND (*fp) = 0;
3467 FIELD_TYPE (*fp) = die_type (die, cu);
3468 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
3469 fip->nbaseclasses++;
3473 /* Create the vector of fields, and attach it to the type. */
3476 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3477 struct dwarf2_cu *cu)
3479 int nfields = fip->nfields;
3481 /* Record the field count, allocate space for the array of fields,
3482 and create blank accessibility bitfields if necessary. */
3483 TYPE_NFIELDS (type) = nfields;
3484 TYPE_FIELDS (type) = (struct field *)
3485 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3486 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3488 if (fip->non_public_fields)
3490 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3492 TYPE_FIELD_PRIVATE_BITS (type) =
3493 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3494 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3496 TYPE_FIELD_PROTECTED_BITS (type) =
3497 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3498 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3500 TYPE_FIELD_IGNORE_BITS (type) =
3501 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3502 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3505 /* If the type has baseclasses, allocate and clear a bit vector for
3506 TYPE_FIELD_VIRTUAL_BITS. */
3507 if (fip->nbaseclasses)
3509 int num_bytes = B_BYTES (fip->nbaseclasses);
3510 unsigned char *pointer;
3512 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3513 pointer = TYPE_ALLOC (type, num_bytes);
3514 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
3515 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3516 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3519 /* Copy the saved-up fields into the field vector. Start from the head
3520 of the list, adding to the tail of the field array, so that they end
3521 up in the same order in the array in which they were added to the list. */
3522 while (nfields-- > 0)
3524 TYPE_FIELD (type, nfields) = fip->fields->field;
3525 switch (fip->fields->accessibility)
3527 case DW_ACCESS_private:
3528 SET_TYPE_FIELD_PRIVATE (type, nfields);
3531 case DW_ACCESS_protected:
3532 SET_TYPE_FIELD_PROTECTED (type, nfields);
3535 case DW_ACCESS_public:
3539 /* Unknown accessibility. Complain and treat it as public. */
3541 complaint (&symfile_complaints, _("unsupported accessibility %d"),
3542 fip->fields->accessibility);
3546 if (nfields < fip->nbaseclasses)
3548 switch (fip->fields->virtuality)
3550 case DW_VIRTUALITY_virtual:
3551 case DW_VIRTUALITY_pure_virtual:
3552 SET_TYPE_FIELD_VIRTUAL (type, nfields);
3556 fip->fields = fip->fields->next;
3560 /* Add a member function to the proper fieldlist. */
3563 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3564 struct type *type, struct dwarf2_cu *cu)
3566 struct objfile *objfile = cu->objfile;
3567 struct attribute *attr;
3568 struct fnfieldlist *flp;
3570 struct fn_field *fnp;
3573 struct nextfnfield *new_fnfield;
3575 /* Get name of member function. */
3576 attr = dwarf2_attr (die, DW_AT_name, cu);
3577 if (attr && DW_STRING (attr))
3578 fieldname = DW_STRING (attr);
3582 /* Get the mangled name. */
3583 physname = dwarf2_linkage_name (die, cu);
3585 /* Look up member function name in fieldlist. */
3586 for (i = 0; i < fip->nfnfields; i++)
3588 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3592 /* Create new list element if necessary. */
3593 if (i < fip->nfnfields)
3594 flp = &fip->fnfieldlists[i];
3597 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3599 fip->fnfieldlists = (struct fnfieldlist *)
3600 xrealloc (fip->fnfieldlists,
3601 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3602 * sizeof (struct fnfieldlist));
3603 if (fip->nfnfields == 0)
3604 make_cleanup (free_current_contents, &fip->fnfieldlists);
3606 flp = &fip->fnfieldlists[fip->nfnfields];
3607 flp->name = fieldname;
3613 /* Create a new member function field and chain it to the field list
3615 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3616 make_cleanup (xfree, new_fnfield);
3617 memset (new_fnfield, 0, sizeof (struct nextfnfield));
3618 new_fnfield->next = flp->head;
3619 flp->head = new_fnfield;
3622 /* Fill in the member function field info. */
3623 fnp = &new_fnfield->fnfield;
3624 /* The name is already allocated along with this objfile, so we don't
3625 need to duplicate it for the type. */
3626 fnp->physname = physname ? physname : "";
3627 fnp->type = alloc_type (objfile);
3628 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3630 int nparams = TYPE_NFIELDS (die->type);
3632 /* TYPE is the domain of this method, and DIE->TYPE is the type
3633 of the method itself (TYPE_CODE_METHOD). */
3634 smash_to_method_type (fnp->type, type,
3635 TYPE_TARGET_TYPE (die->type),
3636 TYPE_FIELDS (die->type),
3637 TYPE_NFIELDS (die->type),
3638 TYPE_VARARGS (die->type));
3640 /* Handle static member functions.
3641 Dwarf2 has no clean way to discern C++ static and non-static
3642 member functions. G++ helps GDB by marking the first
3643 parameter for non-static member functions (which is the
3644 this pointer) as artificial. We obtain this information
3645 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3646 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3647 fnp->voffset = VOFFSET_STATIC;
3650 complaint (&symfile_complaints, _("member function type missing for '%s'"),
3653 /* Get fcontext from DW_AT_containing_type if present. */
3654 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3655 fnp->fcontext = die_containing_type (die, cu);
3657 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3658 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3660 /* Get accessibility. */
3661 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3664 switch (DW_UNSND (attr))
3666 case DW_ACCESS_private:
3667 fnp->is_private = 1;
3669 case DW_ACCESS_protected:
3670 fnp->is_protected = 1;
3675 /* Check for artificial methods. */
3676 attr = dwarf2_attr (die, DW_AT_artificial, cu);
3677 if (attr && DW_UNSND (attr) != 0)
3678 fnp->is_artificial = 1;
3680 /* Get index in virtual function table if it is a virtual member function. */
3681 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3684 /* Support the .debug_loc offsets */
3685 if (attr_form_is_block (attr))
3687 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3689 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3691 dwarf2_complex_location_expr_complaint ();
3695 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3701 /* Create the vector of member function fields, and attach it to the type. */
3704 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3705 struct dwarf2_cu *cu)
3707 struct fnfieldlist *flp;
3708 int total_length = 0;
3711 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3712 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3713 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3715 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3717 struct nextfnfield *nfp = flp->head;
3718 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3721 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3722 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3723 fn_flp->fn_fields = (struct fn_field *)
3724 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3725 for (k = flp->length; (k--, nfp); nfp = nfp->next)
3726 fn_flp->fn_fields[k] = nfp->fnfield;
3728 total_length += flp->length;
3731 TYPE_NFN_FIELDS (type) = fip->nfnfields;
3732 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3735 /* Returns non-zero if NAME is the name of a vtable member in CU's
3736 language, zero otherwise. */
3738 is_vtable_name (const char *name, struct dwarf2_cu *cu)
3740 static const char vptr[] = "_vptr";
3741 static const char vtable[] = "vtable";
3743 /* Look for the C++ and Java forms of the vtable. */
3744 if ((cu->language == language_java
3745 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
3746 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
3747 && is_cplus_marker (name[sizeof (vptr) - 1])))
3753 /* GCC outputs unnamed structures that are really pointers to member
3754 functions, with the ABI-specified layout. If DIE (from CU) describes
3755 such a structure, set its type, and return nonzero. Otherwise return
3758 GCC shouldn't do this; it should just output pointer to member DIEs.
3759 This is GCC PR debug/28767. */
3762 quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu)
3764 struct objfile *objfile = cu->objfile;
3766 struct die_info *pfn_die, *delta_die;
3767 struct attribute *pfn_name, *delta_name;
3768 struct type *pfn_type, *domain_type;
3770 /* Check for a structure with no name and two children. */
3771 if (die->tag != DW_TAG_structure_type
3772 || dwarf2_attr (die, DW_AT_name, cu) != NULL
3773 || die->child == NULL
3774 || die->child->sibling == NULL
3775 || (die->child->sibling->sibling != NULL
3776 && die->child->sibling->sibling->tag != DW_TAG_padding))
3779 /* Check for __pfn and __delta members. */
3780 pfn_die = die->child;
3781 pfn_name = dwarf2_attr (pfn_die, DW_AT_name, cu);
3782 if (pfn_die->tag != DW_TAG_member
3784 || DW_STRING (pfn_name) == NULL
3785 || strcmp ("__pfn", DW_STRING (pfn_name)) != 0)
3788 delta_die = pfn_die->sibling;
3789 delta_name = dwarf2_attr (delta_die, DW_AT_name, cu);
3790 if (delta_die->tag != DW_TAG_member
3791 || delta_name == NULL
3792 || DW_STRING (delta_name) == NULL
3793 || strcmp ("__delta", DW_STRING (delta_name)) != 0)
3796 /* Find the type of the method. */
3797 pfn_type = die_type (pfn_die, cu);
3798 if (pfn_type == NULL
3799 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
3800 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
3803 /* Look for the "this" argument. */
3804 pfn_type = TYPE_TARGET_TYPE (pfn_type);
3805 if (TYPE_NFIELDS (pfn_type) == 0
3806 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
3809 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
3810 type = alloc_type (objfile);
3811 smash_to_method_type (type, domain_type, TYPE_TARGET_TYPE (pfn_type),
3812 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
3813 TYPE_VARARGS (pfn_type));
3814 type = lookup_methodptr_type (type);
3815 set_die_type (die, type, cu);
3820 /* Called when we find the DIE that starts a structure or union scope
3821 (definition) to process all dies that define the members of the
3824 NOTE: we need to call struct_type regardless of whether or not the
3825 DIE has an at_name attribute, since it might be an anonymous
3826 structure or union. This gets the type entered into our set of
3829 However, if the structure is incomplete (an opaque struct/union)
3830 then suppress creating a symbol table entry for it since gdb only
3831 wants to find the one with the complete definition. Note that if
3832 it is complete, we just call new_symbol, which does it's own
3833 checking about whether the struct/union is anonymous or not (and
3834 suppresses creating a symbol table entry itself). */
3837 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3839 struct objfile *objfile = cu->objfile;
3841 struct attribute *attr;
3842 const char *previous_prefix = processing_current_prefix;
3843 struct cleanup *back_to = NULL;
3848 if (quirk_gcc_member_function_pointer (die, cu))
3851 type = alloc_type (objfile);
3852 INIT_CPLUS_SPECIFIC (type);
3853 attr = dwarf2_attr (die, DW_AT_name, cu);
3854 if (attr && DW_STRING (attr))
3856 if (cu->language == language_cplus
3857 || cu->language == language_java)
3859 char *new_prefix = determine_class_name (die, cu);
3860 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3861 strlen (new_prefix),
3862 &objfile->objfile_obstack);
3863 back_to = make_cleanup (xfree, new_prefix);
3864 processing_current_prefix = new_prefix;
3868 /* The name is already allocated along with this objfile, so
3869 we don't need to duplicate it for the type. */
3870 TYPE_TAG_NAME (type) = DW_STRING (attr);
3874 if (die->tag == DW_TAG_structure_type)
3876 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3878 else if (die->tag == DW_TAG_union_type)
3880 TYPE_CODE (type) = TYPE_CODE_UNION;
3884 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3886 TYPE_CODE (type) = TYPE_CODE_CLASS;
3889 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3892 TYPE_LENGTH (type) = DW_UNSND (attr);
3896 TYPE_LENGTH (type) = 0;
3899 TYPE_FLAGS (type) |= TYPE_FLAG_STUB_SUPPORTED;
3900 if (die_is_declaration (die, cu))
3901 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3903 /* We need to add the type field to the die immediately so we don't
3904 infinitely recurse when dealing with pointers to the structure
3905 type within the structure itself. */
3906 set_die_type (die, type, cu);
3908 if (die->child != NULL && ! die_is_declaration (die, cu))
3910 struct field_info fi;
3911 struct die_info *child_die;
3912 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3914 memset (&fi, 0, sizeof (struct field_info));
3916 child_die = die->child;
3918 while (child_die && child_die->tag)
3920 if (child_die->tag == DW_TAG_member
3921 || child_die->tag == DW_TAG_variable)
3923 /* NOTE: carlton/2002-11-05: A C++ static data member
3924 should be a DW_TAG_member that is a declaration, but
3925 all versions of G++ as of this writing (so through at
3926 least 3.2.1) incorrectly generate DW_TAG_variable
3927 tags for them instead. */
3928 dwarf2_add_field (&fi, child_die, cu);
3930 else if (child_die->tag == DW_TAG_subprogram)
3932 /* C++ member function. */
3933 read_type_die (child_die, cu);
3934 dwarf2_add_member_fn (&fi, child_die, type, cu);
3936 else if (child_die->tag == DW_TAG_inheritance)
3938 /* C++ base class field. */
3939 dwarf2_add_field (&fi, child_die, cu);
3941 child_die = sibling_die (child_die);
3944 /* Attach fields and member functions to the type. */
3946 dwarf2_attach_fields_to_type (&fi, type, cu);
3949 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3951 /* Get the type which refers to the base class (possibly this
3952 class itself) which contains the vtable pointer for the current
3953 class from the DW_AT_containing_type attribute. */
3955 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3957 struct type *t = die_containing_type (die, cu);
3959 TYPE_VPTR_BASETYPE (type) = t;
3964 /* Our own class provides vtbl ptr. */
3965 for (i = TYPE_NFIELDS (t) - 1;
3966 i >= TYPE_N_BASECLASSES (t);
3969 char *fieldname = TYPE_FIELD_NAME (t, i);
3971 if (is_vtable_name (fieldname, cu))
3973 TYPE_VPTR_FIELDNO (type) = i;
3978 /* Complain if virtual function table field not found. */
3979 if (i < TYPE_N_BASECLASSES (t))
3980 complaint (&symfile_complaints,
3981 _("virtual function table pointer not found when defining class '%s'"),
3982 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3987 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3990 else if (cu->producer
3991 && strncmp (cu->producer,
3992 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3994 /* The IBM XLC compiler does not provide direct indication
3995 of the containing type, but the vtable pointer is
3996 always named __vfp. */
4000 for (i = TYPE_NFIELDS (type) - 1;
4001 i >= TYPE_N_BASECLASSES (type);
4004 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
4006 TYPE_VPTR_FIELDNO (type) = i;
4007 TYPE_VPTR_BASETYPE (type) = type;
4014 do_cleanups (back_to);
4017 processing_current_prefix = previous_prefix;
4018 if (back_to != NULL)
4019 do_cleanups (back_to);
4023 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
4025 struct objfile *objfile = cu->objfile;
4026 const char *previous_prefix = processing_current_prefix;
4027 struct die_info *child_die = die->child;
4029 if (TYPE_TAG_NAME (die->type) != NULL)
4030 processing_current_prefix = TYPE_TAG_NAME (die->type);
4032 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4033 snapshots) has been known to create a die giving a declaration
4034 for a class that has, as a child, a die giving a definition for a
4035 nested class. So we have to process our children even if the
4036 current die is a declaration. Normally, of course, a declaration
4037 won't have any children at all. */
4039 while (child_die != NULL && child_die->tag)
4041 if (child_die->tag == DW_TAG_member
4042 || child_die->tag == DW_TAG_variable
4043 || child_die->tag == DW_TAG_inheritance)
4048 process_die (child_die, cu);
4050 child_die = sibling_die (child_die);
4053 /* Do not consider external references. According to the DWARF standard,
4054 these DIEs are identified by the fact that they have no byte_size
4055 attribute, and a declaration attribute. */
4056 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
4057 || !die_is_declaration (die, cu))
4058 new_symbol (die, die->type, cu);
4060 processing_current_prefix = previous_prefix;
4063 /* Given a DW_AT_enumeration_type die, set its type. We do not
4064 complete the type's fields yet, or create any symbols. */
4067 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
4069 struct objfile *objfile = cu->objfile;
4071 struct attribute *attr;
4076 type = alloc_type (objfile);
4078 TYPE_CODE (type) = TYPE_CODE_ENUM;
4079 attr = dwarf2_attr (die, DW_AT_name, cu);
4080 if (attr && DW_STRING (attr))
4082 char *name = DW_STRING (attr);
4084 if (processing_has_namespace_info)
4086 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
4087 processing_current_prefix,
4092 /* The name is already allocated along with this objfile, so
4093 we don't need to duplicate it for the type. */
4094 TYPE_TAG_NAME (type) = name;
4098 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4101 TYPE_LENGTH (type) = DW_UNSND (attr);
4105 TYPE_LENGTH (type) = 0;
4108 set_die_type (die, type, cu);
4111 /* Determine the name of the type represented by DIE, which should be
4112 a named C++ or Java compound type. Return the name in question; the caller
4113 is responsible for xfree()'ing it. */
4116 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
4118 struct cleanup *back_to = NULL;
4119 struct die_info *spec_die = die_specification (die, cu);
4120 char *new_prefix = NULL;
4122 /* If this is the definition of a class that is declared by another
4123 die, then processing_current_prefix may not be accurate; see
4124 read_func_scope for a similar example. */
4125 if (spec_die != NULL)
4127 char *specification_prefix = determine_prefix (spec_die, cu);
4128 processing_current_prefix = specification_prefix;
4129 back_to = make_cleanup (xfree, specification_prefix);
4132 /* If we don't have namespace debug info, guess the name by trying
4133 to demangle the names of members, just like we did in
4134 guess_structure_name. */
4135 if (!processing_has_namespace_info)
4137 struct die_info *child;
4139 for (child = die->child;
4140 child != NULL && child->tag != 0;
4141 child = sibling_die (child))
4143 if (child->tag == DW_TAG_subprogram)
4146 = language_class_name_from_physname (cu->language_defn,
4150 if (new_prefix != NULL)
4156 if (new_prefix == NULL)
4158 const char *name = dwarf2_name (die, cu);
4159 new_prefix = typename_concat (NULL, processing_current_prefix,
4160 name ? name : "<<anonymous>>",
4164 if (back_to != NULL)
4165 do_cleanups (back_to);
4170 /* Given a pointer to a die which begins an enumeration, process all
4171 the dies that define the members of the enumeration, and create the
4172 symbol for the enumeration type.
4174 NOTE: We reverse the order of the element list. */
4177 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4179 struct objfile *objfile = cu->objfile;
4180 struct die_info *child_die;
4181 struct field *fields;
4182 struct attribute *attr;
4185 int unsigned_enum = 1;
4189 if (die->child != NULL)
4191 child_die = die->child;
4192 while (child_die && child_die->tag)
4194 if (child_die->tag != DW_TAG_enumerator)
4196 process_die (child_die, cu);
4200 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4203 sym = new_symbol (child_die, die->type, cu);
4204 if (SYMBOL_VALUE (sym) < 0)
4207 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4209 fields = (struct field *)
4211 (num_fields + DW_FIELD_ALLOC_CHUNK)
4212 * sizeof (struct field));
4215 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4216 FIELD_TYPE (fields[num_fields]) = NULL;
4217 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4218 FIELD_BITSIZE (fields[num_fields]) = 0;
4219 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4225 child_die = sibling_die (child_die);
4230 TYPE_NFIELDS (die->type) = num_fields;
4231 TYPE_FIELDS (die->type) = (struct field *)
4232 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4233 memcpy (TYPE_FIELDS (die->type), fields,
4234 sizeof (struct field) * num_fields);
4238 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4241 new_symbol (die, die->type, cu);
4244 /* Extract all information from a DW_TAG_array_type DIE and put it in
4245 the DIE's type field. For now, this only handles one dimensional
4249 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4251 struct objfile *objfile = cu->objfile;
4252 struct die_info *child_die;
4253 struct type *type = NULL;
4254 struct type *element_type, *range_type, *index_type;
4255 struct type **range_types = NULL;
4256 struct attribute *attr;
4258 struct cleanup *back_to;
4260 /* Return if we've already decoded this type. */
4266 element_type = die_type (die, cu);
4268 /* Irix 6.2 native cc creates array types without children for
4269 arrays with unspecified length. */
4270 if (die->child == NULL)
4272 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4273 range_type = create_range_type (NULL, index_type, 0, -1);
4274 set_die_type (die, create_array_type (NULL, element_type, range_type),
4279 back_to = make_cleanup (null_cleanup, NULL);
4280 child_die = die->child;
4281 while (child_die && child_die->tag)
4283 if (child_die->tag == DW_TAG_subrange_type)
4285 read_subrange_type (child_die, cu);
4287 if (child_die->type != NULL)
4289 /* The range type was succesfully read. Save it for
4290 the array type creation. */
4291 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4293 range_types = (struct type **)
4294 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4295 * sizeof (struct type *));
4297 make_cleanup (free_current_contents, &range_types);
4299 range_types[ndim++] = child_die->type;
4302 child_die = sibling_die (child_die);
4305 /* Dwarf2 dimensions are output from left to right, create the
4306 necessary array types in backwards order. */
4308 type = element_type;
4310 if (read_array_order (die, cu) == DW_ORD_col_major)
4314 type = create_array_type (NULL, type, range_types[i++]);
4319 type = create_array_type (NULL, type, range_types[ndim]);
4322 /* Understand Dwarf2 support for vector types (like they occur on
4323 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4324 array type. This is not part of the Dwarf2/3 standard yet, but a
4325 custom vendor extension. The main difference between a regular
4326 array and the vector variant is that vectors are passed by value
4328 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4330 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4332 attr = dwarf2_attr (die, DW_AT_name, cu);
4333 if (attr && DW_STRING (attr))
4334 TYPE_NAME (type) = DW_STRING (attr);
4336 do_cleanups (back_to);
4338 /* Install the type in the die. */
4339 set_die_type (die, type, cu);
4342 static enum dwarf_array_dim_ordering
4343 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4345 struct attribute *attr;
4347 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4349 if (attr) return DW_SND (attr);
4352 GNU F77 is a special case, as at 08/2004 array type info is the
4353 opposite order to the dwarf2 specification, but data is still
4354 laid out as per normal fortran.
4356 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4360 if (cu->language == language_fortran &&
4361 cu->producer && strstr (cu->producer, "GNU F77"))
4363 return DW_ORD_row_major;
4366 switch (cu->language_defn->la_array_ordering)
4368 case array_column_major:
4369 return DW_ORD_col_major;
4370 case array_row_major:
4372 return DW_ORD_row_major;
4376 /* Extract all information from a DW_TAG_set_type DIE and put it in
4377 the DIE's type field. */
4380 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
4382 if (die->type == NULL)
4383 die->type = create_set_type ((struct type *) NULL, die_type (die, cu));
4386 /* First cut: install each common block member as a global variable. */
4389 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4391 struct die_info *child_die;
4392 struct attribute *attr;
4394 CORE_ADDR base = (CORE_ADDR) 0;
4396 attr = dwarf2_attr (die, DW_AT_location, cu);
4399 /* Support the .debug_loc offsets */
4400 if (attr_form_is_block (attr))
4402 base = decode_locdesc (DW_BLOCK (attr), cu);
4404 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4406 dwarf2_complex_location_expr_complaint ();
4410 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4411 "common block member");
4414 if (die->child != NULL)
4416 child_die = die->child;
4417 while (child_die && child_die->tag)
4419 sym = new_symbol (child_die, NULL, cu);
4420 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4423 SYMBOL_VALUE_ADDRESS (sym) =
4424 base + decode_locdesc (DW_BLOCK (attr), cu);
4425 add_symbol_to_list (sym, &global_symbols);
4427 child_die = sibling_die (child_die);
4432 /* Read a C++ namespace. */
4435 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4437 struct objfile *objfile = cu->objfile;
4438 const char *previous_prefix = processing_current_prefix;
4441 struct die_info *current_die;
4442 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4444 name = namespace_name (die, &is_anonymous, cu);
4446 /* Now build the name of the current namespace. */
4448 if (previous_prefix[0] == '\0')
4450 processing_current_prefix = name;
4454 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4455 make_cleanup (xfree, temp_name);
4456 processing_current_prefix = temp_name;
4459 /* Add a symbol associated to this if we haven't seen the namespace
4460 before. Also, add a using directive if it's an anonymous
4463 if (dwarf2_extension (die, cu) == NULL)
4467 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4468 this cast will hopefully become unnecessary. */
4469 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4470 (char *) processing_current_prefix,
4472 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4474 new_symbol (die, type, cu);
4475 set_die_type (die, type, cu);
4478 cp_add_using_directive (processing_current_prefix,
4479 strlen (previous_prefix),
4480 strlen (processing_current_prefix));
4483 if (die->child != NULL)
4485 struct die_info *child_die = die->child;
4487 while (child_die && child_die->tag)
4489 process_die (child_die, cu);
4490 child_die = sibling_die (child_die);
4494 processing_current_prefix = previous_prefix;
4495 do_cleanups (back_to);
4498 /* Return the name of the namespace represented by DIE. Set
4499 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4503 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4505 struct die_info *current_die;
4506 const char *name = NULL;
4508 /* Loop through the extensions until we find a name. */
4510 for (current_die = die;
4511 current_die != NULL;
4512 current_die = dwarf2_extension (die, cu))
4514 name = dwarf2_name (current_die, cu);
4519 /* Is it an anonymous namespace? */
4521 *is_anonymous = (name == NULL);
4523 name = "(anonymous namespace)";
4528 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4529 the user defined type vector. */
4532 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4534 struct comp_unit_head *cu_header = &cu->header;
4536 struct attribute *attr_byte_size;
4537 struct attribute *attr_address_class;
4538 int byte_size, addr_class;
4545 type = lookup_pointer_type (die_type (die, cu));
4547 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4549 byte_size = DW_UNSND (attr_byte_size);
4551 byte_size = cu_header->addr_size;
4553 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4554 if (attr_address_class)
4555 addr_class = DW_UNSND (attr_address_class);
4557 addr_class = DW_ADDR_none;
4559 /* If the pointer size or address class is different than the
4560 default, create a type variant marked as such and set the
4561 length accordingly. */
4562 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4564 if (gdbarch_address_class_type_flags_p (current_gdbarch))
4568 type_flags = gdbarch_address_class_type_flags
4569 (current_gdbarch, byte_size, addr_class);
4570 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4571 type = make_type_with_address_space (type, type_flags);
4573 else if (TYPE_LENGTH (type) != byte_size)
4575 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4578 /* Should we also complain about unhandled address classes? */
4582 TYPE_LENGTH (type) = byte_size;
4583 set_die_type (die, type, cu);
4586 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4587 the user defined type vector. */
4590 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4592 struct objfile *objfile = cu->objfile;
4594 struct type *to_type;
4595 struct type *domain;
4602 to_type = die_type (die, cu);
4603 domain = die_containing_type (die, cu);
4605 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
4606 type = lookup_methodptr_type (to_type);
4608 type = lookup_memberptr_type (to_type, domain);
4610 set_die_type (die, type, cu);
4613 /* Extract all information from a DW_TAG_reference_type DIE and add to
4614 the user defined type vector. */
4617 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4619 struct comp_unit_head *cu_header = &cu->header;
4621 struct attribute *attr;
4628 type = lookup_reference_type (die_type (die, cu));
4629 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4632 TYPE_LENGTH (type) = DW_UNSND (attr);
4636 TYPE_LENGTH (type) = cu_header->addr_size;
4638 set_die_type (die, type, cu);
4642 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4644 struct type *base_type;
4651 base_type = die_type (die, cu);
4652 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4657 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4659 struct type *base_type;
4666 base_type = die_type (die, cu);
4667 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4671 /* Extract all information from a DW_TAG_string_type DIE and add to
4672 the user defined type vector. It isn't really a user defined type,
4673 but it behaves like one, with other DIE's using an AT_user_def_type
4674 attribute to reference it. */
4677 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4679 struct objfile *objfile = cu->objfile;
4680 struct type *type, *range_type, *index_type, *char_type;
4681 struct attribute *attr;
4682 unsigned int length;
4689 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4692 length = DW_UNSND (attr);
4696 /* check for the DW_AT_byte_size attribute */
4697 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4700 length = DW_UNSND (attr);
4707 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4708 range_type = create_range_type (NULL, index_type, 1, length);
4709 if (cu->language == language_fortran)
4711 /* Need to create a unique string type for bounds
4713 type = create_string_type (0, range_type);
4717 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4718 type = create_string_type (char_type, range_type);
4720 set_die_type (die, type, cu);
4723 /* Handle DIES due to C code like:
4727 int (*funcp)(int a, long l);
4731 ('funcp' generates a DW_TAG_subroutine_type DIE)
4735 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4737 struct type *type; /* Type that this function returns */
4738 struct type *ftype; /* Function that returns above type */
4739 struct attribute *attr;
4741 /* Decode the type that this subroutine returns */
4746 type = die_type (die, cu);
4747 ftype = make_function_type (type, (struct type **) 0);
4749 /* All functions in C++ and Java have prototypes. */
4750 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4751 if ((attr && (DW_UNSND (attr) != 0))
4752 || cu->language == language_cplus
4753 || cu->language == language_java)
4754 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4756 if (die->child != NULL)
4758 struct die_info *child_die;
4762 /* Count the number of parameters.
4763 FIXME: GDB currently ignores vararg functions, but knows about
4764 vararg member functions. */
4765 child_die = die->child;
4766 while (child_die && child_die->tag)
4768 if (child_die->tag == DW_TAG_formal_parameter)
4770 else if (child_die->tag == DW_TAG_unspecified_parameters)
4771 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4772 child_die = sibling_die (child_die);
4775 /* Allocate storage for parameters and fill them in. */
4776 TYPE_NFIELDS (ftype) = nparams;
4777 TYPE_FIELDS (ftype) = (struct field *)
4778 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4780 child_die = die->child;
4781 while (child_die && child_die->tag)
4783 if (child_die->tag == DW_TAG_formal_parameter)
4785 /* Dwarf2 has no clean way to discern C++ static and non-static
4786 member functions. G++ helps GDB by marking the first
4787 parameter for non-static member functions (which is the
4788 this pointer) as artificial. We pass this information
4789 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4790 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4792 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4794 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4795 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4798 child_die = sibling_die (child_die);
4802 set_die_type (die, ftype, cu);
4806 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4808 struct objfile *objfile = cu->objfile;
4809 struct attribute *attr;
4814 attr = dwarf2_attr (die, DW_AT_name, cu);
4815 if (attr && DW_STRING (attr))
4817 name = DW_STRING (attr);
4819 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4820 TYPE_FLAG_TARGET_STUB, name, objfile),
4822 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4826 /* Find a representation of a given base type and install
4827 it in the TYPE field of the die. */
4830 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4832 struct objfile *objfile = cu->objfile;
4834 struct attribute *attr;
4835 int encoding = 0, size = 0;
4837 /* If we've already decoded this die, this is a no-op. */
4843 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4846 encoding = DW_UNSND (attr);
4848 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4851 size = DW_UNSND (attr);
4853 attr = dwarf2_attr (die, DW_AT_name, cu);
4854 if (attr && DW_STRING (attr))
4856 enum type_code code = TYPE_CODE_INT;
4861 case DW_ATE_address:
4862 /* Turn DW_ATE_address into a void * pointer. */
4863 code = TYPE_CODE_PTR;
4864 type_flags |= TYPE_FLAG_UNSIGNED;
4866 case DW_ATE_boolean:
4867 code = TYPE_CODE_BOOL;
4868 type_flags |= TYPE_FLAG_UNSIGNED;
4870 case DW_ATE_complex_float:
4871 code = TYPE_CODE_COMPLEX;
4874 code = TYPE_CODE_FLT;
4878 case DW_ATE_unsigned:
4879 type_flags |= TYPE_FLAG_UNSIGNED;
4881 case DW_ATE_signed_char:
4882 if (cu->language == language_m2)
4883 code = TYPE_CODE_CHAR;
4885 case DW_ATE_unsigned_char:
4886 if (cu->language == language_m2)
4887 code = TYPE_CODE_CHAR;
4888 type_flags |= TYPE_FLAG_UNSIGNED;
4891 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4892 dwarf_type_encoding_name (encoding));
4895 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4896 if (encoding == DW_ATE_address)
4897 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4899 else if (encoding == DW_ATE_complex_float)
4902 TYPE_TARGET_TYPE (type)
4903 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4904 else if (size == 16)
4905 TYPE_TARGET_TYPE (type)
4906 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4908 TYPE_TARGET_TYPE (type)
4909 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4914 type = dwarf_base_type (encoding, size, cu);
4916 set_die_type (die, type, cu);
4919 /* Read the given DW_AT_subrange DIE. */
4922 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4924 struct type *base_type;
4925 struct type *range_type;
4926 struct attribute *attr;
4930 /* If we have already decoded this die, then nothing more to do. */
4934 base_type = die_type (die, cu);
4935 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4937 complaint (&symfile_complaints,
4938 _("DW_AT_type missing from DW_TAG_subrange_type"));
4940 = dwarf_base_type (DW_ATE_signed,
4941 gdbarch_addr_bit (current_gdbarch) / 8, cu);
4944 if (cu->language == language_fortran)
4946 /* FORTRAN implies a lower bound of 1, if not given. */
4950 /* FIXME: For variable sized arrays either of these could be
4951 a variable rather than a constant value. We'll allow it,
4952 but we don't know how to handle it. */
4953 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4955 low = dwarf2_get_attr_constant_value (attr, 0);
4957 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4960 if (attr->form == DW_FORM_block1)
4962 /* GCC encodes arrays with unspecified or dynamic length
4963 with a DW_FORM_block1 attribute.
4964 FIXME: GDB does not yet know how to handle dynamic
4965 arrays properly, treat them as arrays with unspecified
4968 FIXME: jimb/2003-09-22: GDB does not really know
4969 how to handle arrays of unspecified length
4970 either; we just represent them as zero-length
4971 arrays. Choose an appropriate upper bound given
4972 the lower bound we've computed above. */
4976 high = dwarf2_get_attr_constant_value (attr, 1);
4979 range_type = create_range_type (NULL, base_type, low, high);
4981 attr = dwarf2_attr (die, DW_AT_name, cu);
4982 if (attr && DW_STRING (attr))
4983 TYPE_NAME (range_type) = DW_STRING (attr);
4985 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4987 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4989 set_die_type (die, range_type, cu);
4993 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
4996 struct attribute *attr;
5001 /* For now, we only support the C meaning of an unspecified type: void. */
5003 attr = dwarf2_attr (die, DW_AT_name, cu);
5004 type = init_type (TYPE_CODE_VOID, 0, 0, attr ? DW_STRING (attr) : "",
5007 set_die_type (die, type, cu);
5010 /* Read a whole compilation unit into a linked list of dies. */
5012 static struct die_info *
5013 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
5015 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
5018 /* Read a single die and all its descendents. Set the die's sibling
5019 field to NULL; set other fields in the die correctly, and set all
5020 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5021 location of the info_ptr after reading all of those dies. PARENT
5022 is the parent of the die in question. */
5024 static struct die_info *
5025 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
5026 struct dwarf2_cu *cu,
5027 gdb_byte **new_info_ptr,
5028 struct die_info *parent)
5030 struct die_info *die;
5034 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
5035 store_in_ref_table (die->offset, die, cu);
5039 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
5045 *new_info_ptr = cur_ptr;
5048 die->sibling = NULL;
5049 die->parent = parent;
5053 /* Read a die, all of its descendents, and all of its siblings; set
5054 all of the fields of all of the dies correctly. Arguments are as
5055 in read_die_and_children. */
5057 static struct die_info *
5058 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
5059 struct dwarf2_cu *cu,
5060 gdb_byte **new_info_ptr,
5061 struct die_info *parent)
5063 struct die_info *first_die, *last_sibling;
5067 first_die = last_sibling = NULL;
5071 struct die_info *die
5072 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
5080 last_sibling->sibling = die;
5085 *new_info_ptr = cur_ptr;
5095 /* Free a linked list of dies. */
5098 free_die_list (struct die_info *dies)
5100 struct die_info *die, *next;
5105 if (die->child != NULL)
5106 free_die_list (die->child);
5107 next = die->sibling;
5114 /* Read the contents of the section at OFFSET and of size SIZE from the
5115 object file specified by OBJFILE into the objfile_obstack and return it. */
5118 dwarf2_read_section (struct objfile *objfile, asection *sectp)
5120 bfd *abfd = objfile->obfd;
5121 gdb_byte *buf, *retbuf;
5122 bfd_size_type size = bfd_get_section_size (sectp);
5127 buf = obstack_alloc (&objfile->objfile_obstack, size);
5128 retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
5132 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
5133 || bfd_bread (buf, size, abfd) != size)
5134 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5135 bfd_get_filename (abfd));
5140 /* In DWARF version 2, the description of the debugging information is
5141 stored in a separate .debug_abbrev section. Before we read any
5142 dies from a section we read in all abbreviations and install them
5143 in a hash table. This function also sets flags in CU describing
5144 the data found in the abbrev table. */
5147 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
5149 struct comp_unit_head *cu_header = &cu->header;
5150 gdb_byte *abbrev_ptr;
5151 struct abbrev_info *cur_abbrev;
5152 unsigned int abbrev_number, bytes_read, abbrev_name;
5153 unsigned int abbrev_form, hash_number;
5154 struct attr_abbrev *cur_attrs;
5155 unsigned int allocated_attrs;
5157 /* Initialize dwarf2 abbrevs */
5158 obstack_init (&cu->abbrev_obstack);
5159 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
5161 * sizeof (struct abbrev_info *)));
5162 memset (cu->dwarf2_abbrevs, 0,
5163 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
5165 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
5166 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5167 abbrev_ptr += bytes_read;
5169 allocated_attrs = ATTR_ALLOC_CHUNK;
5170 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
5172 /* loop until we reach an abbrev number of 0 */
5173 while (abbrev_number)
5175 cur_abbrev = dwarf_alloc_abbrev (cu);
5177 /* read in abbrev header */
5178 cur_abbrev->number = abbrev_number;
5179 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5180 abbrev_ptr += bytes_read;
5181 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5184 if (cur_abbrev->tag == DW_TAG_namespace)
5185 cu->has_namespace_info = 1;
5187 /* now read in declarations */
5188 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5189 abbrev_ptr += bytes_read;
5190 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5191 abbrev_ptr += bytes_read;
5194 if (cur_abbrev->num_attrs == allocated_attrs)
5196 allocated_attrs += ATTR_ALLOC_CHUNK;
5198 = xrealloc (cur_attrs, (allocated_attrs
5199 * sizeof (struct attr_abbrev)));
5202 /* Record whether this compilation unit might have
5203 inter-compilation-unit references. If we don't know what form
5204 this attribute will have, then it might potentially be a
5205 DW_FORM_ref_addr, so we conservatively expect inter-CU
5208 if (abbrev_form == DW_FORM_ref_addr
5209 || abbrev_form == DW_FORM_indirect)
5210 cu->has_form_ref_addr = 1;
5212 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5213 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5214 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5215 abbrev_ptr += bytes_read;
5216 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5217 abbrev_ptr += bytes_read;
5220 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5221 (cur_abbrev->num_attrs
5222 * sizeof (struct attr_abbrev)));
5223 memcpy (cur_abbrev->attrs, cur_attrs,
5224 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5226 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5227 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5228 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5230 /* Get next abbreviation.
5231 Under Irix6 the abbreviations for a compilation unit are not
5232 always properly terminated with an abbrev number of 0.
5233 Exit loop if we encounter an abbreviation which we have
5234 already read (which means we are about to read the abbreviations
5235 for the next compile unit) or if the end of the abbreviation
5236 table is reached. */
5237 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5238 >= dwarf2_per_objfile->abbrev_size)
5240 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5241 abbrev_ptr += bytes_read;
5242 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5249 /* Release the memory used by the abbrev table for a compilation unit. */
5252 dwarf2_free_abbrev_table (void *ptr_to_cu)
5254 struct dwarf2_cu *cu = ptr_to_cu;
5256 obstack_free (&cu->abbrev_obstack, NULL);
5257 cu->dwarf2_abbrevs = NULL;
5260 /* Lookup an abbrev_info structure in the abbrev hash table. */
5262 static struct abbrev_info *
5263 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5265 unsigned int hash_number;
5266 struct abbrev_info *abbrev;
5268 hash_number = number % ABBREV_HASH_SIZE;
5269 abbrev = cu->dwarf2_abbrevs[hash_number];
5273 if (abbrev->number == number)
5276 abbrev = abbrev->next;
5281 /* Returns nonzero if TAG represents a type that we might generate a partial
5285 is_type_tag_for_partial (int tag)
5290 /* Some types that would be reasonable to generate partial symbols for,
5291 that we don't at present. */
5292 case DW_TAG_array_type:
5293 case DW_TAG_file_type:
5294 case DW_TAG_ptr_to_member_type:
5295 case DW_TAG_set_type:
5296 case DW_TAG_string_type:
5297 case DW_TAG_subroutine_type:
5299 case DW_TAG_base_type:
5300 case DW_TAG_class_type:
5301 case DW_TAG_enumeration_type:
5302 case DW_TAG_structure_type:
5303 case DW_TAG_subrange_type:
5304 case DW_TAG_typedef:
5305 case DW_TAG_union_type:
5312 /* Load all DIEs that are interesting for partial symbols into memory. */
5314 static struct partial_die_info *
5315 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5316 struct dwarf2_cu *cu)
5318 struct partial_die_info *part_die;
5319 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5320 struct abbrev_info *abbrev;
5321 unsigned int bytes_read;
5322 unsigned int load_all = 0;
5324 int nesting_level = 1;
5329 if (cu->per_cu && cu->per_cu->load_all_dies)
5333 = htab_create_alloc_ex (cu->header.length / 12,
5337 &cu->comp_unit_obstack,
5338 hashtab_obstack_allocate,
5339 dummy_obstack_deallocate);
5341 part_die = obstack_alloc (&cu->comp_unit_obstack,
5342 sizeof (struct partial_die_info));
5346 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5348 /* A NULL abbrev means the end of a series of children. */
5351 if (--nesting_level == 0)
5353 /* PART_DIE was probably the last thing allocated on the
5354 comp_unit_obstack, so we could call obstack_free
5355 here. We don't do that because the waste is small,
5356 and will be cleaned up when we're done with this
5357 compilation unit. This way, we're also more robust
5358 against other users of the comp_unit_obstack. */
5361 info_ptr += bytes_read;
5362 last_die = parent_die;
5363 parent_die = parent_die->die_parent;
5367 /* Check whether this DIE is interesting enough to save. Normally
5368 we would not be interested in members here, but there may be
5369 later variables referencing them via DW_AT_specification (for
5372 && !is_type_tag_for_partial (abbrev->tag)
5373 && abbrev->tag != DW_TAG_enumerator
5374 && abbrev->tag != DW_TAG_subprogram
5375 && abbrev->tag != DW_TAG_variable
5376 && abbrev->tag != DW_TAG_namespace
5377 && abbrev->tag != DW_TAG_member)
5379 /* Otherwise we skip to the next sibling, if any. */
5380 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5384 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5385 abfd, info_ptr, cu);
5387 /* This two-pass algorithm for processing partial symbols has a
5388 high cost in cache pressure. Thus, handle some simple cases
5389 here which cover the majority of C partial symbols. DIEs
5390 which neither have specification tags in them, nor could have
5391 specification tags elsewhere pointing at them, can simply be
5392 processed and discarded.
5394 This segment is also optional; scan_partial_symbols and
5395 add_partial_symbol will handle these DIEs if we chain
5396 them in normally. When compilers which do not emit large
5397 quantities of duplicate debug information are more common,
5398 this code can probably be removed. */
5400 /* Any complete simple types at the top level (pretty much all
5401 of them, for a language without namespaces), can be processed
5403 if (parent_die == NULL
5404 && part_die->has_specification == 0
5405 && part_die->is_declaration == 0
5406 && (part_die->tag == DW_TAG_typedef
5407 || part_die->tag == DW_TAG_base_type
5408 || part_die->tag == DW_TAG_subrange_type))
5410 if (building_psymtab && part_die->name != NULL)
5411 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5412 VAR_DOMAIN, LOC_TYPEDEF,
5413 &cu->objfile->static_psymbols,
5414 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5415 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5419 /* If we're at the second level, and we're an enumerator, and
5420 our parent has no specification (meaning possibly lives in a
5421 namespace elsewhere), then we can add the partial symbol now
5422 instead of queueing it. */
5423 if (part_die->tag == DW_TAG_enumerator
5424 && parent_die != NULL
5425 && parent_die->die_parent == NULL
5426 && parent_die->tag == DW_TAG_enumeration_type
5427 && parent_die->has_specification == 0)
5429 if (part_die->name == NULL)
5430 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5431 else if (building_psymtab)
5432 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5433 VAR_DOMAIN, LOC_CONST,
5434 (cu->language == language_cplus
5435 || cu->language == language_java)
5436 ? &cu->objfile->global_psymbols
5437 : &cu->objfile->static_psymbols,
5438 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5440 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5444 /* We'll save this DIE so link it in. */
5445 part_die->die_parent = parent_die;
5446 part_die->die_sibling = NULL;
5447 part_die->die_child = NULL;
5449 if (last_die && last_die == parent_die)
5450 last_die->die_child = part_die;
5452 last_die->die_sibling = part_die;
5454 last_die = part_die;
5456 if (first_die == NULL)
5457 first_die = part_die;
5459 /* Maybe add the DIE to the hash table. Not all DIEs that we
5460 find interesting need to be in the hash table, because we
5461 also have the parent/sibling/child chains; only those that we
5462 might refer to by offset later during partial symbol reading.
5464 For now this means things that might have be the target of a
5465 DW_AT_specification, DW_AT_abstract_origin, or
5466 DW_AT_extension. DW_AT_extension will refer only to
5467 namespaces; DW_AT_abstract_origin refers to functions (and
5468 many things under the function DIE, but we do not recurse
5469 into function DIEs during partial symbol reading) and
5470 possibly variables as well; DW_AT_specification refers to
5471 declarations. Declarations ought to have the DW_AT_declaration
5472 flag. It happens that GCC forgets to put it in sometimes, but
5473 only for functions, not for types.
5475 Adding more things than necessary to the hash table is harmless
5476 except for the performance cost. Adding too few will result in
5477 wasted time in find_partial_die, when we reread the compilation
5478 unit with load_all_dies set. */
5481 || abbrev->tag == DW_TAG_subprogram
5482 || abbrev->tag == DW_TAG_variable
5483 || abbrev->tag == DW_TAG_namespace
5484 || part_die->is_declaration)
5488 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5489 part_die->offset, INSERT);
5493 part_die = obstack_alloc (&cu->comp_unit_obstack,
5494 sizeof (struct partial_die_info));
5496 /* For some DIEs we want to follow their children (if any). For C
5497 we have no reason to follow the children of structures; for other
5498 languages we have to, both so that we can get at method physnames
5499 to infer fully qualified class names, and for DW_AT_specification. */
5500 if (last_die->has_children
5502 || last_die->tag == DW_TAG_namespace
5503 || last_die->tag == DW_TAG_enumeration_type
5504 || (cu->language != language_c
5505 && (last_die->tag == DW_TAG_class_type
5506 || last_die->tag == DW_TAG_structure_type
5507 || last_die->tag == DW_TAG_union_type))))
5510 parent_die = last_die;
5514 /* Otherwise we skip to the next sibling, if any. */
5515 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5517 /* Back to the top, do it again. */
5521 /* Read a minimal amount of information into the minimal die structure. */
5524 read_partial_die (struct partial_die_info *part_die,
5525 struct abbrev_info *abbrev,
5526 unsigned int abbrev_len, bfd *abfd,
5527 gdb_byte *info_ptr, struct dwarf2_cu *cu)
5529 unsigned int bytes_read, i;
5530 struct attribute attr;
5531 int has_low_pc_attr = 0;
5532 int has_high_pc_attr = 0;
5534 memset (part_die, 0, sizeof (struct partial_die_info));
5536 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5538 info_ptr += abbrev_len;
5543 part_die->tag = abbrev->tag;
5544 part_die->has_children = abbrev->has_children;
5546 for (i = 0; i < abbrev->num_attrs; ++i)
5548 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5550 /* Store the data if it is of an attribute we want to keep in a
5551 partial symbol table. */
5556 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5557 if (part_die->name == NULL)
5558 part_die->name = DW_STRING (&attr);
5560 case DW_AT_comp_dir:
5561 if (part_die->dirname == NULL)
5562 part_die->dirname = DW_STRING (&attr);
5564 case DW_AT_MIPS_linkage_name:
5565 part_die->name = DW_STRING (&attr);
5568 has_low_pc_attr = 1;
5569 part_die->lowpc = DW_ADDR (&attr);
5572 has_high_pc_attr = 1;
5573 part_die->highpc = DW_ADDR (&attr);
5575 case DW_AT_location:
5576 /* Support the .debug_loc offsets */
5577 if (attr_form_is_block (&attr))
5579 part_die->locdesc = DW_BLOCK (&attr);
5581 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5583 dwarf2_complex_location_expr_complaint ();
5587 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5588 "partial symbol information");
5591 case DW_AT_language:
5592 part_die->language = DW_UNSND (&attr);
5594 case DW_AT_external:
5595 part_die->is_external = DW_UNSND (&attr);
5597 case DW_AT_declaration:
5598 part_die->is_declaration = DW_UNSND (&attr);
5601 part_die->has_type = 1;
5603 case DW_AT_abstract_origin:
5604 case DW_AT_specification:
5605 case DW_AT_extension:
5606 part_die->has_specification = 1;
5607 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5610 /* Ignore absolute siblings, they might point outside of
5611 the current compile unit. */
5612 if (attr.form == DW_FORM_ref_addr)
5613 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5615 part_die->sibling = dwarf2_per_objfile->info_buffer
5616 + dwarf2_get_ref_die_offset (&attr, cu);
5618 case DW_AT_stmt_list:
5619 part_die->has_stmt_list = 1;
5620 part_die->line_offset = DW_UNSND (&attr);
5622 case DW_AT_byte_size:
5623 part_die->has_byte_size = 1;
5630 /* When using the GNU linker, .gnu.linkonce. sections are used to
5631 eliminate duplicate copies of functions and vtables and such.
5632 The linker will arbitrarily choose one and discard the others.
5633 The AT_*_pc values for such functions refer to local labels in
5634 these sections. If the section from that file was discarded, the
5635 labels are not in the output, so the relocs get a value of 0.
5636 If this is a discarded function, mark the pc bounds as invalid,
5637 so that GDB will ignore it. */
5638 if (has_low_pc_attr && has_high_pc_attr
5639 && part_die->lowpc < part_die->highpc
5640 && (part_die->lowpc != 0
5641 || dwarf2_per_objfile->has_section_at_zero))
5642 part_die->has_pc_info = 1;
5646 /* Find a cached partial DIE at OFFSET in CU. */
5648 static struct partial_die_info *
5649 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5651 struct partial_die_info *lookup_die = NULL;
5652 struct partial_die_info part_die;
5654 part_die.offset = offset;
5655 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5660 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5662 static struct partial_die_info *
5663 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5665 struct dwarf2_per_cu_data *per_cu = NULL;
5666 struct partial_die_info *pd = NULL;
5668 if (offset >= cu->header.offset
5669 && offset < cu->header.offset + cu->header.length)
5671 pd = find_partial_die_in_comp_unit (offset, cu);
5676 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5678 if (per_cu->cu == NULL)
5680 load_comp_unit (per_cu, cu->objfile);
5681 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5682 dwarf2_per_objfile->read_in_chain = per_cu;
5685 per_cu->cu->last_used = 0;
5686 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5688 if (pd == NULL && per_cu->load_all_dies == 0)
5690 struct cleanup *back_to;
5691 struct partial_die_info comp_unit_die;
5692 struct abbrev_info *abbrev;
5693 unsigned int bytes_read;
5696 per_cu->load_all_dies = 1;
5698 /* Re-read the DIEs. */
5699 back_to = make_cleanup (null_cleanup, 0);
5700 if (per_cu->cu->dwarf2_abbrevs == NULL)
5702 dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
5703 back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
5705 info_ptr = per_cu->cu->header.first_die_ptr;
5706 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
5707 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
5708 per_cu->cu->objfile->obfd, info_ptr,
5710 if (comp_unit_die.has_children)
5711 load_partial_dies (per_cu->cu->objfile->obfd, info_ptr, 0, per_cu->cu);
5712 do_cleanups (back_to);
5714 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5718 internal_error (__FILE__, __LINE__,
5719 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5720 offset, bfd_get_filename (cu->objfile->obfd));
5724 /* Adjust PART_DIE before generating a symbol for it. This function
5725 may set the is_external flag or change the DIE's name. */
5728 fixup_partial_die (struct partial_die_info *part_die,
5729 struct dwarf2_cu *cu)
5731 /* If we found a reference attribute and the DIE has no name, try
5732 to find a name in the referred to DIE. */
5734 if (part_die->name == NULL && part_die->has_specification)
5736 struct partial_die_info *spec_die;
5738 spec_die = find_partial_die (part_die->spec_offset, cu);
5740 fixup_partial_die (spec_die, cu);
5744 part_die->name = spec_die->name;
5746 /* Copy DW_AT_external attribute if it is set. */
5747 if (spec_die->is_external)
5748 part_die->is_external = spec_die->is_external;
5752 /* Set default names for some unnamed DIEs. */
5753 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5754 || part_die->tag == DW_TAG_class_type))
5755 part_die->name = "(anonymous class)";
5757 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5758 part_die->name = "(anonymous namespace)";
5760 if (part_die->tag == DW_TAG_structure_type
5761 || part_die->tag == DW_TAG_class_type
5762 || part_die->tag == DW_TAG_union_type)
5763 guess_structure_name (part_die, cu);
5766 /* Read the die from the .debug_info section buffer. Set DIEP to
5767 point to a newly allocated die with its information, except for its
5768 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5769 whether the die has children or not. */
5772 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5773 struct dwarf2_cu *cu, int *has_children)
5775 unsigned int abbrev_number, bytes_read, i, offset;
5776 struct abbrev_info *abbrev;
5777 struct die_info *die;
5779 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5780 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5781 info_ptr += bytes_read;
5784 die = dwarf_alloc_die ();
5786 die->abbrev = abbrev_number;
5793 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5796 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5798 bfd_get_filename (abfd));
5800 die = dwarf_alloc_die ();
5801 die->offset = offset;
5802 die->tag = abbrev->tag;
5803 die->abbrev = abbrev_number;
5806 die->num_attrs = abbrev->num_attrs;
5807 die->attrs = (struct attribute *)
5808 xmalloc (die->num_attrs * sizeof (struct attribute));
5810 for (i = 0; i < abbrev->num_attrs; ++i)
5812 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5813 abfd, info_ptr, cu);
5815 /* If this attribute is an absolute reference to a different
5816 compilation unit, make sure that compilation unit is loaded
5818 if (die->attrs[i].form == DW_FORM_ref_addr
5819 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5820 || (DW_ADDR (&die->attrs[i])
5821 >= cu->header.offset + cu->header.length)))
5823 struct dwarf2_per_cu_data *per_cu;
5824 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5827 /* Mark the dependence relation so that we don't flush PER_CU
5829 dwarf2_add_dependence (cu, per_cu);
5831 /* If it's already on the queue, we have nothing to do. */
5835 /* If the compilation unit is already loaded, just mark it as
5837 if (per_cu->cu != NULL)
5839 per_cu->cu->last_used = 0;
5843 /* Add it to the queue. */
5844 queue_comp_unit (per_cu);
5849 *has_children = abbrev->has_children;
5853 /* Read an attribute value described by an attribute form. */
5856 read_attribute_value (struct attribute *attr, unsigned form,
5857 bfd *abfd, gdb_byte *info_ptr,
5858 struct dwarf2_cu *cu)
5860 struct comp_unit_head *cu_header = &cu->header;
5861 unsigned int bytes_read;
5862 struct dwarf_block *blk;
5868 case DW_FORM_ref_addr:
5869 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5870 info_ptr += bytes_read;
5872 case DW_FORM_block2:
5873 blk = dwarf_alloc_block (cu);
5874 blk->size = read_2_bytes (abfd, info_ptr);
5876 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5877 info_ptr += blk->size;
5878 DW_BLOCK (attr) = blk;
5880 case DW_FORM_block4:
5881 blk = dwarf_alloc_block (cu);
5882 blk->size = read_4_bytes (abfd, info_ptr);
5884 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5885 info_ptr += blk->size;
5886 DW_BLOCK (attr) = blk;
5889 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5893 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5897 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5900 case DW_FORM_string:
5901 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5902 info_ptr += bytes_read;
5905 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5907 info_ptr += bytes_read;
5910 blk = dwarf_alloc_block (cu);
5911 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5912 info_ptr += bytes_read;
5913 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5914 info_ptr += blk->size;
5915 DW_BLOCK (attr) = blk;
5917 case DW_FORM_block1:
5918 blk = dwarf_alloc_block (cu);
5919 blk->size = read_1_byte (abfd, info_ptr);
5921 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5922 info_ptr += blk->size;
5923 DW_BLOCK (attr) = blk;
5926 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5930 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5934 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5935 info_ptr += bytes_read;
5938 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5939 info_ptr += bytes_read;
5942 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5946 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5950 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5954 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5957 case DW_FORM_ref_udata:
5958 DW_ADDR (attr) = (cu->header.offset
5959 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5960 info_ptr += bytes_read;
5962 case DW_FORM_indirect:
5963 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5964 info_ptr += bytes_read;
5965 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5968 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5969 dwarf_form_name (form),
5970 bfd_get_filename (abfd));
5975 /* Read an attribute described by an abbreviated attribute. */
5978 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5979 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
5981 attr->name = abbrev->name;
5982 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5985 /* read dwarf information from a buffer */
5988 read_1_byte (bfd *abfd, gdb_byte *buf)
5990 return bfd_get_8 (abfd, buf);
5994 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
5996 return bfd_get_signed_8 (abfd, buf);
6000 read_2_bytes (bfd *abfd, gdb_byte *buf)
6002 return bfd_get_16 (abfd, buf);
6006 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
6008 return bfd_get_signed_16 (abfd, buf);
6012 read_4_bytes (bfd *abfd, gdb_byte *buf)
6014 return bfd_get_32 (abfd, buf);
6018 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
6020 return bfd_get_signed_32 (abfd, buf);
6023 static unsigned long
6024 read_8_bytes (bfd *abfd, gdb_byte *buf)
6026 return bfd_get_64 (abfd, buf);
6030 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
6031 unsigned int *bytes_read)
6033 struct comp_unit_head *cu_header = &cu->header;
6034 CORE_ADDR retval = 0;
6036 if (cu_header->signed_addr_p)
6038 switch (cu_header->addr_size)
6041 retval = bfd_get_signed_16 (abfd, buf);
6044 retval = bfd_get_signed_32 (abfd, buf);
6047 retval = bfd_get_signed_64 (abfd, buf);
6050 internal_error (__FILE__, __LINE__,
6051 _("read_address: bad switch, signed [in module %s]"),
6052 bfd_get_filename (abfd));
6057 switch (cu_header->addr_size)
6060 retval = bfd_get_16 (abfd, buf);
6063 retval = bfd_get_32 (abfd, buf);
6066 retval = bfd_get_64 (abfd, buf);
6069 internal_error (__FILE__, __LINE__,
6070 _("read_address: bad switch, unsigned [in module %s]"),
6071 bfd_get_filename (abfd));
6075 *bytes_read = cu_header->addr_size;
6079 /* Read the initial length from a section. The (draft) DWARF 3
6080 specification allows the initial length to take up either 4 bytes
6081 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6082 bytes describe the length and all offsets will be 8 bytes in length
6085 An older, non-standard 64-bit format is also handled by this
6086 function. The older format in question stores the initial length
6087 as an 8-byte quantity without an escape value. Lengths greater
6088 than 2^32 aren't very common which means that the initial 4 bytes
6089 is almost always zero. Since a length value of zero doesn't make
6090 sense for the 32-bit format, this initial zero can be considered to
6091 be an escape value which indicates the presence of the older 64-bit
6092 format. As written, the code can't detect (old format) lengths
6093 greater than 4GB. If it becomes necessary to handle lengths
6094 somewhat larger than 4GB, we could allow other small values (such
6095 as the non-sensical values of 1, 2, and 3) to also be used as
6096 escape values indicating the presence of the old format.
6098 The value returned via bytes_read should be used to increment the
6099 relevant pointer after calling read_initial_length().
6101 As a side effect, this function sets the fields initial_length_size
6102 and offset_size in cu_header to the values appropriate for the
6103 length field. (The format of the initial length field determines
6104 the width of file offsets to be fetched later with read_offset().)
6106 [ Note: read_initial_length() and read_offset() are based on the
6107 document entitled "DWARF Debugging Information Format", revision
6108 3, draft 8, dated November 19, 2001. This document was obtained
6111 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6113 This document is only a draft and is subject to change. (So beware.)
6115 Details regarding the older, non-standard 64-bit format were
6116 determined empirically by examining 64-bit ELF files produced by
6117 the SGI toolchain on an IRIX 6.5 machine.
6119 - Kevin, July 16, 2002
6123 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
6124 unsigned int *bytes_read)
6126 LONGEST length = bfd_get_32 (abfd, buf);
6128 if (length == 0xffffffff)
6130 length = bfd_get_64 (abfd, buf + 4);
6133 else if (length == 0)
6135 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6136 length = bfd_get_64 (abfd, buf);
6146 gdb_assert (cu_header->initial_length_size == 0
6147 || cu_header->initial_length_size == 4
6148 || cu_header->initial_length_size == 8
6149 || cu_header->initial_length_size == 12);
6151 if (cu_header->initial_length_size != 0
6152 && cu_header->initial_length_size != *bytes_read)
6153 complaint (&symfile_complaints,
6154 _("intermixed 32-bit and 64-bit DWARF sections"));
6156 cu_header->initial_length_size = *bytes_read;
6157 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
6163 /* Read an offset from the data stream. The size of the offset is
6164 given by cu_header->offset_size. */
6167 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
6168 unsigned int *bytes_read)
6172 switch (cu_header->offset_size)
6175 retval = bfd_get_32 (abfd, buf);
6179 retval = bfd_get_64 (abfd, buf);
6183 internal_error (__FILE__, __LINE__,
6184 _("read_offset: bad switch [in module %s]"),
6185 bfd_get_filename (abfd));
6192 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
6194 /* If the size of a host char is 8 bits, we can return a pointer
6195 to the buffer, otherwise we have to copy the data to a buffer
6196 allocated on the temporary obstack. */
6197 gdb_assert (HOST_CHAR_BIT == 8);
6202 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6204 /* If the size of a host char is 8 bits, we can return a pointer
6205 to the string, otherwise we have to copy the string to a buffer
6206 allocated on the temporary obstack. */
6207 gdb_assert (HOST_CHAR_BIT == 8);
6210 *bytes_read_ptr = 1;
6213 *bytes_read_ptr = strlen ((char *) buf) + 1;
6214 return (char *) buf;
6218 read_indirect_string (bfd *abfd, gdb_byte *buf,
6219 const struct comp_unit_head *cu_header,
6220 unsigned int *bytes_read_ptr)
6222 LONGEST str_offset = read_offset (abfd, buf, cu_header,
6225 if (dwarf2_per_objfile->str_buffer == NULL)
6227 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6228 bfd_get_filename (abfd));
6231 if (str_offset >= dwarf2_per_objfile->str_size)
6233 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6234 bfd_get_filename (abfd));
6237 gdb_assert (HOST_CHAR_BIT == 8);
6238 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6240 return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6243 static unsigned long
6244 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6246 unsigned long result;
6247 unsigned int num_read;
6257 byte = bfd_get_8 (abfd, buf);
6260 result |= ((unsigned long)(byte & 127) << shift);
6261 if ((byte & 128) == 0)
6267 *bytes_read_ptr = num_read;
6272 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6275 int i, shift, num_read;
6284 byte = bfd_get_8 (abfd, buf);
6287 result |= ((long)(byte & 127) << shift);
6289 if ((byte & 128) == 0)
6294 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6295 result |= -(((long)1) << shift);
6296 *bytes_read_ptr = num_read;
6300 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6303 skip_leb128 (bfd *abfd, gdb_byte *buf)
6309 byte = bfd_get_8 (abfd, buf);
6311 if ((byte & 128) == 0)
6317 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6323 cu->language = language_c;
6325 case DW_LANG_C_plus_plus:
6326 cu->language = language_cplus;
6328 case DW_LANG_Fortran77:
6329 case DW_LANG_Fortran90:
6330 case DW_LANG_Fortran95:
6331 cu->language = language_fortran;
6333 case DW_LANG_Mips_Assembler:
6334 cu->language = language_asm;
6337 cu->language = language_java;
6341 cu->language = language_ada;
6343 case DW_LANG_Modula2:
6344 cu->language = language_m2;
6346 case DW_LANG_Pascal83:
6347 cu->language = language_pascal;
6349 case DW_LANG_Cobol74:
6350 case DW_LANG_Cobol85:
6352 cu->language = language_minimal;
6355 cu->language_defn = language_def (cu->language);
6358 /* Return the named attribute or NULL if not there. */
6360 static struct attribute *
6361 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6364 struct attribute *spec = NULL;
6366 for (i = 0; i < die->num_attrs; ++i)
6368 if (die->attrs[i].name == name)
6369 return &die->attrs[i];
6370 if (die->attrs[i].name == DW_AT_specification
6371 || die->attrs[i].name == DW_AT_abstract_origin)
6372 spec = &die->attrs[i];
6376 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6381 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6382 and holds a non-zero value. This function should only be used for
6383 DW_FORM_flag attributes. */
6386 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6388 struct attribute *attr = dwarf2_attr (die, name, cu);
6390 return (attr && DW_UNSND (attr));
6394 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6396 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6397 which value is non-zero. However, we have to be careful with
6398 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6399 (via dwarf2_flag_true_p) follows this attribute. So we may
6400 end up accidently finding a declaration attribute that belongs
6401 to a different DIE referenced by the specification attribute,
6402 even though the given DIE does not have a declaration attribute. */
6403 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6404 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6407 /* Return the die giving the specification for DIE, if there is
6410 static struct die_info *
6411 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6413 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6415 if (spec_attr == NULL)
6418 return follow_die_ref (die, spec_attr, cu);
6421 /* Free the line_header structure *LH, and any arrays and strings it
6424 free_line_header (struct line_header *lh)
6426 if (lh->standard_opcode_lengths)
6427 xfree (lh->standard_opcode_lengths);
6429 /* Remember that all the lh->file_names[i].name pointers are
6430 pointers into debug_line_buffer, and don't need to be freed. */
6432 xfree (lh->file_names);
6434 /* Similarly for the include directory names. */
6435 if (lh->include_dirs)
6436 xfree (lh->include_dirs);
6442 /* Add an entry to LH's include directory table. */
6444 add_include_dir (struct line_header *lh, char *include_dir)
6446 /* Grow the array if necessary. */
6447 if (lh->include_dirs_size == 0)
6449 lh->include_dirs_size = 1; /* for testing */
6450 lh->include_dirs = xmalloc (lh->include_dirs_size
6451 * sizeof (*lh->include_dirs));
6453 else if (lh->num_include_dirs >= lh->include_dirs_size)
6455 lh->include_dirs_size *= 2;
6456 lh->include_dirs = xrealloc (lh->include_dirs,
6457 (lh->include_dirs_size
6458 * sizeof (*lh->include_dirs)));
6461 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6465 /* Add an entry to LH's file name table. */
6467 add_file_name (struct line_header *lh,
6469 unsigned int dir_index,
6470 unsigned int mod_time,
6471 unsigned int length)
6473 struct file_entry *fe;
6475 /* Grow the array if necessary. */
6476 if (lh->file_names_size == 0)
6478 lh->file_names_size = 1; /* for testing */
6479 lh->file_names = xmalloc (lh->file_names_size
6480 * sizeof (*lh->file_names));
6482 else if (lh->num_file_names >= lh->file_names_size)
6484 lh->file_names_size *= 2;
6485 lh->file_names = xrealloc (lh->file_names,
6486 (lh->file_names_size
6487 * sizeof (*lh->file_names)));
6490 fe = &lh->file_names[lh->num_file_names++];
6492 fe->dir_index = dir_index;
6493 fe->mod_time = mod_time;
6494 fe->length = length;
6500 /* Read the statement program header starting at OFFSET in
6501 .debug_line, according to the endianness of ABFD. Return a pointer
6502 to a struct line_header, allocated using xmalloc.
6504 NOTE: the strings in the include directory and file name tables of
6505 the returned object point into debug_line_buffer, and must not be
6507 static struct line_header *
6508 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6509 struct dwarf2_cu *cu)
6511 struct cleanup *back_to;
6512 struct line_header *lh;
6514 unsigned int bytes_read;
6516 char *cur_dir, *cur_file;
6518 if (dwarf2_per_objfile->line_buffer == NULL)
6520 complaint (&symfile_complaints, _("missing .debug_line section"));
6524 /* Make sure that at least there's room for the total_length field.
6525 That could be 12 bytes long, but we're just going to fudge that. */
6526 if (offset + 4 >= dwarf2_per_objfile->line_size)
6528 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6532 lh = xmalloc (sizeof (*lh));
6533 memset (lh, 0, sizeof (*lh));
6534 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6537 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6539 /* Read in the header. */
6541 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6542 line_ptr += bytes_read;
6543 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6544 + dwarf2_per_objfile->line_size))
6546 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6549 lh->statement_program_end = line_ptr + lh->total_length;
6550 lh->version = read_2_bytes (abfd, line_ptr);
6552 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6553 line_ptr += bytes_read;
6554 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6556 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6558 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6560 lh->line_range = read_1_byte (abfd, line_ptr);
6562 lh->opcode_base = read_1_byte (abfd, line_ptr);
6564 lh->standard_opcode_lengths
6565 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6567 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6568 for (i = 1; i < lh->opcode_base; ++i)
6570 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6574 /* Read directory table. */
6575 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6577 line_ptr += bytes_read;
6578 add_include_dir (lh, cur_dir);
6580 line_ptr += bytes_read;
6582 /* Read file name table. */
6583 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6585 unsigned int dir_index, mod_time, length;
6587 line_ptr += bytes_read;
6588 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6589 line_ptr += bytes_read;
6590 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6591 line_ptr += bytes_read;
6592 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6593 line_ptr += bytes_read;
6595 add_file_name (lh, cur_file, dir_index, mod_time, length);
6597 line_ptr += bytes_read;
6598 lh->statement_program_start = line_ptr;
6600 if (line_ptr > (dwarf2_per_objfile->line_buffer
6601 + dwarf2_per_objfile->line_size))
6602 complaint (&symfile_complaints,
6603 _("line number info header doesn't fit in `.debug_line' section"));
6605 discard_cleanups (back_to);
6609 /* This function exists to work around a bug in certain compilers
6610 (particularly GCC 2.95), in which the first line number marker of a
6611 function does not show up until after the prologue, right before
6612 the second line number marker. This function shifts ADDRESS down
6613 to the beginning of the function if necessary, and is called on
6614 addresses passed to record_line. */
6617 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6619 struct function_range *fn;
6621 /* Find the function_range containing address. */
6626 cu->cached_fn = cu->first_fn;
6630 if (fn->lowpc <= address && fn->highpc > address)
6636 while (fn && fn != cu->cached_fn)
6637 if (fn->lowpc <= address && fn->highpc > address)
6647 if (address != fn->lowpc)
6648 complaint (&symfile_complaints,
6649 _("misplaced first line number at 0x%lx for '%s'"),
6650 (unsigned long) address, fn->name);
6655 /* Decode the Line Number Program (LNP) for the given line_header
6656 structure and CU. The actual information extracted and the type
6657 of structures created from the LNP depends on the value of PST.
6659 1. If PST is NULL, then this procedure uses the data from the program
6660 to create all necessary symbol tables, and their linetables.
6661 The compilation directory of the file is passed in COMP_DIR,
6662 and must not be NULL.
6664 2. If PST is not NULL, this procedure reads the program to determine
6665 the list of files included by the unit represented by PST, and
6666 builds all the associated partial symbol tables. In this case,
6667 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6668 is not used to compute the full name of the symtab, and therefore
6669 omitting it when building the partial symtab does not introduce
6670 the potential for inconsistency - a partial symtab and its associated
6671 symbtab having a different fullname -). */
6674 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6675 struct dwarf2_cu *cu, struct partial_symtab *pst)
6677 gdb_byte *line_ptr, *extended_end;
6679 unsigned int bytes_read, extended_len;
6680 unsigned char op_code, extended_op, adj_opcode;
6682 struct objfile *objfile = cu->objfile;
6683 const int decode_for_pst_p = (pst != NULL);
6684 struct subfile *last_subfile = NULL, *first_subfile = current_subfile;
6686 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6688 line_ptr = lh->statement_program_start;
6689 line_end = lh->statement_program_end;
6691 /* Read the statement sequences until there's nothing left. */
6692 while (line_ptr < line_end)
6694 /* state machine registers */
6695 CORE_ADDR address = 0;
6696 unsigned int file = 1;
6697 unsigned int line = 1;
6698 unsigned int column = 0;
6699 int is_stmt = lh->default_is_stmt;
6700 int basic_block = 0;
6701 int end_sequence = 0;
6703 if (!decode_for_pst_p && lh->num_file_names >= file)
6705 /* Start a subfile for the current file of the state machine. */
6706 /* lh->include_dirs and lh->file_names are 0-based, but the
6707 directory and file name numbers in the statement program
6709 struct file_entry *fe = &lh->file_names[file - 1];
6713 dir = lh->include_dirs[fe->dir_index - 1];
6715 dwarf2_start_subfile (fe->name, dir, comp_dir);
6718 /* Decode the table. */
6719 while (!end_sequence)
6721 op_code = read_1_byte (abfd, line_ptr);
6724 if (op_code >= lh->opcode_base)
6726 /* Special operand. */
6727 adj_opcode = op_code - lh->opcode_base;
6728 address += (adj_opcode / lh->line_range)
6729 * lh->minimum_instruction_length;
6730 line += lh->line_base + (adj_opcode % lh->line_range);
6731 if (lh->num_file_names < file)
6732 dwarf2_debug_line_missing_file_complaint ();
6735 lh->file_names[file - 1].included_p = 1;
6736 if (!decode_for_pst_p)
6738 if (last_subfile != current_subfile)
6741 record_line (last_subfile, 0, address);
6742 last_subfile = current_subfile;
6744 /* Append row to matrix using current values. */
6745 record_line (current_subfile, line,
6746 check_cu_functions (address, cu));
6751 else switch (op_code)
6753 case DW_LNS_extended_op:
6754 extended_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6755 line_ptr += bytes_read;
6756 extended_end = line_ptr + extended_len;
6757 extended_op = read_1_byte (abfd, line_ptr);
6759 switch (extended_op)
6761 case DW_LNE_end_sequence:
6764 if (lh->num_file_names < file)
6765 dwarf2_debug_line_missing_file_complaint ();
6768 lh->file_names[file - 1].included_p = 1;
6769 if (!decode_for_pst_p)
6770 record_line (current_subfile, 0, address);
6773 case DW_LNE_set_address:
6774 address = read_address (abfd, line_ptr, cu, &bytes_read);
6775 line_ptr += bytes_read;
6776 address += baseaddr;
6778 case DW_LNE_define_file:
6781 unsigned int dir_index, mod_time, length;
6783 cur_file = read_string (abfd, line_ptr, &bytes_read);
6784 line_ptr += bytes_read;
6786 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6787 line_ptr += bytes_read;
6789 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6790 line_ptr += bytes_read;
6792 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6793 line_ptr += bytes_read;
6794 add_file_name (lh, cur_file, dir_index, mod_time, length);
6798 complaint (&symfile_complaints,
6799 _("mangled .debug_line section"));
6802 /* Make sure that we parsed the extended op correctly. If e.g.
6803 we expected a different address size than the producer used,
6804 we may have read the wrong number of bytes. */
6805 if (line_ptr != extended_end)
6807 complaint (&symfile_complaints,
6808 _("mangled .debug_line section"));
6813 if (lh->num_file_names < file)
6814 dwarf2_debug_line_missing_file_complaint ();
6817 lh->file_names[file - 1].included_p = 1;
6818 if (!decode_for_pst_p)
6820 if (last_subfile != current_subfile)
6823 record_line (last_subfile, 0, address);
6824 last_subfile = current_subfile;
6826 record_line (current_subfile, line,
6827 check_cu_functions (address, cu));
6832 case DW_LNS_advance_pc:
6833 address += lh->minimum_instruction_length
6834 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6835 line_ptr += bytes_read;
6837 case DW_LNS_advance_line:
6838 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6839 line_ptr += bytes_read;
6841 case DW_LNS_set_file:
6843 /* The arrays lh->include_dirs and lh->file_names are
6844 0-based, but the directory and file name numbers in
6845 the statement program are 1-based. */
6846 struct file_entry *fe;
6849 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6850 line_ptr += bytes_read;
6851 if (lh->num_file_names < file)
6852 dwarf2_debug_line_missing_file_complaint ();
6855 fe = &lh->file_names[file - 1];
6857 dir = lh->include_dirs[fe->dir_index - 1];
6858 if (!decode_for_pst_p)
6860 last_subfile = current_subfile;
6861 dwarf2_start_subfile (fe->name, dir, comp_dir);
6866 case DW_LNS_set_column:
6867 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6868 line_ptr += bytes_read;
6870 case DW_LNS_negate_stmt:
6871 is_stmt = (!is_stmt);
6873 case DW_LNS_set_basic_block:
6876 /* Add to the address register of the state machine the
6877 address increment value corresponding to special opcode
6878 255. I.e., this value is scaled by the minimum
6879 instruction length since special opcode 255 would have
6880 scaled the the increment. */
6881 case DW_LNS_const_add_pc:
6882 address += (lh->minimum_instruction_length
6883 * ((255 - lh->opcode_base) / lh->line_range));
6885 case DW_LNS_fixed_advance_pc:
6886 address += read_2_bytes (abfd, line_ptr);
6891 /* Unknown standard opcode, ignore it. */
6894 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6896 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6897 line_ptr += bytes_read;
6904 if (decode_for_pst_p)
6908 /* Now that we're done scanning the Line Header Program, we can
6909 create the psymtab of each included file. */
6910 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6911 if (lh->file_names[file_index].included_p == 1)
6913 const struct file_entry fe = lh->file_names [file_index];
6914 char *include_name = fe.name;
6915 char *dir_name = NULL;
6916 char *pst_filename = pst->filename;
6919 dir_name = lh->include_dirs[fe.dir_index - 1];
6921 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6923 include_name = concat (dir_name, SLASH_STRING,
6924 include_name, (char *)NULL);
6925 make_cleanup (xfree, include_name);
6928 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6930 pst_filename = concat (pst->dirname, SLASH_STRING,
6931 pst_filename, (char *)NULL);
6932 make_cleanup (xfree, pst_filename);
6935 if (strcmp (include_name, pst_filename) != 0)
6936 dwarf2_create_include_psymtab (include_name, pst, objfile);
6941 /* Make sure a symtab is created for every file, even files
6942 which contain only variables (i.e. no code with associated
6946 struct file_entry *fe;
6948 for (i = 0; i < lh->num_file_names; i++)
6951 fe = &lh->file_names[i];
6953 dir = lh->include_dirs[fe->dir_index - 1];
6954 dwarf2_start_subfile (fe->name, dir, comp_dir);
6956 /* Skip the main file; we don't need it, and it must be
6957 allocated last, so that it will show up before the
6958 non-primary symtabs in the objfile's symtab list. */
6959 if (current_subfile == first_subfile)
6962 if (current_subfile->symtab == NULL)
6963 current_subfile->symtab = allocate_symtab (current_subfile->name,
6965 fe->symtab = current_subfile->symtab;
6970 /* Start a subfile for DWARF. FILENAME is the name of the file and
6971 DIRNAME the name of the source directory which contains FILENAME
6972 or NULL if not known. COMP_DIR is the compilation directory for the
6973 linetable's compilation unit or NULL if not known.
6974 This routine tries to keep line numbers from identical absolute and
6975 relative file names in a common subfile.
6977 Using the `list' example from the GDB testsuite, which resides in
6978 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6979 of /srcdir/list0.c yields the following debugging information for list0.c:
6981 DW_AT_name: /srcdir/list0.c
6982 DW_AT_comp_dir: /compdir
6983 files.files[0].name: list0.h
6984 files.files[0].dir: /srcdir
6985 files.files[1].name: list0.c
6986 files.files[1].dir: /srcdir
6988 The line number information for list0.c has to end up in a single
6989 subfile, so that `break /srcdir/list0.c:1' works as expected.
6990 start_subfile will ensure that this happens provided that we pass the
6991 concatenation of files.files[1].dir and files.files[1].name as the
6995 dwarf2_start_subfile (char *filename, char *dirname, char *comp_dir)
6999 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7000 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7001 second argument to start_subfile. To be consistent, we do the
7002 same here. In order not to lose the line information directory,
7003 we concatenate it to the filename when it makes sense.
7004 Note that the Dwarf3 standard says (speaking of filenames in line
7005 information): ``The directory index is ignored for file names
7006 that represent full path names''. Thus ignoring dirname in the
7007 `else' branch below isn't an issue. */
7009 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
7010 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
7012 fullname = filename;
7014 start_subfile (fullname, comp_dir);
7016 if (fullname != filename)
7021 var_decode_location (struct attribute *attr, struct symbol *sym,
7022 struct dwarf2_cu *cu)
7024 struct objfile *objfile = cu->objfile;
7025 struct comp_unit_head *cu_header = &cu->header;
7027 /* NOTE drow/2003-01-30: There used to be a comment and some special
7028 code here to turn a symbol with DW_AT_external and a
7029 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7030 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7031 with some versions of binutils) where shared libraries could have
7032 relocations against symbols in their debug information - the
7033 minimal symbol would have the right address, but the debug info
7034 would not. It's no longer necessary, because we will explicitly
7035 apply relocations when we read in the debug information now. */
7037 /* A DW_AT_location attribute with no contents indicates that a
7038 variable has been optimized away. */
7039 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
7041 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7045 /* Handle one degenerate form of location expression specially, to
7046 preserve GDB's previous behavior when section offsets are
7047 specified. If this is just a DW_OP_addr then mark this symbol
7050 if (attr_form_is_block (attr)
7051 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
7052 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
7056 SYMBOL_VALUE_ADDRESS (sym) =
7057 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
7058 fixup_symbol_section (sym, objfile);
7059 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
7060 SYMBOL_SECTION (sym));
7061 SYMBOL_CLASS (sym) = LOC_STATIC;
7065 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7066 expression evaluator, and use LOC_COMPUTED only when necessary
7067 (i.e. when the value of a register or memory location is
7068 referenced, or a thread-local block, etc.). Then again, it might
7069 not be worthwhile. I'm assuming that it isn't unless performance
7070 or memory numbers show me otherwise. */
7072 dwarf2_symbol_mark_computed (attr, sym, cu);
7073 SYMBOL_CLASS (sym) = LOC_COMPUTED;
7076 /* Given a pointer to a DWARF information entry, figure out if we need
7077 to make a symbol table entry for it, and if so, create a new entry
7078 and return a pointer to it.
7079 If TYPE is NULL, determine symbol type from the die, otherwise
7080 used the passed type. */
7082 static struct symbol *
7083 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
7085 struct objfile *objfile = cu->objfile;
7086 struct symbol *sym = NULL;
7088 struct attribute *attr = NULL;
7089 struct attribute *attr2 = NULL;
7092 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7094 if (die->tag != DW_TAG_namespace)
7095 name = dwarf2_linkage_name (die, cu);
7097 name = TYPE_NAME (type);
7101 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
7102 sizeof (struct symbol));
7103 OBJSTAT (objfile, n_syms++);
7104 memset (sym, 0, sizeof (struct symbol));
7106 /* Cache this symbol's name and the name's demangled form (if any). */
7107 SYMBOL_LANGUAGE (sym) = cu->language;
7108 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
7110 /* Default assumptions.
7111 Use the passed type or decode it from the die. */
7112 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7113 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7115 SYMBOL_TYPE (sym) = type;
7117 SYMBOL_TYPE (sym) = die_type (die, cu);
7118 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
7121 SYMBOL_LINE (sym) = DW_UNSND (attr);
7124 attr = dwarf2_attr (die, DW_AT_decl_file, cu);
7127 int file_index = DW_UNSND (attr);
7128 if (cu->line_header == NULL
7129 || file_index > cu->line_header->num_file_names)
7130 complaint (&symfile_complaints,
7131 _("file index out of range"));
7132 else if (file_index > 0)
7134 struct file_entry *fe;
7135 fe = &cu->line_header->file_names[file_index - 1];
7136 SYMBOL_SYMTAB (sym) = fe->symtab;
7143 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
7146 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
7148 SYMBOL_CLASS (sym) = LOC_LABEL;
7150 case DW_TAG_subprogram:
7151 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7153 SYMBOL_CLASS (sym) = LOC_BLOCK;
7154 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7155 if (attr2 && (DW_UNSND (attr2) != 0))
7157 add_symbol_to_list (sym, &global_symbols);
7161 add_symbol_to_list (sym, cu->list_in_scope);
7164 case DW_TAG_variable:
7165 /* Compilation with minimal debug info may result in variables
7166 with missing type entries. Change the misleading `void' type
7167 to something sensible. */
7168 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
7170 = builtin_type (current_gdbarch)->nodebug_data_symbol;
7172 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7175 dwarf2_const_value (attr, sym, cu);
7176 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7177 if (attr2 && (DW_UNSND (attr2) != 0))
7178 add_symbol_to_list (sym, &global_symbols);
7180 add_symbol_to_list (sym, cu->list_in_scope);
7183 attr = dwarf2_attr (die, DW_AT_location, cu);
7186 var_decode_location (attr, sym, cu);
7187 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7188 if (attr2 && (DW_UNSND (attr2) != 0))
7189 add_symbol_to_list (sym, &global_symbols);
7191 add_symbol_to_list (sym, cu->list_in_scope);
7195 /* We do not know the address of this symbol.
7196 If it is an external symbol and we have type information
7197 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7198 The address of the variable will then be determined from
7199 the minimal symbol table whenever the variable is
7201 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7202 if (attr2 && (DW_UNSND (attr2) != 0)
7203 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
7205 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
7206 add_symbol_to_list (sym, &global_symbols);
7210 case DW_TAG_formal_parameter:
7211 attr = dwarf2_attr (die, DW_AT_location, cu);
7214 var_decode_location (attr, sym, cu);
7215 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7216 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
7217 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
7219 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7222 dwarf2_const_value (attr, sym, cu);
7224 add_symbol_to_list (sym, cu->list_in_scope);
7226 case DW_TAG_unspecified_parameters:
7227 /* From varargs functions; gdb doesn't seem to have any
7228 interest in this information, so just ignore it for now.
7231 case DW_TAG_class_type:
7232 case DW_TAG_structure_type:
7233 case DW_TAG_union_type:
7234 case DW_TAG_set_type:
7235 case DW_TAG_enumeration_type:
7236 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7237 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7239 /* Make sure that the symbol includes appropriate enclosing
7240 classes/namespaces in its name. These are calculated in
7241 read_structure_type, and the correct name is saved in
7244 if (cu->language == language_cplus
7245 || cu->language == language_java)
7247 struct type *type = SYMBOL_TYPE (sym);
7249 if (TYPE_TAG_NAME (type) != NULL)
7251 /* FIXME: carlton/2003-11-10: Should this use
7252 SYMBOL_SET_NAMES instead? (The same problem also
7253 arises further down in this function.) */
7254 /* The type's name is already allocated along with
7255 this objfile, so we don't need to duplicate it
7257 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
7262 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7263 really ever be static objects: otherwise, if you try
7264 to, say, break of a class's method and you're in a file
7265 which doesn't mention that class, it won't work unless
7266 the check for all static symbols in lookup_symbol_aux
7267 saves you. See the OtherFileClass tests in
7268 gdb.c++/namespace.exp. */
7270 struct pending **list_to_add;
7272 list_to_add = (cu->list_in_scope == &file_symbols
7273 && (cu->language == language_cplus
7274 || cu->language == language_java)
7275 ? &global_symbols : cu->list_in_scope);
7277 add_symbol_to_list (sym, list_to_add);
7279 /* The semantics of C++ state that "struct foo { ... }" also
7280 defines a typedef for "foo". A Java class declaration also
7281 defines a typedef for the class. Synthesize a typedef symbol
7282 so that "ptype foo" works as expected. */
7283 if (cu->language == language_cplus
7284 || cu->language == language_java
7285 || cu->language == language_ada)
7287 struct symbol *typedef_sym = (struct symbol *)
7288 obstack_alloc (&objfile->objfile_obstack,
7289 sizeof (struct symbol));
7290 *typedef_sym = *sym;
7291 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
7292 /* The symbol's name is already allocated along with
7293 this objfile, so we don't need to duplicate it for
7295 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
7296 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
7297 add_symbol_to_list (typedef_sym, list_to_add);
7301 case DW_TAG_typedef:
7302 if (processing_has_namespace_info
7303 && processing_current_prefix[0] != '\0')
7305 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7306 processing_current_prefix,
7309 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7310 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7311 add_symbol_to_list (sym, cu->list_in_scope);
7313 case DW_TAG_base_type:
7314 case DW_TAG_subrange_type:
7315 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7316 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7317 add_symbol_to_list (sym, cu->list_in_scope);
7319 case DW_TAG_enumerator:
7320 if (processing_has_namespace_info
7321 && processing_current_prefix[0] != '\0')
7323 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7324 processing_current_prefix,
7327 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7330 dwarf2_const_value (attr, sym, cu);
7333 /* NOTE: carlton/2003-11-10: See comment above in the
7334 DW_TAG_class_type, etc. block. */
7336 struct pending **list_to_add;
7338 list_to_add = (cu->list_in_scope == &file_symbols
7339 && (cu->language == language_cplus
7340 || cu->language == language_java)
7341 ? &global_symbols : cu->list_in_scope);
7343 add_symbol_to_list (sym, list_to_add);
7346 case DW_TAG_namespace:
7347 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7348 add_symbol_to_list (sym, &global_symbols);
7351 /* Not a tag we recognize. Hopefully we aren't processing
7352 trash data, but since we must specifically ignore things
7353 we don't recognize, there is nothing else we should do at
7355 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7356 dwarf_tag_name (die->tag));
7363 /* Copy constant value from an attribute to a symbol. */
7366 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7367 struct dwarf2_cu *cu)
7369 struct objfile *objfile = cu->objfile;
7370 struct comp_unit_head *cu_header = &cu->header;
7371 struct dwarf_block *blk;
7376 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7377 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7378 cu_header->addr_size,
7379 TYPE_LENGTH (SYMBOL_TYPE
7381 SYMBOL_VALUE_BYTES (sym) =
7382 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7383 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7384 it's body - store_unsigned_integer. */
7385 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7387 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7389 case DW_FORM_block1:
7390 case DW_FORM_block2:
7391 case DW_FORM_block4:
7393 blk = DW_BLOCK (attr);
7394 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7395 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7397 TYPE_LENGTH (SYMBOL_TYPE
7399 SYMBOL_VALUE_BYTES (sym) =
7400 obstack_alloc (&objfile->objfile_obstack, blk->size);
7401 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7402 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7405 /* The DW_AT_const_value attributes are supposed to carry the
7406 symbol's value "represented as it would be on the target
7407 architecture." By the time we get here, it's already been
7408 converted to host endianness, so we just need to sign- or
7409 zero-extend it as appropriate. */
7411 dwarf2_const_value_data (attr, sym, 8);
7414 dwarf2_const_value_data (attr, sym, 16);
7417 dwarf2_const_value_data (attr, sym, 32);
7420 dwarf2_const_value_data (attr, sym, 64);
7424 SYMBOL_VALUE (sym) = DW_SND (attr);
7425 SYMBOL_CLASS (sym) = LOC_CONST;
7429 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7430 SYMBOL_CLASS (sym) = LOC_CONST;
7434 complaint (&symfile_complaints,
7435 _("unsupported const value attribute form: '%s'"),
7436 dwarf_form_name (attr->form));
7437 SYMBOL_VALUE (sym) = 0;
7438 SYMBOL_CLASS (sym) = LOC_CONST;
7444 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7445 or zero-extend it as appropriate for the symbol's type. */
7447 dwarf2_const_value_data (struct attribute *attr,
7451 LONGEST l = DW_UNSND (attr);
7453 if (bits < sizeof (l) * 8)
7455 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7456 l &= ((LONGEST) 1 << bits) - 1;
7458 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7461 SYMBOL_VALUE (sym) = l;
7462 SYMBOL_CLASS (sym) = LOC_CONST;
7466 /* Return the type of the die in question using its DW_AT_type attribute. */
7468 static struct type *
7469 die_type (struct die_info *die, struct dwarf2_cu *cu)
7472 struct attribute *type_attr;
7473 struct die_info *type_die;
7475 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7478 /* A missing DW_AT_type represents a void type. */
7479 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7482 type_die = follow_die_ref (die, type_attr, cu);
7484 type = tag_type_to_type (type_die, cu);
7487 dump_die (type_die);
7488 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7494 /* Return the containing type of the die in question using its
7495 DW_AT_containing_type attribute. */
7497 static struct type *
7498 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7500 struct type *type = NULL;
7501 struct attribute *type_attr;
7502 struct die_info *type_die = NULL;
7504 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7507 type_die = follow_die_ref (die, type_attr, cu);
7508 type = tag_type_to_type (type_die, cu);
7513 dump_die (type_die);
7514 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7520 static struct type *
7521 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7529 read_type_die (die, cu);
7533 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7541 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7543 char *prefix = determine_prefix (die, cu);
7544 const char *old_prefix = processing_current_prefix;
7545 struct cleanup *back_to = make_cleanup (xfree, prefix);
7546 processing_current_prefix = prefix;
7550 case DW_TAG_class_type:
7551 case DW_TAG_structure_type:
7552 case DW_TAG_union_type:
7553 read_structure_type (die, cu);
7555 case DW_TAG_enumeration_type:
7556 read_enumeration_type (die, cu);
7558 case DW_TAG_subprogram:
7559 case DW_TAG_subroutine_type:
7560 read_subroutine_type (die, cu);
7562 case DW_TAG_array_type:
7563 read_array_type (die, cu);
7565 case DW_TAG_set_type:
7566 read_set_type (die, cu);
7568 case DW_TAG_pointer_type:
7569 read_tag_pointer_type (die, cu);
7571 case DW_TAG_ptr_to_member_type:
7572 read_tag_ptr_to_member_type (die, cu);
7574 case DW_TAG_reference_type:
7575 read_tag_reference_type (die, cu);
7577 case DW_TAG_const_type:
7578 read_tag_const_type (die, cu);
7580 case DW_TAG_volatile_type:
7581 read_tag_volatile_type (die, cu);
7583 case DW_TAG_string_type:
7584 read_tag_string_type (die, cu);
7586 case DW_TAG_typedef:
7587 read_typedef (die, cu);
7589 case DW_TAG_subrange_type:
7590 read_subrange_type (die, cu);
7592 case DW_TAG_base_type:
7593 read_base_type (die, cu);
7595 case DW_TAG_unspecified_type:
7596 read_unspecified_type (die, cu);
7599 complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
7600 dwarf_tag_name (die->tag));
7604 processing_current_prefix = old_prefix;
7605 do_cleanups (back_to);
7608 /* Return the name of the namespace/class that DIE is defined within,
7609 or "" if we can't tell. The caller should xfree the result. */
7611 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7612 therein) for an example of how to use this function to deal with
7613 DW_AT_specification. */
7616 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7618 struct die_info *parent;
7620 if (cu->language != language_cplus
7621 && cu->language != language_java)
7624 parent = die->parent;
7628 return xstrdup ("");
7632 switch (parent->tag) {
7633 case DW_TAG_namespace:
7635 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7636 before doing this check? */
7637 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7639 return xstrdup (TYPE_TAG_NAME (parent->type));
7644 char *parent_prefix = determine_prefix (parent, cu);
7645 char *retval = typename_concat (NULL, parent_prefix,
7646 namespace_name (parent, &dummy,
7649 xfree (parent_prefix);
7654 case DW_TAG_class_type:
7655 case DW_TAG_structure_type:
7657 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7659 return xstrdup (TYPE_TAG_NAME (parent->type));
7663 const char *old_prefix = processing_current_prefix;
7664 char *new_prefix = determine_prefix (parent, cu);
7667 processing_current_prefix = new_prefix;
7668 retval = determine_class_name (parent, cu);
7669 processing_current_prefix = old_prefix;
7676 return determine_prefix (parent, cu);
7681 /* Return a newly-allocated string formed by concatenating PREFIX and
7682 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7683 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7684 perform an obconcat, otherwise allocate storage for the result. The CU argument
7685 is used to determine the language and hence, the appropriate separator. */
7687 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7690 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7691 struct dwarf2_cu *cu)
7695 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7697 else if (cu->language == language_java)
7704 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7709 strcpy (retval, prefix);
7710 strcat (retval, sep);
7713 strcat (retval, suffix);
7719 /* We have an obstack. */
7720 return obconcat (obs, prefix, sep, suffix);
7724 static struct type *
7725 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7727 struct objfile *objfile = cu->objfile;
7729 /* FIXME - this should not produce a new (struct type *)
7730 every time. It should cache base types. */
7734 case DW_ATE_address:
7735 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7737 case DW_ATE_boolean:
7738 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7740 case DW_ATE_complex_float:
7743 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7747 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7753 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7757 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7764 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7767 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7771 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7775 case DW_ATE_signed_char:
7776 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7778 case DW_ATE_unsigned:
7782 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7785 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7789 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7793 case DW_ATE_unsigned_char:
7794 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7797 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7804 copy_die (struct die_info *old_die)
7806 struct die_info *new_die;
7809 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7810 memset (new_die, 0, sizeof (struct die_info));
7812 new_die->tag = old_die->tag;
7813 new_die->has_children = old_die->has_children;
7814 new_die->abbrev = old_die->abbrev;
7815 new_die->offset = old_die->offset;
7816 new_die->type = NULL;
7818 num_attrs = old_die->num_attrs;
7819 new_die->num_attrs = num_attrs;
7820 new_die->attrs = (struct attribute *)
7821 xmalloc (num_attrs * sizeof (struct attribute));
7823 for (i = 0; i < old_die->num_attrs; ++i)
7825 new_die->attrs[i].name = old_die->attrs[i].name;
7826 new_die->attrs[i].form = old_die->attrs[i].form;
7827 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7830 new_die->next = NULL;
7835 /* Return sibling of die, NULL if no sibling. */
7837 static struct die_info *
7838 sibling_die (struct die_info *die)
7840 return die->sibling;
7843 /* Get linkage name of a die, return NULL if not found. */
7846 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7848 struct attribute *attr;
7850 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7851 if (attr && DW_STRING (attr))
7852 return DW_STRING (attr);
7853 attr = dwarf2_attr (die, DW_AT_name, cu);
7854 if (attr && DW_STRING (attr))
7855 return DW_STRING (attr);
7859 /* Get name of a die, return NULL if not found. */
7862 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7864 struct attribute *attr;
7866 attr = dwarf2_attr (die, DW_AT_name, cu);
7867 if (attr && DW_STRING (attr))
7868 return DW_STRING (attr);
7872 /* Return the die that this die in an extension of, or NULL if there
7875 static struct die_info *
7876 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7878 struct attribute *attr;
7880 attr = dwarf2_attr (die, DW_AT_extension, cu);
7884 return follow_die_ref (die, attr, cu);
7887 /* Convert a DIE tag into its string name. */
7890 dwarf_tag_name (unsigned tag)
7894 case DW_TAG_padding:
7895 return "DW_TAG_padding";
7896 case DW_TAG_array_type:
7897 return "DW_TAG_array_type";
7898 case DW_TAG_class_type:
7899 return "DW_TAG_class_type";
7900 case DW_TAG_entry_point:
7901 return "DW_TAG_entry_point";
7902 case DW_TAG_enumeration_type:
7903 return "DW_TAG_enumeration_type";
7904 case DW_TAG_formal_parameter:
7905 return "DW_TAG_formal_parameter";
7906 case DW_TAG_imported_declaration:
7907 return "DW_TAG_imported_declaration";
7909 return "DW_TAG_label";
7910 case DW_TAG_lexical_block:
7911 return "DW_TAG_lexical_block";
7913 return "DW_TAG_member";
7914 case DW_TAG_pointer_type:
7915 return "DW_TAG_pointer_type";
7916 case DW_TAG_reference_type:
7917 return "DW_TAG_reference_type";
7918 case DW_TAG_compile_unit:
7919 return "DW_TAG_compile_unit";
7920 case DW_TAG_string_type:
7921 return "DW_TAG_string_type";
7922 case DW_TAG_structure_type:
7923 return "DW_TAG_structure_type";
7924 case DW_TAG_subroutine_type:
7925 return "DW_TAG_subroutine_type";
7926 case DW_TAG_typedef:
7927 return "DW_TAG_typedef";
7928 case DW_TAG_union_type:
7929 return "DW_TAG_union_type";
7930 case DW_TAG_unspecified_parameters:
7931 return "DW_TAG_unspecified_parameters";
7932 case DW_TAG_variant:
7933 return "DW_TAG_variant";
7934 case DW_TAG_common_block:
7935 return "DW_TAG_common_block";
7936 case DW_TAG_common_inclusion:
7937 return "DW_TAG_common_inclusion";
7938 case DW_TAG_inheritance:
7939 return "DW_TAG_inheritance";
7940 case DW_TAG_inlined_subroutine:
7941 return "DW_TAG_inlined_subroutine";
7943 return "DW_TAG_module";
7944 case DW_TAG_ptr_to_member_type:
7945 return "DW_TAG_ptr_to_member_type";
7946 case DW_TAG_set_type:
7947 return "DW_TAG_set_type";
7948 case DW_TAG_subrange_type:
7949 return "DW_TAG_subrange_type";
7950 case DW_TAG_with_stmt:
7951 return "DW_TAG_with_stmt";
7952 case DW_TAG_access_declaration:
7953 return "DW_TAG_access_declaration";
7954 case DW_TAG_base_type:
7955 return "DW_TAG_base_type";
7956 case DW_TAG_catch_block:
7957 return "DW_TAG_catch_block";
7958 case DW_TAG_const_type:
7959 return "DW_TAG_const_type";
7960 case DW_TAG_constant:
7961 return "DW_TAG_constant";
7962 case DW_TAG_enumerator:
7963 return "DW_TAG_enumerator";
7964 case DW_TAG_file_type:
7965 return "DW_TAG_file_type";
7967 return "DW_TAG_friend";
7968 case DW_TAG_namelist:
7969 return "DW_TAG_namelist";
7970 case DW_TAG_namelist_item:
7971 return "DW_TAG_namelist_item";
7972 case DW_TAG_packed_type:
7973 return "DW_TAG_packed_type";
7974 case DW_TAG_subprogram:
7975 return "DW_TAG_subprogram";
7976 case DW_TAG_template_type_param:
7977 return "DW_TAG_template_type_param";
7978 case DW_TAG_template_value_param:
7979 return "DW_TAG_template_value_param";
7980 case DW_TAG_thrown_type:
7981 return "DW_TAG_thrown_type";
7982 case DW_TAG_try_block:
7983 return "DW_TAG_try_block";
7984 case DW_TAG_variant_part:
7985 return "DW_TAG_variant_part";
7986 case DW_TAG_variable:
7987 return "DW_TAG_variable";
7988 case DW_TAG_volatile_type:
7989 return "DW_TAG_volatile_type";
7990 case DW_TAG_dwarf_procedure:
7991 return "DW_TAG_dwarf_procedure";
7992 case DW_TAG_restrict_type:
7993 return "DW_TAG_restrict_type";
7994 case DW_TAG_interface_type:
7995 return "DW_TAG_interface_type";
7996 case DW_TAG_namespace:
7997 return "DW_TAG_namespace";
7998 case DW_TAG_imported_module:
7999 return "DW_TAG_imported_module";
8000 case DW_TAG_unspecified_type:
8001 return "DW_TAG_unspecified_type";
8002 case DW_TAG_partial_unit:
8003 return "DW_TAG_partial_unit";
8004 case DW_TAG_imported_unit:
8005 return "DW_TAG_imported_unit";
8006 case DW_TAG_condition:
8007 return "DW_TAG_condition";
8008 case DW_TAG_shared_type:
8009 return "DW_TAG_shared_type";
8010 case DW_TAG_MIPS_loop:
8011 return "DW_TAG_MIPS_loop";
8012 case DW_TAG_HP_array_descriptor:
8013 return "DW_TAG_HP_array_descriptor";
8014 case DW_TAG_format_label:
8015 return "DW_TAG_format_label";
8016 case DW_TAG_function_template:
8017 return "DW_TAG_function_template";
8018 case DW_TAG_class_template:
8019 return "DW_TAG_class_template";
8020 case DW_TAG_GNU_BINCL:
8021 return "DW_TAG_GNU_BINCL";
8022 case DW_TAG_GNU_EINCL:
8023 return "DW_TAG_GNU_EINCL";
8024 case DW_TAG_upc_shared_type:
8025 return "DW_TAG_upc_shared_type";
8026 case DW_TAG_upc_strict_type:
8027 return "DW_TAG_upc_strict_type";
8028 case DW_TAG_upc_relaxed_type:
8029 return "DW_TAG_upc_relaxed_type";
8030 case DW_TAG_PGI_kanji_type:
8031 return "DW_TAG_PGI_kanji_type";
8032 case DW_TAG_PGI_interface_block:
8033 return "DW_TAG_PGI_interface_block";
8035 return "DW_TAG_<unknown>";
8039 /* Convert a DWARF attribute code into its string name. */
8042 dwarf_attr_name (unsigned attr)
8047 return "DW_AT_sibling";
8048 case DW_AT_location:
8049 return "DW_AT_location";
8051 return "DW_AT_name";
8052 case DW_AT_ordering:
8053 return "DW_AT_ordering";
8054 case DW_AT_subscr_data:
8055 return "DW_AT_subscr_data";
8056 case DW_AT_byte_size:
8057 return "DW_AT_byte_size";
8058 case DW_AT_bit_offset:
8059 return "DW_AT_bit_offset";
8060 case DW_AT_bit_size:
8061 return "DW_AT_bit_size";
8062 case DW_AT_element_list:
8063 return "DW_AT_element_list";
8064 case DW_AT_stmt_list:
8065 return "DW_AT_stmt_list";
8067 return "DW_AT_low_pc";
8069 return "DW_AT_high_pc";
8070 case DW_AT_language:
8071 return "DW_AT_language";
8073 return "DW_AT_member";
8075 return "DW_AT_discr";
8076 case DW_AT_discr_value:
8077 return "DW_AT_discr_value";
8078 case DW_AT_visibility:
8079 return "DW_AT_visibility";
8081 return "DW_AT_import";
8082 case DW_AT_string_length:
8083 return "DW_AT_string_length";
8084 case DW_AT_common_reference:
8085 return "DW_AT_common_reference";
8086 case DW_AT_comp_dir:
8087 return "DW_AT_comp_dir";
8088 case DW_AT_const_value:
8089 return "DW_AT_const_value";
8090 case DW_AT_containing_type:
8091 return "DW_AT_containing_type";
8092 case DW_AT_default_value:
8093 return "DW_AT_default_value";
8095 return "DW_AT_inline";
8096 case DW_AT_is_optional:
8097 return "DW_AT_is_optional";
8098 case DW_AT_lower_bound:
8099 return "DW_AT_lower_bound";
8100 case DW_AT_producer:
8101 return "DW_AT_producer";
8102 case DW_AT_prototyped:
8103 return "DW_AT_prototyped";
8104 case DW_AT_return_addr:
8105 return "DW_AT_return_addr";
8106 case DW_AT_start_scope:
8107 return "DW_AT_start_scope";
8108 case DW_AT_stride_size:
8109 return "DW_AT_stride_size";
8110 case DW_AT_upper_bound:
8111 return "DW_AT_upper_bound";
8112 case DW_AT_abstract_origin:
8113 return "DW_AT_abstract_origin";
8114 case DW_AT_accessibility:
8115 return "DW_AT_accessibility";
8116 case DW_AT_address_class:
8117 return "DW_AT_address_class";
8118 case DW_AT_artificial:
8119 return "DW_AT_artificial";
8120 case DW_AT_base_types:
8121 return "DW_AT_base_types";
8122 case DW_AT_calling_convention:
8123 return "DW_AT_calling_convention";
8125 return "DW_AT_count";
8126 case DW_AT_data_member_location:
8127 return "DW_AT_data_member_location";
8128 case DW_AT_decl_column:
8129 return "DW_AT_decl_column";
8130 case DW_AT_decl_file:
8131 return "DW_AT_decl_file";
8132 case DW_AT_decl_line:
8133 return "DW_AT_decl_line";
8134 case DW_AT_declaration:
8135 return "DW_AT_declaration";
8136 case DW_AT_discr_list:
8137 return "DW_AT_discr_list";
8138 case DW_AT_encoding:
8139 return "DW_AT_encoding";
8140 case DW_AT_external:
8141 return "DW_AT_external";
8142 case DW_AT_frame_base:
8143 return "DW_AT_frame_base";
8145 return "DW_AT_friend";
8146 case DW_AT_identifier_case:
8147 return "DW_AT_identifier_case";
8148 case DW_AT_macro_info:
8149 return "DW_AT_macro_info";
8150 case DW_AT_namelist_items:
8151 return "DW_AT_namelist_items";
8152 case DW_AT_priority:
8153 return "DW_AT_priority";
8155 return "DW_AT_segment";
8156 case DW_AT_specification:
8157 return "DW_AT_specification";
8158 case DW_AT_static_link:
8159 return "DW_AT_static_link";
8161 return "DW_AT_type";
8162 case DW_AT_use_location:
8163 return "DW_AT_use_location";
8164 case DW_AT_variable_parameter:
8165 return "DW_AT_variable_parameter";
8166 case DW_AT_virtuality:
8167 return "DW_AT_virtuality";
8168 case DW_AT_vtable_elem_location:
8169 return "DW_AT_vtable_elem_location";
8170 /* DWARF 3 values. */
8171 case DW_AT_allocated:
8172 return "DW_AT_allocated";
8173 case DW_AT_associated:
8174 return "DW_AT_associated";
8175 case DW_AT_data_location:
8176 return "DW_AT_data_location";
8178 return "DW_AT_stride";
8179 case DW_AT_entry_pc:
8180 return "DW_AT_entry_pc";
8181 case DW_AT_use_UTF8:
8182 return "DW_AT_use_UTF8";
8183 case DW_AT_extension:
8184 return "DW_AT_extension";
8186 return "DW_AT_ranges";
8187 case DW_AT_trampoline:
8188 return "DW_AT_trampoline";
8189 case DW_AT_call_column:
8190 return "DW_AT_call_column";
8191 case DW_AT_call_file:
8192 return "DW_AT_call_file";
8193 case DW_AT_call_line:
8194 return "DW_AT_call_line";
8195 case DW_AT_description:
8196 return "DW_AT_description";
8197 case DW_AT_binary_scale:
8198 return "DW_AT_binary_scale";
8199 case DW_AT_decimal_scale:
8200 return "DW_AT_decimal_scale";
8202 return "DW_AT_small";
8203 case DW_AT_decimal_sign:
8204 return "DW_AT_decimal_sign";
8205 case DW_AT_digit_count:
8206 return "DW_AT_digit_count";
8207 case DW_AT_picture_string:
8208 return "DW_AT_picture_string";
8210 return "DW_AT_mutable";
8211 case DW_AT_threads_scaled:
8212 return "DW_AT_threads_scaled";
8213 case DW_AT_explicit:
8214 return "DW_AT_explicit";
8215 case DW_AT_object_pointer:
8216 return "DW_AT_object_pointer";
8217 case DW_AT_endianity:
8218 return "DW_AT_endianity";
8219 case DW_AT_elemental:
8220 return "DW_AT_elemental";
8222 return "DW_AT_pure";
8223 case DW_AT_recursive:
8224 return "DW_AT_recursive";
8226 /* SGI/MIPS extensions. */
8227 case DW_AT_MIPS_fde:
8228 return "DW_AT_MIPS_fde";
8229 case DW_AT_MIPS_loop_begin:
8230 return "DW_AT_MIPS_loop_begin";
8231 case DW_AT_MIPS_tail_loop_begin:
8232 return "DW_AT_MIPS_tail_loop_begin";
8233 case DW_AT_MIPS_epilog_begin:
8234 return "DW_AT_MIPS_epilog_begin";
8235 case DW_AT_MIPS_loop_unroll_factor:
8236 return "DW_AT_MIPS_loop_unroll_factor";
8237 case DW_AT_MIPS_software_pipeline_depth:
8238 return "DW_AT_MIPS_software_pipeline_depth";
8239 case DW_AT_MIPS_linkage_name:
8240 return "DW_AT_MIPS_linkage_name";
8241 case DW_AT_MIPS_stride:
8242 return "DW_AT_MIPS_stride";
8243 case DW_AT_MIPS_abstract_name:
8244 return "DW_AT_MIPS_abstract_name";
8245 case DW_AT_MIPS_clone_origin:
8246 return "DW_AT_MIPS_clone_origin";
8247 case DW_AT_MIPS_has_inlines:
8248 return "DW_AT_MIPS_has_inlines";
8250 /* HP extensions. */
8251 case DW_AT_HP_block_index:
8252 return "DW_AT_HP_block_index";
8253 case DW_AT_HP_unmodifiable:
8254 return "DW_AT_HP_unmodifiable";
8255 case DW_AT_HP_actuals_stmt_list:
8256 return "DW_AT_HP_actuals_stmt_list";
8257 case DW_AT_HP_proc_per_section:
8258 return "DW_AT_HP_proc_per_section";
8259 case DW_AT_HP_raw_data_ptr:
8260 return "DW_AT_HP_raw_data_ptr";
8261 case DW_AT_HP_pass_by_reference:
8262 return "DW_AT_HP_pass_by_reference";
8263 case DW_AT_HP_opt_level:
8264 return "DW_AT_HP_opt_level";
8265 case DW_AT_HP_prof_version_id:
8266 return "DW_AT_HP_prof_version_id";
8267 case DW_AT_HP_opt_flags:
8268 return "DW_AT_HP_opt_flags";
8269 case DW_AT_HP_cold_region_low_pc:
8270 return "DW_AT_HP_cold_region_low_pc";
8271 case DW_AT_HP_cold_region_high_pc:
8272 return "DW_AT_HP_cold_region_high_pc";
8273 case DW_AT_HP_all_variables_modifiable:
8274 return "DW_AT_HP_all_variables_modifiable";
8275 case DW_AT_HP_linkage_name:
8276 return "DW_AT_HP_linkage_name";
8277 case DW_AT_HP_prof_flags:
8278 return "DW_AT_HP_prof_flags";
8279 /* GNU extensions. */
8280 case DW_AT_sf_names:
8281 return "DW_AT_sf_names";
8282 case DW_AT_src_info:
8283 return "DW_AT_src_info";
8284 case DW_AT_mac_info:
8285 return "DW_AT_mac_info";
8286 case DW_AT_src_coords:
8287 return "DW_AT_src_coords";
8288 case DW_AT_body_begin:
8289 return "DW_AT_body_begin";
8290 case DW_AT_body_end:
8291 return "DW_AT_body_end";
8292 case DW_AT_GNU_vector:
8293 return "DW_AT_GNU_vector";
8294 /* VMS extensions. */
8295 case DW_AT_VMS_rtnbeg_pd_address:
8296 return "DW_AT_VMS_rtnbeg_pd_address";
8297 /* UPC extension. */
8298 case DW_AT_upc_threads_scaled:
8299 return "DW_AT_upc_threads_scaled";
8300 /* PGI (STMicroelectronics) extensions. */
8301 case DW_AT_PGI_lbase:
8302 return "DW_AT_PGI_lbase";
8303 case DW_AT_PGI_soffset:
8304 return "DW_AT_PGI_soffset";
8305 case DW_AT_PGI_lstride:
8306 return "DW_AT_PGI_lstride";
8308 return "DW_AT_<unknown>";
8312 /* Convert a DWARF value form code into its string name. */
8315 dwarf_form_name (unsigned form)
8320 return "DW_FORM_addr";
8321 case DW_FORM_block2:
8322 return "DW_FORM_block2";
8323 case DW_FORM_block4:
8324 return "DW_FORM_block4";
8326 return "DW_FORM_data2";
8328 return "DW_FORM_data4";
8330 return "DW_FORM_data8";
8331 case DW_FORM_string:
8332 return "DW_FORM_string";
8334 return "DW_FORM_block";
8335 case DW_FORM_block1:
8336 return "DW_FORM_block1";
8338 return "DW_FORM_data1";
8340 return "DW_FORM_flag";
8342 return "DW_FORM_sdata";
8344 return "DW_FORM_strp";
8346 return "DW_FORM_udata";
8347 case DW_FORM_ref_addr:
8348 return "DW_FORM_ref_addr";
8350 return "DW_FORM_ref1";
8352 return "DW_FORM_ref2";
8354 return "DW_FORM_ref4";
8356 return "DW_FORM_ref8";
8357 case DW_FORM_ref_udata:
8358 return "DW_FORM_ref_udata";
8359 case DW_FORM_indirect:
8360 return "DW_FORM_indirect";
8362 return "DW_FORM_<unknown>";
8366 /* Convert a DWARF stack opcode into its string name. */
8369 dwarf_stack_op_name (unsigned op)
8374 return "DW_OP_addr";
8376 return "DW_OP_deref";
8378 return "DW_OP_const1u";
8380 return "DW_OP_const1s";
8382 return "DW_OP_const2u";
8384 return "DW_OP_const2s";
8386 return "DW_OP_const4u";
8388 return "DW_OP_const4s";
8390 return "DW_OP_const8u";
8392 return "DW_OP_const8s";
8394 return "DW_OP_constu";
8396 return "DW_OP_consts";
8400 return "DW_OP_drop";
8402 return "DW_OP_over";
8404 return "DW_OP_pick";
8406 return "DW_OP_swap";
8410 return "DW_OP_xderef";
8418 return "DW_OP_minus";
8430 return "DW_OP_plus";
8431 case DW_OP_plus_uconst:
8432 return "DW_OP_plus_uconst";
8438 return "DW_OP_shra";
8456 return "DW_OP_skip";
8458 return "DW_OP_lit0";
8460 return "DW_OP_lit1";
8462 return "DW_OP_lit2";
8464 return "DW_OP_lit3";
8466 return "DW_OP_lit4";
8468 return "DW_OP_lit5";
8470 return "DW_OP_lit6";
8472 return "DW_OP_lit7";
8474 return "DW_OP_lit8";
8476 return "DW_OP_lit9";
8478 return "DW_OP_lit10";
8480 return "DW_OP_lit11";
8482 return "DW_OP_lit12";
8484 return "DW_OP_lit13";
8486 return "DW_OP_lit14";
8488 return "DW_OP_lit15";
8490 return "DW_OP_lit16";
8492 return "DW_OP_lit17";
8494 return "DW_OP_lit18";
8496 return "DW_OP_lit19";
8498 return "DW_OP_lit20";
8500 return "DW_OP_lit21";
8502 return "DW_OP_lit22";
8504 return "DW_OP_lit23";
8506 return "DW_OP_lit24";
8508 return "DW_OP_lit25";
8510 return "DW_OP_lit26";
8512 return "DW_OP_lit27";
8514 return "DW_OP_lit28";
8516 return "DW_OP_lit29";
8518 return "DW_OP_lit30";
8520 return "DW_OP_lit31";
8522 return "DW_OP_reg0";
8524 return "DW_OP_reg1";
8526 return "DW_OP_reg2";
8528 return "DW_OP_reg3";
8530 return "DW_OP_reg4";
8532 return "DW_OP_reg5";
8534 return "DW_OP_reg6";
8536 return "DW_OP_reg7";
8538 return "DW_OP_reg8";
8540 return "DW_OP_reg9";
8542 return "DW_OP_reg10";
8544 return "DW_OP_reg11";
8546 return "DW_OP_reg12";
8548 return "DW_OP_reg13";
8550 return "DW_OP_reg14";
8552 return "DW_OP_reg15";
8554 return "DW_OP_reg16";
8556 return "DW_OP_reg17";
8558 return "DW_OP_reg18";
8560 return "DW_OP_reg19";
8562 return "DW_OP_reg20";
8564 return "DW_OP_reg21";
8566 return "DW_OP_reg22";
8568 return "DW_OP_reg23";
8570 return "DW_OP_reg24";
8572 return "DW_OP_reg25";
8574 return "DW_OP_reg26";
8576 return "DW_OP_reg27";
8578 return "DW_OP_reg28";
8580 return "DW_OP_reg29";
8582 return "DW_OP_reg30";
8584 return "DW_OP_reg31";
8586 return "DW_OP_breg0";
8588 return "DW_OP_breg1";
8590 return "DW_OP_breg2";
8592 return "DW_OP_breg3";
8594 return "DW_OP_breg4";
8596 return "DW_OP_breg5";
8598 return "DW_OP_breg6";
8600 return "DW_OP_breg7";
8602 return "DW_OP_breg8";
8604 return "DW_OP_breg9";
8606 return "DW_OP_breg10";
8608 return "DW_OP_breg11";
8610 return "DW_OP_breg12";
8612 return "DW_OP_breg13";
8614 return "DW_OP_breg14";
8616 return "DW_OP_breg15";
8618 return "DW_OP_breg16";
8620 return "DW_OP_breg17";
8622 return "DW_OP_breg18";
8624 return "DW_OP_breg19";
8626 return "DW_OP_breg20";
8628 return "DW_OP_breg21";
8630 return "DW_OP_breg22";
8632 return "DW_OP_breg23";
8634 return "DW_OP_breg24";
8636 return "DW_OP_breg25";
8638 return "DW_OP_breg26";
8640 return "DW_OP_breg27";
8642 return "DW_OP_breg28";
8644 return "DW_OP_breg29";
8646 return "DW_OP_breg30";
8648 return "DW_OP_breg31";
8650 return "DW_OP_regx";
8652 return "DW_OP_fbreg";
8654 return "DW_OP_bregx";
8656 return "DW_OP_piece";
8657 case DW_OP_deref_size:
8658 return "DW_OP_deref_size";
8659 case DW_OP_xderef_size:
8660 return "DW_OP_xderef_size";
8663 /* DWARF 3 extensions. */
8664 case DW_OP_push_object_address:
8665 return "DW_OP_push_object_address";
8667 return "DW_OP_call2";
8669 return "DW_OP_call4";
8670 case DW_OP_call_ref:
8671 return "DW_OP_call_ref";
8672 /* GNU extensions. */
8673 case DW_OP_form_tls_address:
8674 return "DW_OP_form_tls_address";
8675 case DW_OP_call_frame_cfa:
8676 return "DW_OP_call_frame_cfa";
8677 case DW_OP_bit_piece:
8678 return "DW_OP_bit_piece";
8679 case DW_OP_GNU_push_tls_address:
8680 return "DW_OP_GNU_push_tls_address";
8681 case DW_OP_GNU_uninit:
8682 return "DW_OP_GNU_uninit";
8683 /* HP extensions. */
8684 case DW_OP_HP_is_value:
8685 return "DW_OP_HP_is_value";
8686 case DW_OP_HP_fltconst4:
8687 return "DW_OP_HP_fltconst4";
8688 case DW_OP_HP_fltconst8:
8689 return "DW_OP_HP_fltconst8";
8690 case DW_OP_HP_mod_range:
8691 return "DW_OP_HP_mod_range";
8692 case DW_OP_HP_unmod_range:
8693 return "DW_OP_HP_unmod_range";
8695 return "DW_OP_HP_tls";
8697 return "OP_<unknown>";
8702 dwarf_bool_name (unsigned mybool)
8710 /* Convert a DWARF type code into its string name. */
8713 dwarf_type_encoding_name (unsigned enc)
8718 return "DW_ATE_void";
8719 case DW_ATE_address:
8720 return "DW_ATE_address";
8721 case DW_ATE_boolean:
8722 return "DW_ATE_boolean";
8723 case DW_ATE_complex_float:
8724 return "DW_ATE_complex_float";
8726 return "DW_ATE_float";
8728 return "DW_ATE_signed";
8729 case DW_ATE_signed_char:
8730 return "DW_ATE_signed_char";
8731 case DW_ATE_unsigned:
8732 return "DW_ATE_unsigned";
8733 case DW_ATE_unsigned_char:
8734 return "DW_ATE_unsigned_char";
8736 case DW_ATE_imaginary_float:
8737 return "DW_ATE_imaginary_float";
8738 case DW_ATE_packed_decimal:
8739 return "DW_ATE_packed_decimal";
8740 case DW_ATE_numeric_string:
8741 return "DW_ATE_numeric_string";
8743 return "DW_ATE_edited";
8744 case DW_ATE_signed_fixed:
8745 return "DW_ATE_signed_fixed";
8746 case DW_ATE_unsigned_fixed:
8747 return "DW_ATE_unsigned_fixed";
8748 case DW_ATE_decimal_float:
8749 return "DW_ATE_decimal_float";
8750 /* HP extensions. */
8751 case DW_ATE_HP_float80:
8752 return "DW_ATE_HP_float80";
8753 case DW_ATE_HP_complex_float80:
8754 return "DW_ATE_HP_complex_float80";
8755 case DW_ATE_HP_float128:
8756 return "DW_ATE_HP_float128";
8757 case DW_ATE_HP_complex_float128:
8758 return "DW_ATE_HP_complex_float128";
8759 case DW_ATE_HP_floathpintel:
8760 return "DW_ATE_HP_floathpintel";
8761 case DW_ATE_HP_imaginary_float80:
8762 return "DW_ATE_HP_imaginary_float80";
8763 case DW_ATE_HP_imaginary_float128:
8764 return "DW_ATE_HP_imaginary_float128";
8766 return "DW_ATE_<unknown>";
8770 /* Convert a DWARF call frame info operation to its string name. */
8774 dwarf_cfi_name (unsigned cfi_opc)
8778 case DW_CFA_advance_loc:
8779 return "DW_CFA_advance_loc";
8781 return "DW_CFA_offset";
8782 case DW_CFA_restore:
8783 return "DW_CFA_restore";
8785 return "DW_CFA_nop";
8786 case DW_CFA_set_loc:
8787 return "DW_CFA_set_loc";
8788 case DW_CFA_advance_loc1:
8789 return "DW_CFA_advance_loc1";
8790 case DW_CFA_advance_loc2:
8791 return "DW_CFA_advance_loc2";
8792 case DW_CFA_advance_loc4:
8793 return "DW_CFA_advance_loc4";
8794 case DW_CFA_offset_extended:
8795 return "DW_CFA_offset_extended";
8796 case DW_CFA_restore_extended:
8797 return "DW_CFA_restore_extended";
8798 case DW_CFA_undefined:
8799 return "DW_CFA_undefined";
8800 case DW_CFA_same_value:
8801 return "DW_CFA_same_value";
8802 case DW_CFA_register:
8803 return "DW_CFA_register";
8804 case DW_CFA_remember_state:
8805 return "DW_CFA_remember_state";
8806 case DW_CFA_restore_state:
8807 return "DW_CFA_restore_state";
8808 case DW_CFA_def_cfa:
8809 return "DW_CFA_def_cfa";
8810 case DW_CFA_def_cfa_register:
8811 return "DW_CFA_def_cfa_register";
8812 case DW_CFA_def_cfa_offset:
8813 return "DW_CFA_def_cfa_offset";
8815 case DW_CFA_def_cfa_expression:
8816 return "DW_CFA_def_cfa_expression";
8817 case DW_CFA_expression:
8818 return "DW_CFA_expression";
8819 case DW_CFA_offset_extended_sf:
8820 return "DW_CFA_offset_extended_sf";
8821 case DW_CFA_def_cfa_sf:
8822 return "DW_CFA_def_cfa_sf";
8823 case DW_CFA_def_cfa_offset_sf:
8824 return "DW_CFA_def_cfa_offset_sf";
8825 case DW_CFA_val_offset:
8826 return "DW_CFA_val_offset";
8827 case DW_CFA_val_offset_sf:
8828 return "DW_CFA_val_offset_sf";
8829 case DW_CFA_val_expression:
8830 return "DW_CFA_val_expression";
8831 /* SGI/MIPS specific. */
8832 case DW_CFA_MIPS_advance_loc8:
8833 return "DW_CFA_MIPS_advance_loc8";
8834 /* GNU extensions. */
8835 case DW_CFA_GNU_window_save:
8836 return "DW_CFA_GNU_window_save";
8837 case DW_CFA_GNU_args_size:
8838 return "DW_CFA_GNU_args_size";
8839 case DW_CFA_GNU_negative_offset_extended:
8840 return "DW_CFA_GNU_negative_offset_extended";
8842 return "DW_CFA_<unknown>";
8848 dump_die (struct die_info *die)
8852 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8853 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8854 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8855 dwarf_bool_name (die->child != NULL));
8857 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8858 for (i = 0; i < die->num_attrs; ++i)
8860 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8861 dwarf_attr_name (die->attrs[i].name),
8862 dwarf_form_name (die->attrs[i].form));
8863 switch (die->attrs[i].form)
8865 case DW_FORM_ref_addr:
8867 fprintf_unfiltered (gdb_stderr, "address: ");
8868 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8870 case DW_FORM_block2:
8871 case DW_FORM_block4:
8873 case DW_FORM_block1:
8874 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8879 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8880 (long) (DW_ADDR (&die->attrs[i])));
8888 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8890 case DW_FORM_string:
8892 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8893 DW_STRING (&die->attrs[i])
8894 ? DW_STRING (&die->attrs[i]) : "");
8897 if (DW_UNSND (&die->attrs[i]))
8898 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8900 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8902 case DW_FORM_indirect:
8903 /* the reader will have reduced the indirect form to
8904 the "base form" so this form should not occur */
8905 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8908 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8909 die->attrs[i].form);
8911 fprintf_unfiltered (gdb_stderr, "\n");
8916 dump_die_list (struct die_info *die)
8921 if (die->child != NULL)
8922 dump_die_list (die->child);
8923 if (die->sibling != NULL)
8924 dump_die_list (die->sibling);
8929 store_in_ref_table (unsigned int offset, struct die_info *die,
8930 struct dwarf2_cu *cu)
8933 struct die_info *old;
8935 h = (offset % REF_HASH_SIZE);
8936 old = cu->die_ref_table[h];
8937 die->next_ref = old;
8938 cu->die_ref_table[h] = die;
8942 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8944 unsigned int result = 0;
8948 case DW_FORM_ref_addr:
8953 case DW_FORM_ref_udata:
8954 result = DW_ADDR (attr);
8957 complaint (&symfile_complaints,
8958 _("unsupported die ref attribute form: '%s'"),
8959 dwarf_form_name (attr->form));
8964 /* Return the constant value held by the given attribute. Return -1
8965 if the value held by the attribute is not constant. */
8968 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8970 if (attr->form == DW_FORM_sdata)
8971 return DW_SND (attr);
8972 else if (attr->form == DW_FORM_udata
8973 || attr->form == DW_FORM_data1
8974 || attr->form == DW_FORM_data2
8975 || attr->form == DW_FORM_data4
8976 || attr->form == DW_FORM_data8)
8977 return DW_UNSND (attr);
8980 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8981 dwarf_form_name (attr->form));
8982 return default_value;
8986 static struct die_info *
8987 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8988 struct dwarf2_cu *cu)
8990 struct die_info *die;
8991 unsigned int offset;
8993 struct die_info temp_die;
8994 struct dwarf2_cu *target_cu;
8996 offset = dwarf2_get_ref_die_offset (attr, cu);
8998 if (DW_ADDR (attr) < cu->header.offset
8999 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
9001 struct dwarf2_per_cu_data *per_cu;
9002 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
9004 target_cu = per_cu->cu;
9009 h = (offset % REF_HASH_SIZE);
9010 die = target_cu->die_ref_table[h];
9013 if (die->offset == offset)
9015 die = die->next_ref;
9018 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9019 "at 0x%lx [in module %s]"),
9020 (long) src_die->offset, (long) offset, cu->objfile->name);
9025 static struct type *
9026 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
9027 struct dwarf2_cu *cu)
9029 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
9031 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
9032 typeid, objfile->name);
9035 /* Look for this particular type in the fundamental type vector. If
9036 one is not found, create and install one appropriate for the
9037 current language and the current target machine. */
9039 if (cu->ftypes[typeid] == NULL)
9041 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
9044 return (cu->ftypes[typeid]);
9047 /* Decode simple location descriptions.
9048 Given a pointer to a dwarf block that defines a location, compute
9049 the location and return the value.
9051 NOTE drow/2003-11-18: This function is called in two situations
9052 now: for the address of static or global variables (partial symbols
9053 only) and for offsets into structures which are expected to be
9054 (more or less) constant. The partial symbol case should go away,
9055 and only the constant case should remain. That will let this
9056 function complain more accurately. A few special modes are allowed
9057 without complaint for global variables (for instance, global
9058 register values and thread-local values).
9060 A location description containing no operations indicates that the
9061 object is optimized out. The return value is 0 for that case.
9062 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9063 callers will only want a very basic result and this can become a
9066 Note that stack[0] is unused except as a default error return.
9067 Note that stack overflow is not yet handled. */
9070 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
9072 struct objfile *objfile = cu->objfile;
9073 struct comp_unit_head *cu_header = &cu->header;
9075 int size = blk->size;
9076 gdb_byte *data = blk->data;
9077 CORE_ADDR stack[64];
9079 unsigned int bytes_read, unsnd;
9123 stack[++stacki] = op - DW_OP_lit0;
9158 stack[++stacki] = op - DW_OP_reg0;
9160 dwarf2_complex_location_expr_complaint ();
9164 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
9166 stack[++stacki] = unsnd;
9168 dwarf2_complex_location_expr_complaint ();
9172 stack[++stacki] = read_address (objfile->obfd, &data[i],
9178 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
9183 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
9188 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
9193 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
9198 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
9203 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
9208 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
9214 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
9219 stack[stacki + 1] = stack[stacki];
9224 stack[stacki - 1] += stack[stacki];
9228 case DW_OP_plus_uconst:
9229 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
9234 stack[stacki - 1] -= stack[stacki];
9239 /* If we're not the last op, then we definitely can't encode
9240 this using GDB's address_class enum. This is valid for partial
9241 global symbols, although the variable's address will be bogus
9244 dwarf2_complex_location_expr_complaint ();
9247 case DW_OP_GNU_push_tls_address:
9248 /* The top of the stack has the offset from the beginning
9249 of the thread control block at which the variable is located. */
9250 /* Nothing should follow this operator, so the top of stack would
9252 /* This is valid for partial global symbols, but the variable's
9253 address will be bogus in the psymtab. */
9255 dwarf2_complex_location_expr_complaint ();
9258 case DW_OP_GNU_uninit:
9262 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
9263 dwarf_stack_op_name (op));
9264 return (stack[stacki]);
9267 return (stack[stacki]);
9270 /* memory allocation interface */
9272 static struct dwarf_block *
9273 dwarf_alloc_block (struct dwarf2_cu *cu)
9275 struct dwarf_block *blk;
9277 blk = (struct dwarf_block *)
9278 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
9282 static struct abbrev_info *
9283 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
9285 struct abbrev_info *abbrev;
9287 abbrev = (struct abbrev_info *)
9288 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
9289 memset (abbrev, 0, sizeof (struct abbrev_info));
9293 static struct die_info *
9294 dwarf_alloc_die (void)
9296 struct die_info *die;
9298 die = (struct die_info *) xmalloc (sizeof (struct die_info));
9299 memset (die, 0, sizeof (struct die_info));
9304 /* Macro support. */
9307 /* Return the full name of file number I in *LH's file name table.
9308 Use COMP_DIR as the name of the current directory of the
9309 compilation. The result is allocated using xmalloc; the caller is
9310 responsible for freeing it. */
9312 file_full_name (int file, struct line_header *lh, const char *comp_dir)
9314 /* Is the file number a valid index into the line header's file name
9315 table? Remember that file numbers start with one, not zero. */
9316 if (1 <= file && file <= lh->num_file_names)
9318 struct file_entry *fe = &lh->file_names[file - 1];
9320 if (IS_ABSOLUTE_PATH (fe->name))
9321 return xstrdup (fe->name);
9329 dir = lh->include_dirs[fe->dir_index - 1];
9335 dir_len = strlen (dir);
9336 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
9337 strcpy (full_name, dir);
9338 full_name[dir_len] = '/';
9339 strcpy (full_name + dir_len + 1, fe->name);
9343 return xstrdup (fe->name);
9348 /* The compiler produced a bogus file number. We can at least
9349 record the macro definitions made in the file, even if we
9350 won't be able to find the file by name. */
9352 sprintf (fake_name, "<bad macro file number %d>", file);
9354 complaint (&symfile_complaints,
9355 _("bad file number in macro information (%d)"),
9358 return xstrdup (fake_name);
9363 static struct macro_source_file *
9364 macro_start_file (int file, int line,
9365 struct macro_source_file *current_file,
9366 const char *comp_dir,
9367 struct line_header *lh, struct objfile *objfile)
9369 /* The full name of this source file. */
9370 char *full_name = file_full_name (file, lh, comp_dir);
9372 /* We don't create a macro table for this compilation unit
9373 at all until we actually get a filename. */
9374 if (! pending_macros)
9375 pending_macros = new_macro_table (&objfile->objfile_obstack,
9376 objfile->macro_cache);
9379 /* If we have no current file, then this must be the start_file
9380 directive for the compilation unit's main source file. */
9381 current_file = macro_set_main (pending_macros, full_name);
9383 current_file = macro_include (current_file, line, full_name);
9387 return current_file;
9391 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9392 followed by a null byte. */
9394 copy_string (const char *buf, int len)
9396 char *s = xmalloc (len + 1);
9397 memcpy (s, buf, len);
9405 consume_improper_spaces (const char *p, const char *body)
9409 complaint (&symfile_complaints,
9410 _("macro definition contains spaces in formal argument list:\n`%s'"),
9422 parse_macro_definition (struct macro_source_file *file, int line,
9427 /* The body string takes one of two forms. For object-like macro
9428 definitions, it should be:
9430 <macro name> " " <definition>
9432 For function-like macro definitions, it should be:
9434 <macro name> "() " <definition>
9436 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9438 Spaces may appear only where explicitly indicated, and in the
9441 The Dwarf 2 spec says that an object-like macro's name is always
9442 followed by a space, but versions of GCC around March 2002 omit
9443 the space when the macro's definition is the empty string.
9445 The Dwarf 2 spec says that there should be no spaces between the
9446 formal arguments in a function-like macro's formal argument list,
9447 but versions of GCC around March 2002 include spaces after the
9451 /* Find the extent of the macro name. The macro name is terminated
9452 by either a space or null character (for an object-like macro) or
9453 an opening paren (for a function-like macro). */
9454 for (p = body; *p; p++)
9455 if (*p == ' ' || *p == '(')
9458 if (*p == ' ' || *p == '\0')
9460 /* It's an object-like macro. */
9461 int name_len = p - body;
9462 char *name = copy_string (body, name_len);
9463 const char *replacement;
9466 replacement = body + name_len + 1;
9469 dwarf2_macro_malformed_definition_complaint (body);
9470 replacement = body + name_len;
9473 macro_define_object (file, line, name, replacement);
9479 /* It's a function-like macro. */
9480 char *name = copy_string (body, p - body);
9483 char **argv = xmalloc (argv_size * sizeof (*argv));
9487 p = consume_improper_spaces (p, body);
9489 /* Parse the formal argument list. */
9490 while (*p && *p != ')')
9492 /* Find the extent of the current argument name. */
9493 const char *arg_start = p;
9495 while (*p && *p != ',' && *p != ')' && *p != ' ')
9498 if (! *p || p == arg_start)
9499 dwarf2_macro_malformed_definition_complaint (body);
9502 /* Make sure argv has room for the new argument. */
9503 if (argc >= argv_size)
9506 argv = xrealloc (argv, argv_size * sizeof (*argv));
9509 argv[argc++] = copy_string (arg_start, p - arg_start);
9512 p = consume_improper_spaces (p, body);
9514 /* Consume the comma, if present. */
9519 p = consume_improper_spaces (p, body);
9528 /* Perfectly formed definition, no complaints. */
9529 macro_define_function (file, line, name,
9530 argc, (const char **) argv,
9532 else if (*p == '\0')
9534 /* Complain, but do define it. */
9535 dwarf2_macro_malformed_definition_complaint (body);
9536 macro_define_function (file, line, name,
9537 argc, (const char **) argv,
9541 /* Just complain. */
9542 dwarf2_macro_malformed_definition_complaint (body);
9545 /* Just complain. */
9546 dwarf2_macro_malformed_definition_complaint (body);
9552 for (i = 0; i < argc; i++)
9558 dwarf2_macro_malformed_definition_complaint (body);
9563 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9564 char *comp_dir, bfd *abfd,
9565 struct dwarf2_cu *cu)
9567 gdb_byte *mac_ptr, *mac_end;
9568 struct macro_source_file *current_file = 0;
9570 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9572 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9576 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9577 mac_end = dwarf2_per_objfile->macinfo_buffer
9578 + dwarf2_per_objfile->macinfo_size;
9582 enum dwarf_macinfo_record_type macinfo_type;
9584 /* Do we at least have room for a macinfo type byte? */
9585 if (mac_ptr >= mac_end)
9587 dwarf2_macros_too_long_complaint ();
9591 macinfo_type = read_1_byte (abfd, mac_ptr);
9594 switch (macinfo_type)
9596 /* A zero macinfo type indicates the end of the macro
9601 case DW_MACINFO_define:
9602 case DW_MACINFO_undef:
9604 unsigned int bytes_read;
9608 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9609 mac_ptr += bytes_read;
9610 body = read_string (abfd, mac_ptr, &bytes_read);
9611 mac_ptr += bytes_read;
9614 complaint (&symfile_complaints,
9615 _("debug info gives macro %s outside of any file: %s"),
9617 DW_MACINFO_define ? "definition" : macinfo_type ==
9618 DW_MACINFO_undef ? "undefinition" :
9619 "something-or-other", body);
9622 if (macinfo_type == DW_MACINFO_define)
9623 parse_macro_definition (current_file, line, body);
9624 else if (macinfo_type == DW_MACINFO_undef)
9625 macro_undef (current_file, line, body);
9630 case DW_MACINFO_start_file:
9632 unsigned int bytes_read;
9635 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9636 mac_ptr += bytes_read;
9637 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9638 mac_ptr += bytes_read;
9640 current_file = macro_start_file (file, line,
9641 current_file, comp_dir,
9646 case DW_MACINFO_end_file:
9648 complaint (&symfile_complaints,
9649 _("macro debug info has an unmatched `close_file' directive"));
9652 current_file = current_file->included_by;
9655 enum dwarf_macinfo_record_type next_type;
9657 /* GCC circa March 2002 doesn't produce the zero
9658 type byte marking the end of the compilation
9659 unit. Complain if it's not there, but exit no
9662 /* Do we at least have room for a macinfo type byte? */
9663 if (mac_ptr >= mac_end)
9665 dwarf2_macros_too_long_complaint ();
9669 /* We don't increment mac_ptr here, so this is just
9671 next_type = read_1_byte (abfd, mac_ptr);
9673 complaint (&symfile_complaints,
9674 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9681 case DW_MACINFO_vendor_ext:
9683 unsigned int bytes_read;
9687 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9688 mac_ptr += bytes_read;
9689 string = read_string (abfd, mac_ptr, &bytes_read);
9690 mac_ptr += bytes_read;
9692 /* We don't recognize any vendor extensions. */
9699 /* Check if the attribute's form is a DW_FORM_block*
9700 if so return true else false. */
9702 attr_form_is_block (struct attribute *attr)
9704 return (attr == NULL ? 0 :
9705 attr->form == DW_FORM_block1
9706 || attr->form == DW_FORM_block2
9707 || attr->form == DW_FORM_block4
9708 || attr->form == DW_FORM_block);
9712 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9713 struct dwarf2_cu *cu)
9715 struct objfile *objfile = cu->objfile;
9717 /* Save the master objfile, so that we can report and look up the
9718 correct file containing this variable. */
9719 if (objfile->separate_debug_objfile_backlink)
9720 objfile = objfile->separate_debug_objfile_backlink;
9722 if ((attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9723 /* ".debug_loc" may not exist at all, or the offset may be outside
9724 the section. If so, fall through to the complaint in the
9726 && DW_UNSND (attr) < dwarf2_per_objfile->loc_size)
9728 struct dwarf2_loclist_baton *baton;
9730 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9731 sizeof (struct dwarf2_loclist_baton));
9732 baton->objfile = objfile;
9734 /* We don't know how long the location list is, but make sure we
9735 don't run off the edge of the section. */
9736 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9737 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9738 baton->base_address = cu->header.base_address;
9739 if (cu->header.base_known == 0)
9740 complaint (&symfile_complaints,
9741 _("Location list used without specifying the CU base address."));
9743 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9744 SYMBOL_LOCATION_BATON (sym) = baton;
9748 struct dwarf2_locexpr_baton *baton;
9750 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9751 sizeof (struct dwarf2_locexpr_baton));
9752 baton->objfile = objfile;
9754 if (attr_form_is_block (attr))
9756 /* Note that we're just copying the block's data pointer
9757 here, not the actual data. We're still pointing into the
9758 info_buffer for SYM's objfile; right now we never release
9759 that buffer, but when we do clean up properly this may
9761 baton->size = DW_BLOCK (attr)->size;
9762 baton->data = DW_BLOCK (attr)->data;
9766 dwarf2_invalid_attrib_class_complaint ("location description",
9767 SYMBOL_NATURAL_NAME (sym));
9772 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9773 SYMBOL_LOCATION_BATON (sym) = baton;
9777 /* Locate the compilation unit from CU's objfile which contains the
9778 DIE at OFFSET. Raises an error on failure. */
9780 static struct dwarf2_per_cu_data *
9781 dwarf2_find_containing_comp_unit (unsigned long offset,
9782 struct objfile *objfile)
9784 struct dwarf2_per_cu_data *this_cu;
9788 high = dwarf2_per_objfile->n_comp_units - 1;
9791 int mid = low + (high - low) / 2;
9792 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9797 gdb_assert (low == high);
9798 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9801 error (_("Dwarf Error: could not find partial DIE containing "
9802 "offset 0x%lx [in module %s]"),
9803 (long) offset, bfd_get_filename (objfile->obfd));
9805 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9806 return dwarf2_per_objfile->all_comp_units[low-1];
9810 this_cu = dwarf2_per_objfile->all_comp_units[low];
9811 if (low == dwarf2_per_objfile->n_comp_units - 1
9812 && offset >= this_cu->offset + this_cu->length)
9813 error (_("invalid dwarf2 offset %ld"), offset);
9814 gdb_assert (offset < this_cu->offset + this_cu->length);
9819 /* Locate the compilation unit from OBJFILE which is located at exactly
9820 OFFSET. Raises an error on failure. */
9822 static struct dwarf2_per_cu_data *
9823 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9825 struct dwarf2_per_cu_data *this_cu;
9826 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9827 if (this_cu->offset != offset)
9828 error (_("no compilation unit with offset %ld."), offset);
9832 /* Release one cached compilation unit, CU. We unlink it from the tree
9833 of compilation units, but we don't remove it from the read_in_chain;
9834 the caller is responsible for that. */
9837 free_one_comp_unit (void *data)
9839 struct dwarf2_cu *cu = data;
9841 if (cu->per_cu != NULL)
9842 cu->per_cu->cu = NULL;
9845 obstack_free (&cu->comp_unit_obstack, NULL);
9847 free_die_list (cu->dies);
9852 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9853 when we're finished with it. We can't free the pointer itself, but be
9854 sure to unlink it from the cache. Also release any associated storage
9855 and perform cache maintenance.
9857 Only used during partial symbol parsing. */
9860 free_stack_comp_unit (void *data)
9862 struct dwarf2_cu *cu = data;
9864 obstack_free (&cu->comp_unit_obstack, NULL);
9865 cu->partial_dies = NULL;
9867 if (cu->per_cu != NULL)
9869 /* This compilation unit is on the stack in our caller, so we
9870 should not xfree it. Just unlink it. */
9871 cu->per_cu->cu = NULL;
9874 /* If we had a per-cu pointer, then we may have other compilation
9875 units loaded, so age them now. */
9876 age_cached_comp_units ();
9880 /* Free all cached compilation units. */
9883 free_cached_comp_units (void *data)
9885 struct dwarf2_per_cu_data *per_cu, **last_chain;
9887 per_cu = dwarf2_per_objfile->read_in_chain;
9888 last_chain = &dwarf2_per_objfile->read_in_chain;
9889 while (per_cu != NULL)
9891 struct dwarf2_per_cu_data *next_cu;
9893 next_cu = per_cu->cu->read_in_chain;
9895 free_one_comp_unit (per_cu->cu);
9896 *last_chain = next_cu;
9902 /* Increase the age counter on each cached compilation unit, and free
9903 any that are too old. */
9906 age_cached_comp_units (void)
9908 struct dwarf2_per_cu_data *per_cu, **last_chain;
9910 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9911 per_cu = dwarf2_per_objfile->read_in_chain;
9912 while (per_cu != NULL)
9914 per_cu->cu->last_used ++;
9915 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9916 dwarf2_mark (per_cu->cu);
9917 per_cu = per_cu->cu->read_in_chain;
9920 per_cu = dwarf2_per_objfile->read_in_chain;
9921 last_chain = &dwarf2_per_objfile->read_in_chain;
9922 while (per_cu != NULL)
9924 struct dwarf2_per_cu_data *next_cu;
9926 next_cu = per_cu->cu->read_in_chain;
9928 if (!per_cu->cu->mark)
9930 free_one_comp_unit (per_cu->cu);
9931 *last_chain = next_cu;
9934 last_chain = &per_cu->cu->read_in_chain;
9940 /* Remove a single compilation unit from the cache. */
9943 free_one_cached_comp_unit (void *target_cu)
9945 struct dwarf2_per_cu_data *per_cu, **last_chain;
9947 per_cu = dwarf2_per_objfile->read_in_chain;
9948 last_chain = &dwarf2_per_objfile->read_in_chain;
9949 while (per_cu != NULL)
9951 struct dwarf2_per_cu_data *next_cu;
9953 next_cu = per_cu->cu->read_in_chain;
9955 if (per_cu->cu == target_cu)
9957 free_one_comp_unit (per_cu->cu);
9958 *last_chain = next_cu;
9962 last_chain = &per_cu->cu->read_in_chain;
9968 /* A pair of DIE offset and GDB type pointer. We store these
9969 in a hash table separate from the DIEs, and preserve them
9970 when the DIEs are flushed out of cache. */
9972 struct dwarf2_offset_and_type
9974 unsigned int offset;
9978 /* Hash function for a dwarf2_offset_and_type. */
9981 offset_and_type_hash (const void *item)
9983 const struct dwarf2_offset_and_type *ofs = item;
9987 /* Equality function for a dwarf2_offset_and_type. */
9990 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9992 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9993 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9994 return ofs_lhs->offset == ofs_rhs->offset;
9997 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9998 table if necessary. */
10001 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
10003 struct dwarf2_offset_and_type **slot, ofs;
10007 if (cu->per_cu == NULL)
10010 if (cu->per_cu->type_hash == NULL)
10011 cu->per_cu->type_hash
10012 = htab_create_alloc_ex (cu->header.length / 24,
10013 offset_and_type_hash,
10014 offset_and_type_eq,
10016 &cu->objfile->objfile_obstack,
10017 hashtab_obstack_allocate,
10018 dummy_obstack_deallocate);
10020 ofs.offset = die->offset;
10022 slot = (struct dwarf2_offset_and_type **)
10023 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
10024 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
10028 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
10029 have a saved type. */
10031 static struct type *
10032 get_die_type (struct die_info *die, htab_t type_hash)
10034 struct dwarf2_offset_and_type *slot, ofs;
10036 ofs.offset = die->offset;
10037 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
10044 /* Restore the types of the DIE tree starting at START_DIE from the hash
10045 table saved in CU. */
10048 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
10050 struct die_info *die;
10052 if (cu->per_cu->type_hash == NULL)
10055 for (die = start_die; die != NULL; die = die->sibling)
10057 die->type = get_die_type (die, cu->per_cu->type_hash);
10058 if (die->child != NULL)
10059 reset_die_and_siblings_types (die->child, cu);
10063 /* Set the mark field in CU and in every other compilation unit in the
10064 cache that we must keep because we are keeping CU. */
10066 /* Add a dependence relationship from CU to REF_PER_CU. */
10069 dwarf2_add_dependence (struct dwarf2_cu *cu,
10070 struct dwarf2_per_cu_data *ref_per_cu)
10074 if (cu->dependencies == NULL)
10076 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
10077 NULL, &cu->comp_unit_obstack,
10078 hashtab_obstack_allocate,
10079 dummy_obstack_deallocate);
10081 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
10083 *slot = ref_per_cu;
10086 /* Set the mark field in CU and in every other compilation unit in the
10087 cache that we must keep because we are keeping CU. */
10090 dwarf2_mark_helper (void **slot, void *data)
10092 struct dwarf2_per_cu_data *per_cu;
10094 per_cu = (struct dwarf2_per_cu_data *) *slot;
10095 if (per_cu->cu->mark)
10097 per_cu->cu->mark = 1;
10099 if (per_cu->cu->dependencies != NULL)
10100 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
10106 dwarf2_mark (struct dwarf2_cu *cu)
10111 if (cu->dependencies != NULL)
10112 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
10116 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
10120 per_cu->cu->mark = 0;
10121 per_cu = per_cu->cu->read_in_chain;
10125 /* Trivial hash function for partial_die_info: the hash value of a DIE
10126 is its offset in .debug_info for this objfile. */
10129 partial_die_hash (const void *item)
10131 const struct partial_die_info *part_die = item;
10132 return part_die->offset;
10135 /* Trivial comparison function for partial_die_info structures: two DIEs
10136 are equal if they have the same offset. */
10139 partial_die_eq (const void *item_lhs, const void *item_rhs)
10141 const struct partial_die_info *part_die_lhs = item_lhs;
10142 const struct partial_die_info *part_die_rhs = item_rhs;
10143 return part_die_lhs->offset == part_die_rhs->offset;
10146 static struct cmd_list_element *set_dwarf2_cmdlist;
10147 static struct cmd_list_element *show_dwarf2_cmdlist;
10150 set_dwarf2_cmd (char *args, int from_tty)
10152 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
10156 show_dwarf2_cmd (char *args, int from_tty)
10158 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
10161 void _initialize_dwarf2_read (void);
10164 _initialize_dwarf2_read (void)
10166 dwarf2_objfile_data_key = register_objfile_data ();
10168 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
10169 Set DWARF 2 specific variables.\n\
10170 Configure DWARF 2 variables such as the cache size"),
10171 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
10172 0/*allow-unknown*/, &maintenance_set_cmdlist);
10174 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
10175 Show DWARF 2 specific variables\n\
10176 Show DWARF 2 variables such as the cache size"),
10177 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
10178 0/*allow-unknown*/, &maintenance_show_cmdlist);
10180 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
10181 &dwarf2_max_cache_age, _("\
10182 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10183 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10184 A higher limit means that cached compilation units will be stored\n\
10185 in memory longer, and more total memory will be used. Zero disables\n\
10186 caching, which can slow down startup."),
10188 show_dwarf2_max_cache_age,
10189 &set_dwarf2_cmdlist,
10190 &show_dwarf2_cmdlist);