1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 support in dwarfread.c
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length; /* length of the .debug_info
83 unsigned short version; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
86 unsigned char addr_size; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length; /* length of the .debug_pubnames
99 unsigned char version; /* version number -- 2 for DWARF
101 unsigned int info_offset; /* offset into .debug_info section */
102 unsigned int info_size; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length; /* byte len of the .debug_aranges
115 unsigned short version; /* version number -- 2 for DWARF
117 unsigned int info_offset; /* offset into .debug_info section */
118 unsigned char addr_size; /* byte size of an address */
119 unsigned char seg_size; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length; /* byte length of the statement
131 unsigned short version; /* version number -- 2 for DWARF
133 unsigned int prologue_length; /* # bytes between prologue &
135 unsigned char minimum_instruction_length; /* byte size of
137 unsigned char default_is_stmt; /* initial value of is_stmt
140 unsigned char line_range;
141 unsigned char opcode_base; /* number assigned to first special
143 unsigned char *standard_opcode_lengths;
147 static const struct objfile_data *dwarf2_objfile_data_key;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size;
153 unsigned int abbrev_size;
154 unsigned int line_size;
155 unsigned int pubnames_size;
156 unsigned int aranges_size;
157 unsigned int loc_size;
158 unsigned int macinfo_size;
159 unsigned int str_size;
160 unsigned int ranges_size;
161 unsigned int frame_size;
162 unsigned int eh_frame_size;
164 /* Loaded data from the sections. */
165 gdb_byte *info_buffer;
166 gdb_byte *abbrev_buffer;
167 gdb_byte *line_buffer;
168 gdb_byte *str_buffer;
169 gdb_byte *macinfo_buffer;
170 gdb_byte *ranges_buffer;
171 gdb_byte *loc_buffer;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data **all_comp_units;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data *read_in_chain;
185 static struct dwarf2_per_objfile *dwarf2_per_objfile;
187 static asection *dwarf_info_section;
188 static asection *dwarf_abbrev_section;
189 static asection *dwarf_line_section;
190 static asection *dwarf_pubnames_section;
191 static asection *dwarf_aranges_section;
192 static asection *dwarf_loc_section;
193 static asection *dwarf_macinfo_section;
194 static asection *dwarf_str_section;
195 static asection *dwarf_ranges_section;
196 asection *dwarf_frame_section;
197 asection *dwarf_eh_frame_section;
199 /* names of the debugging sections */
201 #define INFO_SECTION ".debug_info"
202 #define ABBREV_SECTION ".debug_abbrev"
203 #define LINE_SECTION ".debug_line"
204 #define PUBNAMES_SECTION ".debug_pubnames"
205 #define ARANGES_SECTION ".debug_aranges"
206 #define LOC_SECTION ".debug_loc"
207 #define MACINFO_SECTION ".debug_macinfo"
208 #define STR_SECTION ".debug_str"
209 #define RANGES_SECTION ".debug_ranges"
210 #define FRAME_SECTION ".debug_frame"
211 #define EH_FRAME_SECTION ".eh_frame"
213 /* local data types */
215 /* We hold several abbreviation tables in memory at the same time. */
216 #ifndef ABBREV_HASH_SIZE
217 #define ABBREV_HASH_SIZE 121
220 /* The data in a compilation unit header, after target2host
221 translation, looks like this. */
222 struct comp_unit_head
224 unsigned long length;
226 unsigned int abbrev_offset;
227 unsigned char addr_size;
228 unsigned char signed_addr_p;
230 /* Size of file offsets; either 4 or 8. */
231 unsigned int offset_size;
233 /* Size of the length field; either 4 or 12. */
234 unsigned int initial_length_size;
236 /* Offset to the first byte of this compilation unit header in the
237 .debug_info section, for resolving relative reference dies. */
240 /* Pointer to this compilation unit header in the .debug_info
242 gdb_byte *cu_head_ptr;
244 /* Pointer to the first die of this compilation unit. This will be
245 the first byte following the compilation unit header. */
246 gdb_byte *first_die_ptr;
248 /* Pointer to the next compilation unit header in the program. */
249 struct comp_unit_head *next;
251 /* Base address of this compilation unit. */
252 CORE_ADDR base_address;
254 /* Non-zero if base_address has been set. */
258 /* Fixed size for the DIE hash table. */
259 #ifndef REF_HASH_SIZE
260 #define REF_HASH_SIZE 1021
263 /* Internal state when decoding a particular compilation unit. */
266 /* The objfile containing this compilation unit. */
267 struct objfile *objfile;
269 /* The header of the compilation unit.
271 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
272 should logically be moved to the dwarf2_cu structure. */
273 struct comp_unit_head header;
275 struct function_range *first_fn, *last_fn, *cached_fn;
277 /* The language we are debugging. */
278 enum language language;
279 const struct language_defn *language_defn;
281 const char *producer;
283 /* The generic symbol table building routines have separate lists for
284 file scope symbols and all all other scopes (local scopes). So
285 we need to select the right one to pass to add_symbol_to_list().
286 We do it by keeping a pointer to the correct list in list_in_scope.
288 FIXME: The original dwarf code just treated the file scope as the
289 first local scope, and all other local scopes as nested local
290 scopes, and worked fine. Check to see if we really need to
291 distinguish these in buildsym.c. */
292 struct pending **list_in_scope;
294 /* Maintain an array of referenced fundamental types for the current
295 compilation unit being read. For DWARF version 1, we have to construct
296 the fundamental types on the fly, since no information about the
297 fundamental types is supplied. Each such fundamental type is created by
298 calling a language dependent routine to create the type, and then a
299 pointer to that type is then placed in the array at the index specified
300 by it's FT_<TYPENAME> value. The array has a fixed size set by the
301 FT_NUM_MEMBERS compile time constant, which is the number of predefined
302 fundamental types gdb knows how to construct. */
303 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
305 /* DWARF abbreviation table associated with this compilation unit. */
306 struct abbrev_info **dwarf2_abbrevs;
308 /* Storage for the abbrev table. */
309 struct obstack abbrev_obstack;
311 /* Hash table holding all the loaded partial DIEs. */
314 /* Storage for things with the same lifetime as this read-in compilation
315 unit, including partial DIEs. */
316 struct obstack comp_unit_obstack;
318 /* When multiple dwarf2_cu structures are living in memory, this field
319 chains them all together, so that they can be released efficiently.
320 We will probably also want a generation counter so that most-recently-used
321 compilation units are cached... */
322 struct dwarf2_per_cu_data *read_in_chain;
324 /* Backchain to our per_cu entry if the tree has been built. */
325 struct dwarf2_per_cu_data *per_cu;
327 /* How many compilation units ago was this CU last referenced? */
330 /* A hash table of die offsets for following references. */
331 struct die_info *die_ref_table[REF_HASH_SIZE];
333 /* Full DIEs if read in. */
334 struct die_info *dies;
336 /* A set of pointers to dwarf2_per_cu_data objects for compilation
337 units referenced by this one. Only set during full symbol processing;
338 partial symbol tables do not have dependencies. */
341 /* Mark used when releasing cached dies. */
342 unsigned int mark : 1;
344 /* This flag will be set if this compilation unit might include
345 inter-compilation-unit references. */
346 unsigned int has_form_ref_addr : 1;
348 /* This flag will be set if this compilation unit includes any
349 DW_TAG_namespace DIEs. If we know that there are explicit
350 DIEs for namespaces, we don't need to try to infer them
351 from mangled names. */
352 unsigned int has_namespace_info : 1;
355 /* Persistent data held for a compilation unit, even when not
356 processing it. We put a pointer to this structure in the
357 read_symtab_private field of the psymtab. If we encounter
358 inter-compilation-unit references, we also maintain a sorted
359 list of all compilation units. */
361 struct dwarf2_per_cu_data
363 /* The start offset and length of this compilation unit. 2**31-1
364 bytes should suffice to store the length of any compilation unit
365 - if it doesn't, GDB will fall over anyway. */
366 unsigned long offset;
367 unsigned long length : 31;
369 /* Flag indicating this compilation unit will be read in before
370 any of the current compilation units are processed. */
371 unsigned long queued : 1;
373 /* Set iff currently read in. */
374 struct dwarf2_cu *cu;
376 /* If full symbols for this CU have been read in, then this field
377 holds a map of DIE offsets to types. It isn't always possible
378 to reconstruct this information later, so we have to preserve
382 /* The partial symbol table associated with this compilation unit. */
383 struct partial_symtab *psymtab;
386 /* The line number information for a compilation unit (found in the
387 .debug_line section) begins with a "statement program header",
388 which contains the following information. */
391 unsigned int total_length;
392 unsigned short version;
393 unsigned int header_length;
394 unsigned char minimum_instruction_length;
395 unsigned char default_is_stmt;
397 unsigned char line_range;
398 unsigned char opcode_base;
400 /* standard_opcode_lengths[i] is the number of operands for the
401 standard opcode whose value is i. This means that
402 standard_opcode_lengths[0] is unused, and the last meaningful
403 element is standard_opcode_lengths[opcode_base - 1]. */
404 unsigned char *standard_opcode_lengths;
406 /* The include_directories table. NOTE! These strings are not
407 allocated with xmalloc; instead, they are pointers into
408 debug_line_buffer. If you try to free them, `free' will get
410 unsigned int num_include_dirs, include_dirs_size;
413 /* The file_names table. NOTE! These strings are not allocated
414 with xmalloc; instead, they are pointers into debug_line_buffer.
415 Don't try to free them directly. */
416 unsigned int num_file_names, file_names_size;
420 unsigned int dir_index;
421 unsigned int mod_time;
423 int included_p; /* Non-zero if referenced by the Line Number Program. */
426 /* The start and end of the statement program following this
427 header. These point into dwarf2_per_objfile->line_buffer. */
428 gdb_byte *statement_program_start, *statement_program_end;
431 /* When we construct a partial symbol table entry we only
432 need this much information. */
433 struct partial_die_info
435 /* Offset of this DIE. */
438 /* DWARF-2 tag for this DIE. */
439 ENUM_BITFIELD(dwarf_tag) tag : 16;
441 /* Language code associated with this DIE. This is only used
442 for the compilation unit DIE. */
443 unsigned int language : 8;
445 /* Assorted flags describing the data found in this DIE. */
446 unsigned int has_children : 1;
447 unsigned int is_external : 1;
448 unsigned int is_declaration : 1;
449 unsigned int has_type : 1;
450 unsigned int has_specification : 1;
451 unsigned int has_stmt_list : 1;
452 unsigned int has_pc_info : 1;
454 /* Flag set if the SCOPE field of this structure has been
456 unsigned int scope_set : 1;
458 /* The name of this DIE. Normally the value of DW_AT_name, but
459 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
464 /* The scope to prepend to our children. This is generally
465 allocated on the comp_unit_obstack, so will disappear
466 when this compilation unit leaves the cache. */
469 /* The location description associated with this DIE, if any. */
470 struct dwarf_block *locdesc;
472 /* If HAS_PC_INFO, the PC range associated with this DIE. */
476 /* Pointer into the info_buffer pointing at the target of
477 DW_AT_sibling, if any. */
480 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
481 DW_AT_specification (or DW_AT_abstract_origin or
483 unsigned int spec_offset;
485 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
486 unsigned int line_offset;
488 /* Pointers to this DIE's parent, first child, and next sibling,
490 struct partial_die_info *die_parent, *die_child, *die_sibling;
493 /* This data structure holds the information of an abbrev. */
496 unsigned int number; /* number identifying abbrev */
497 enum dwarf_tag tag; /* dwarf tag */
498 unsigned short has_children; /* boolean */
499 unsigned short num_attrs; /* number of attributes */
500 struct attr_abbrev *attrs; /* an array of attribute descriptions */
501 struct abbrev_info *next; /* next in chain */
506 enum dwarf_attribute name;
507 enum dwarf_form form;
510 /* This data structure holds a complete die structure. */
513 enum dwarf_tag tag; /* Tag indicating type of die */
514 unsigned int abbrev; /* Abbrev number */
515 unsigned int offset; /* Offset in .debug_info section */
516 unsigned int num_attrs; /* Number of attributes */
517 struct attribute *attrs; /* An array of attributes */
518 struct die_info *next_ref; /* Next die in ref hash table */
520 /* The dies in a compilation unit form an n-ary tree. PARENT
521 points to this die's parent; CHILD points to the first child of
522 this node; and all the children of a given node are chained
523 together via their SIBLING fields, terminated by a die whose
525 struct die_info *child; /* Its first child, if any. */
526 struct die_info *sibling; /* Its next sibling, if any. */
527 struct die_info *parent; /* Its parent, if any. */
529 struct type *type; /* Cached type information */
532 /* Attributes have a name and a value */
535 enum dwarf_attribute name;
536 enum dwarf_form form;
540 struct dwarf_block *blk;
548 struct function_range
551 CORE_ADDR lowpc, highpc;
553 struct function_range *next;
556 /* Get at parts of an attribute structure */
558 #define DW_STRING(attr) ((attr)->u.str)
559 #define DW_UNSND(attr) ((attr)->u.unsnd)
560 #define DW_BLOCK(attr) ((attr)->u.blk)
561 #define DW_SND(attr) ((attr)->u.snd)
562 #define DW_ADDR(attr) ((attr)->u.addr)
564 /* Blocks are a bunch of untyped bytes. */
571 #ifndef ATTR_ALLOC_CHUNK
572 #define ATTR_ALLOC_CHUNK 4
575 /* Allocate fields for structs, unions and enums in this size. */
576 #ifndef DW_FIELD_ALLOC_CHUNK
577 #define DW_FIELD_ALLOC_CHUNK 4
580 /* A zeroed version of a partial die for initialization purposes. */
581 static struct partial_die_info zeroed_partial_die;
583 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
584 but this would require a corresponding change in unpack_field_as_long
586 static int bits_per_byte = 8;
588 /* The routines that read and process dies for a C struct or C++ class
589 pass lists of data member fields and lists of member function fields
590 in an instance of a field_info structure, as defined below. */
593 /* List of data member and baseclasses fields. */
596 struct nextfield *next;
603 /* Number of fields. */
606 /* Number of baseclasses. */
609 /* Set if the accesibility of one of the fields is not public. */
610 int non_public_fields;
612 /* Member function fields array, entries are allocated in the order they
613 are encountered in the object file. */
616 struct nextfnfield *next;
617 struct fn_field fnfield;
621 /* Member function fieldlist array, contains name of possibly overloaded
622 member function, number of overloaded member functions and a pointer
623 to the head of the member function field chain. */
628 struct nextfnfield *head;
632 /* Number of entries in the fnfieldlists array. */
636 /* One item on the queue of compilation units to read in full symbols
638 struct dwarf2_queue_item
640 struct dwarf2_per_cu_data *per_cu;
641 struct dwarf2_queue_item *next;
644 /* The current queue. */
645 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
647 /* Loaded secondary compilation units are kept in memory until they
648 have not been referenced for the processing of this many
649 compilation units. Set this to zero to disable caching. Cache
650 sizes of up to at least twenty will improve startup time for
651 typical inter-CU-reference binaries, at an obvious memory cost. */
652 static int dwarf2_max_cache_age = 5;
654 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
655 struct cmd_list_element *c, const char *value)
657 fprintf_filtered (file, _("\
658 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
663 /* Various complaints about symbol reading that don't abort the process */
666 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
668 complaint (&symfile_complaints,
669 _("statement list doesn't fit in .debug_line section"));
673 dwarf2_complex_location_expr_complaint (void)
675 complaint (&symfile_complaints, _("location expression too complex"));
679 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
682 complaint (&symfile_complaints,
683 _("const value length mismatch for '%s', got %d, expected %d"), arg1,
688 dwarf2_macros_too_long_complaint (void)
690 complaint (&symfile_complaints,
691 _("macro info runs off end of `.debug_macinfo' section"));
695 dwarf2_macro_malformed_definition_complaint (const char *arg1)
697 complaint (&symfile_complaints,
698 _("macro debug info contains a malformed macro definition:\n`%s'"),
703 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
705 complaint (&symfile_complaints,
706 _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
709 /* local function prototypes */
711 static void dwarf2_locate_sections (bfd *, asection *, void *);
714 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
717 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
720 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
721 struct partial_die_info *,
722 struct partial_symtab *);
724 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
726 static void scan_partial_symbols (struct partial_die_info *,
727 CORE_ADDR *, CORE_ADDR *,
730 static void add_partial_symbol (struct partial_die_info *,
733 static int pdi_needs_namespace (enum dwarf_tag tag);
735 static void add_partial_namespace (struct partial_die_info *pdi,
736 CORE_ADDR *lowpc, CORE_ADDR *highpc,
737 struct dwarf2_cu *cu);
739 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
740 struct dwarf2_cu *cu);
742 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
745 struct dwarf2_cu *cu);
747 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
749 static void psymtab_to_symtab_1 (struct partial_symtab *);
751 gdb_byte *dwarf2_read_section (struct objfile *, asection *);
753 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
755 static void dwarf2_free_abbrev_table (void *);
757 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
760 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
763 static struct partial_die_info *load_partial_dies (bfd *, gdb_byte *, int,
766 static gdb_byte *read_partial_die (struct partial_die_info *,
767 struct abbrev_info *abbrev, unsigned int,
768 bfd *, gdb_byte *, struct dwarf2_cu *);
770 static struct partial_die_info *find_partial_die (unsigned long,
773 static void fixup_partial_die (struct partial_die_info *,
776 static gdb_byte *read_full_die (struct die_info **, bfd *, gdb_byte *,
777 struct dwarf2_cu *, int *);
779 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
780 bfd *, gdb_byte *, struct dwarf2_cu *);
782 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
783 bfd *, gdb_byte *, struct dwarf2_cu *);
785 static unsigned int read_1_byte (bfd *, gdb_byte *);
787 static int read_1_signed_byte (bfd *, gdb_byte *);
789 static unsigned int read_2_bytes (bfd *, gdb_byte *);
791 static unsigned int read_4_bytes (bfd *, gdb_byte *);
793 static unsigned long read_8_bytes (bfd *, gdb_byte *);
795 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
798 static LONGEST read_initial_length (bfd *, gdb_byte *,
799 struct comp_unit_head *, unsigned int *);
801 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
804 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
806 static char *read_string (bfd *, gdb_byte *, unsigned int *);
808 static char *read_indirect_string (bfd *, gdb_byte *,
809 const struct comp_unit_head *,
812 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
814 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
816 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
818 static void set_cu_language (unsigned int, struct dwarf2_cu *);
820 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
823 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
824 struct dwarf2_cu *cu);
826 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
828 static struct die_info *die_specification (struct die_info *die,
831 static void free_line_header (struct line_header *lh);
833 static void add_file_name (struct line_header *, char *, unsigned int,
834 unsigned int, unsigned int);
836 static struct line_header *(dwarf_decode_line_header
837 (unsigned int offset,
838 bfd *abfd, struct dwarf2_cu *cu));
840 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
841 struct dwarf2_cu *, struct partial_symtab *);
843 static void dwarf2_start_subfile (char *, char *);
845 static struct symbol *new_symbol (struct die_info *, struct type *,
848 static void dwarf2_const_value (struct attribute *, struct symbol *,
851 static void dwarf2_const_value_data (struct attribute *attr,
855 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
857 static struct type *die_containing_type (struct die_info *,
860 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
862 static void read_type_die (struct die_info *, struct dwarf2_cu *);
864 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
866 static char *typename_concat (struct obstack *,
871 static void read_typedef (struct die_info *, struct dwarf2_cu *);
873 static void read_base_type (struct die_info *, struct dwarf2_cu *);
875 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
877 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
879 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
881 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
883 static int dwarf2_get_pc_bounds (struct die_info *,
884 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
886 static void get_scope_pc_bounds (struct die_info *,
887 CORE_ADDR *, CORE_ADDR *,
890 static void dwarf2_add_field (struct field_info *, struct die_info *,
893 static void dwarf2_attach_fields_to_type (struct field_info *,
894 struct type *, struct dwarf2_cu *);
896 static void dwarf2_add_member_fn (struct field_info *,
897 struct die_info *, struct type *,
900 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
901 struct type *, struct dwarf2_cu *);
903 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
905 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
907 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
909 static void read_common_block (struct die_info *, struct dwarf2_cu *);
911 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
913 static const char *namespace_name (struct die_info *die,
914 int *is_anonymous, struct dwarf2_cu *);
916 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
918 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
920 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
922 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
924 static void read_array_type (struct die_info *, struct dwarf2_cu *);
926 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
929 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
931 static void read_tag_ptr_to_member_type (struct die_info *,
934 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
936 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
938 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
940 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
942 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
944 static struct die_info *read_comp_unit (gdb_byte *, bfd *, struct dwarf2_cu *);
946 static struct die_info *read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
948 gdb_byte **new_info_ptr,
949 struct die_info *parent);
951 static struct die_info *read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
953 gdb_byte **new_info_ptr,
954 struct die_info *parent);
956 static void free_die_list (struct die_info *);
958 static void process_die (struct die_info *, struct dwarf2_cu *);
960 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
962 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
964 static struct die_info *dwarf2_extension (struct die_info *die,
967 static char *dwarf_tag_name (unsigned int);
969 static char *dwarf_attr_name (unsigned int);
971 static char *dwarf_form_name (unsigned int);
973 static char *dwarf_stack_op_name (unsigned int);
975 static char *dwarf_bool_name (unsigned int);
977 static char *dwarf_type_encoding_name (unsigned int);
980 static char *dwarf_cfi_name (unsigned int);
982 struct die_info *copy_die (struct die_info *);
985 static struct die_info *sibling_die (struct die_info *);
987 static void dump_die (struct die_info *);
989 static void dump_die_list (struct die_info *);
991 static void store_in_ref_table (unsigned int, struct die_info *,
994 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
997 static int dwarf2_get_attr_constant_value (struct attribute *, int);
999 static struct die_info *follow_die_ref (struct die_info *,
1001 struct dwarf2_cu *);
1003 static struct type *dwarf2_fundamental_type (struct objfile *, int,
1004 struct dwarf2_cu *);
1006 /* memory allocation interface */
1008 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1010 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1012 static struct die_info *dwarf_alloc_die (void);
1014 static void initialize_cu_func_list (struct dwarf2_cu *);
1016 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1017 struct dwarf2_cu *);
1019 static void dwarf_decode_macros (struct line_header *, unsigned int,
1020 char *, bfd *, struct dwarf2_cu *);
1022 static int attr_form_is_block (struct attribute *);
1025 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
1026 struct dwarf2_cu *cu);
1028 static gdb_byte *skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
1029 struct dwarf2_cu *cu);
1031 static void free_stack_comp_unit (void *);
1033 static hashval_t partial_die_hash (const void *item);
1035 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1037 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1038 (unsigned long offset, struct objfile *objfile);
1040 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1041 (unsigned long offset, struct objfile *objfile);
1043 static void free_one_comp_unit (void *);
1045 static void free_cached_comp_units (void *);
1047 static void age_cached_comp_units (void);
1049 static void free_one_cached_comp_unit (void *);
1051 static void set_die_type (struct die_info *, struct type *,
1052 struct dwarf2_cu *);
1054 static void reset_die_and_siblings_types (struct die_info *,
1055 struct dwarf2_cu *);
1057 static void create_all_comp_units (struct objfile *);
1059 static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *);
1061 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1063 static void dwarf2_add_dependence (struct dwarf2_cu *,
1064 struct dwarf2_per_cu_data *);
1066 static void dwarf2_mark (struct dwarf2_cu *);
1068 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1070 /* Try to locate the sections we need for DWARF 2 debugging
1071 information and return true if we have enough to do something. */
1074 dwarf2_has_info (struct objfile *objfile)
1076 struct dwarf2_per_objfile *data;
1078 /* Initialize per-objfile state. */
1079 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1080 memset (data, 0, sizeof (*data));
1081 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1082 dwarf2_per_objfile = data;
1084 dwarf_info_section = 0;
1085 dwarf_abbrev_section = 0;
1086 dwarf_line_section = 0;
1087 dwarf_str_section = 0;
1088 dwarf_macinfo_section = 0;
1089 dwarf_frame_section = 0;
1090 dwarf_eh_frame_section = 0;
1091 dwarf_ranges_section = 0;
1092 dwarf_loc_section = 0;
1094 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1095 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
1098 /* This function is mapped across the sections and remembers the
1099 offset and size of each of the debugging sections we are interested
1103 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
1105 if (strcmp (sectp->name, INFO_SECTION) == 0)
1107 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1108 dwarf_info_section = sectp;
1110 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1112 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1113 dwarf_abbrev_section = sectp;
1115 else if (strcmp (sectp->name, LINE_SECTION) == 0)
1117 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1118 dwarf_line_section = sectp;
1120 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1122 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1123 dwarf_pubnames_section = sectp;
1125 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1127 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1128 dwarf_aranges_section = sectp;
1130 else if (strcmp (sectp->name, LOC_SECTION) == 0)
1132 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1133 dwarf_loc_section = sectp;
1135 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1137 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1138 dwarf_macinfo_section = sectp;
1140 else if (strcmp (sectp->name, STR_SECTION) == 0)
1142 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1143 dwarf_str_section = sectp;
1145 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1147 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1148 dwarf_frame_section = sectp;
1150 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1152 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1153 if (aflag & SEC_HAS_CONTENTS)
1155 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1156 dwarf_eh_frame_section = sectp;
1159 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1161 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1162 dwarf_ranges_section = sectp;
1166 /* Build a partial symbol table. */
1169 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1171 /* We definitely need the .debug_info and .debug_abbrev sections */
1173 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1174 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1176 if (dwarf_line_section)
1177 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1179 dwarf2_per_objfile->line_buffer = NULL;
1181 if (dwarf_str_section)
1182 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1184 dwarf2_per_objfile->str_buffer = NULL;
1186 if (dwarf_macinfo_section)
1187 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1188 dwarf_macinfo_section);
1190 dwarf2_per_objfile->macinfo_buffer = NULL;
1192 if (dwarf_ranges_section)
1193 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1195 dwarf2_per_objfile->ranges_buffer = NULL;
1197 if (dwarf_loc_section)
1198 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1200 dwarf2_per_objfile->loc_buffer = NULL;
1203 || (objfile->global_psymbols.size == 0
1204 && objfile->static_psymbols.size == 0))
1206 init_psymbol_list (objfile, 1024);
1210 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1212 /* Things are significantly easier if we have .debug_aranges and
1213 .debug_pubnames sections */
1215 dwarf2_build_psymtabs_easy (objfile, mainline);
1219 /* only test this case for now */
1221 /* In this case we have to work a bit harder */
1222 dwarf2_build_psymtabs_hard (objfile, mainline);
1227 /* Build the partial symbol table from the information in the
1228 .debug_pubnames and .debug_aranges sections. */
1231 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1233 bfd *abfd = objfile->obfd;
1234 char *aranges_buffer, *pubnames_buffer;
1235 char *aranges_ptr, *pubnames_ptr;
1236 unsigned int entry_length, version, info_offset, info_size;
1238 pubnames_buffer = dwarf2_read_section (objfile,
1239 dwarf_pubnames_section);
1240 pubnames_ptr = pubnames_buffer;
1241 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1243 struct comp_unit_head cu_header;
1244 unsigned int bytes_read;
1246 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1248 pubnames_ptr += bytes_read;
1249 version = read_1_byte (abfd, pubnames_ptr);
1251 info_offset = read_4_bytes (abfd, pubnames_ptr);
1253 info_size = read_4_bytes (abfd, pubnames_ptr);
1257 aranges_buffer = dwarf2_read_section (objfile,
1258 dwarf_aranges_section);
1263 /* Read in the comp unit header information from the debug_info at
1267 read_comp_unit_head (struct comp_unit_head *cu_header,
1268 gdb_byte *info_ptr, bfd *abfd)
1271 unsigned int bytes_read;
1272 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1274 info_ptr += bytes_read;
1275 cu_header->version = read_2_bytes (abfd, info_ptr);
1277 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1279 info_ptr += bytes_read;
1280 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1282 signed_addr = bfd_get_sign_extend_vma (abfd);
1283 if (signed_addr < 0)
1284 internal_error (__FILE__, __LINE__,
1285 _("read_comp_unit_head: dwarf from non elf file"));
1286 cu_header->signed_addr_p = signed_addr;
1291 partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
1294 gdb_byte *beg_of_comp_unit = info_ptr;
1296 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1298 if (header->version != 2)
1299 error (_("Dwarf Error: wrong version in compilation unit header "
1300 "(is %d, should be %d) [in module %s]"), header->version,
1301 2, bfd_get_filename (abfd));
1303 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1304 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1305 "(offset 0x%lx + 6) [in module %s]"),
1306 (long) header->abbrev_offset,
1307 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1308 bfd_get_filename (abfd));
1310 if (beg_of_comp_unit + header->length + header->initial_length_size
1311 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1312 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1313 "(offset 0x%lx + 0) [in module %s]"),
1314 (long) header->length,
1315 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1316 bfd_get_filename (abfd));
1321 /* Allocate a new partial symtab for file named NAME and mark this new
1322 partial symtab as being an include of PST. */
1325 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1326 struct objfile *objfile)
1328 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1330 subpst->section_offsets = pst->section_offsets;
1331 subpst->textlow = 0;
1332 subpst->texthigh = 0;
1334 subpst->dependencies = (struct partial_symtab **)
1335 obstack_alloc (&objfile->objfile_obstack,
1336 sizeof (struct partial_symtab *));
1337 subpst->dependencies[0] = pst;
1338 subpst->number_of_dependencies = 1;
1340 subpst->globals_offset = 0;
1341 subpst->n_global_syms = 0;
1342 subpst->statics_offset = 0;
1343 subpst->n_static_syms = 0;
1344 subpst->symtab = NULL;
1345 subpst->read_symtab = pst->read_symtab;
1348 /* No private part is necessary for include psymtabs. This property
1349 can be used to differentiate between such include psymtabs and
1350 the regular ones. */
1351 subpst->read_symtab_private = NULL;
1354 /* Read the Line Number Program data and extract the list of files
1355 included by the source file represented by PST. Build an include
1356 partial symtab for each of these included files.
1358 This procedure assumes that there *is* a Line Number Program in
1359 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1360 before calling this procedure. */
1363 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1364 struct partial_die_info *pdi,
1365 struct partial_symtab *pst)
1367 struct objfile *objfile = cu->objfile;
1368 bfd *abfd = objfile->obfd;
1369 struct line_header *lh;
1371 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1373 return; /* No linetable, so no includes. */
1375 dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1377 free_line_header (lh);
1381 /* Build the partial symbol table by doing a quick pass through the
1382 .debug_info and .debug_abbrev sections. */
1385 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1387 /* Instead of reading this into a big buffer, we should probably use
1388 mmap() on architectures that support it. (FIXME) */
1389 bfd *abfd = objfile->obfd;
1391 gdb_byte *beg_of_comp_unit;
1392 struct partial_die_info comp_unit_die;
1393 struct partial_symtab *pst;
1394 struct cleanup *back_to;
1395 CORE_ADDR lowpc, highpc, baseaddr;
1397 info_ptr = dwarf2_per_objfile->info_buffer;
1399 /* Any cached compilation units will be linked by the per-objfile
1400 read_in_chain. Make sure to free them when we're done. */
1401 back_to = make_cleanup (free_cached_comp_units, NULL);
1403 create_all_comp_units (objfile);
1405 /* Since the objects we're extracting from .debug_info vary in
1406 length, only the individual functions to extract them (like
1407 read_comp_unit_head and load_partial_die) can really know whether
1408 the buffer is large enough to hold another complete object.
1410 At the moment, they don't actually check that. If .debug_info
1411 holds just one extra byte after the last compilation unit's dies,
1412 then read_comp_unit_head will happily read off the end of the
1413 buffer. read_partial_die is similarly casual. Those functions
1416 For this loop condition, simply checking whether there's any data
1417 left at all should be sufficient. */
1418 while (info_ptr < (dwarf2_per_objfile->info_buffer
1419 + dwarf2_per_objfile->info_size))
1421 struct cleanup *back_to_inner;
1422 struct dwarf2_cu cu;
1423 struct abbrev_info *abbrev;
1424 unsigned int bytes_read;
1425 struct dwarf2_per_cu_data *this_cu;
1427 beg_of_comp_unit = info_ptr;
1429 memset (&cu, 0, sizeof (cu));
1431 obstack_init (&cu.comp_unit_obstack);
1433 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1435 cu.objfile = objfile;
1436 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1438 /* Complete the cu_header */
1439 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1440 cu.header.first_die_ptr = info_ptr;
1441 cu.header.cu_head_ptr = beg_of_comp_unit;
1443 cu.list_in_scope = &file_symbols;
1445 /* Read the abbrevs for this compilation unit into a table */
1446 dwarf2_read_abbrevs (abfd, &cu);
1447 make_cleanup (dwarf2_free_abbrev_table, &cu);
1449 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile);
1451 /* Read the compilation unit die */
1452 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1453 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1454 abfd, info_ptr, &cu);
1456 /* Set the language we're debugging */
1457 set_cu_language (comp_unit_die.language, &cu);
1459 /* Allocate a new partial symbol table structure */
1460 pst = start_psymtab_common (objfile, objfile->section_offsets,
1461 comp_unit_die.name ? comp_unit_die.name : "",
1462 comp_unit_die.lowpc,
1463 objfile->global_psymbols.next,
1464 objfile->static_psymbols.next);
1466 if (comp_unit_die.dirname)
1467 pst->dirname = xstrdup (comp_unit_die.dirname);
1469 pst->read_symtab_private = (char *) this_cu;
1471 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1473 /* Store the function that reads in the rest of the symbol table */
1474 pst->read_symtab = dwarf2_psymtab_to_symtab;
1476 /* If this compilation unit was already read in, free the
1477 cached copy in order to read it in again. This is
1478 necessary because we skipped some symbols when we first
1479 read in the compilation unit (see load_partial_dies).
1480 This problem could be avoided, but the benefit is
1482 if (this_cu->cu != NULL)
1483 free_one_cached_comp_unit (this_cu->cu);
1485 cu.per_cu = this_cu;
1487 /* Note that this is a pointer to our stack frame, being
1488 added to a global data structure. It will be cleaned up
1489 in free_stack_comp_unit when we finish with this
1490 compilation unit. */
1493 this_cu->psymtab = pst;
1495 /* Check if comp unit has_children.
1496 If so, read the rest of the partial symbols from this comp unit.
1497 If not, there's no more debug_info for this comp unit. */
1498 if (comp_unit_die.has_children)
1500 struct partial_die_info *first_die;
1502 lowpc = ((CORE_ADDR) -1);
1503 highpc = ((CORE_ADDR) 0);
1505 first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1507 scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1509 /* If we didn't find a lowpc, set it to highpc to avoid
1510 complaints from `maint check'. */
1511 if (lowpc == ((CORE_ADDR) -1))
1514 /* If the compilation unit didn't have an explicit address range,
1515 then use the information extracted from its child dies. */
1516 if (! comp_unit_die.has_pc_info)
1518 comp_unit_die.lowpc = lowpc;
1519 comp_unit_die.highpc = highpc;
1522 pst->textlow = comp_unit_die.lowpc + baseaddr;
1523 pst->texthigh = comp_unit_die.highpc + baseaddr;
1525 pst->n_global_syms = objfile->global_psymbols.next -
1526 (objfile->global_psymbols.list + pst->globals_offset);
1527 pst->n_static_syms = objfile->static_psymbols.next -
1528 (objfile->static_psymbols.list + pst->statics_offset);
1529 sort_pst_symbols (pst);
1531 /* If there is already a psymtab or symtab for a file of this
1532 name, remove it. (If there is a symtab, more drastic things
1533 also happen.) This happens in VxWorks. */
1534 free_named_symtabs (pst->filename);
1536 info_ptr = beg_of_comp_unit + cu.header.length
1537 + cu.header.initial_length_size;
1539 if (comp_unit_die.has_stmt_list)
1541 /* Get the list of files included in the current compilation unit,
1542 and build a psymtab for each of them. */
1543 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1546 do_cleanups (back_to_inner);
1548 do_cleanups (back_to);
1551 /* Load the DIEs for a secondary CU into memory. */
1554 load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile)
1556 bfd *abfd = objfile->obfd;
1557 gdb_byte *info_ptr, *beg_of_comp_unit;
1558 struct partial_die_info comp_unit_die;
1559 struct dwarf2_cu *cu;
1560 struct abbrev_info *abbrev;
1561 unsigned int bytes_read;
1562 struct cleanup *back_to;
1564 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset;
1565 beg_of_comp_unit = info_ptr;
1567 cu = xmalloc (sizeof (struct dwarf2_cu));
1568 memset (cu, 0, sizeof (struct dwarf2_cu));
1570 obstack_init (&cu->comp_unit_obstack);
1572 cu->objfile = objfile;
1573 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd);
1575 /* Complete the cu_header. */
1576 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1577 cu->header.first_die_ptr = info_ptr;
1578 cu->header.cu_head_ptr = beg_of_comp_unit;
1580 /* Read the abbrevs for this compilation unit into a table. */
1581 dwarf2_read_abbrevs (abfd, cu);
1582 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
1584 /* Read the compilation unit die. */
1585 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1586 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1587 abfd, info_ptr, cu);
1589 /* Set the language we're debugging. */
1590 set_cu_language (comp_unit_die.language, cu);
1592 /* Link this compilation unit into the compilation unit tree. */
1594 cu->per_cu = this_cu;
1596 /* Check if comp unit has_children.
1597 If so, read the rest of the partial symbols from this comp unit.
1598 If not, there's no more debug_info for this comp unit. */
1599 if (comp_unit_die.has_children)
1600 load_partial_dies (abfd, info_ptr, 0, cu);
1602 do_cleanups (back_to);
1605 /* Create a list of all compilation units in OBJFILE. We do this only
1606 if an inter-comp-unit reference is found; presumably if there is one,
1607 there will be many, and one will occur early in the .debug_info section.
1608 So there's no point in building this list incrementally. */
1611 create_all_comp_units (struct objfile *objfile)
1615 struct dwarf2_per_cu_data **all_comp_units;
1616 gdb_byte *info_ptr = dwarf2_per_objfile->info_buffer;
1620 all_comp_units = xmalloc (n_allocated
1621 * sizeof (struct dwarf2_per_cu_data *));
1623 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1625 struct comp_unit_head cu_header;
1626 gdb_byte *beg_of_comp_unit;
1627 struct dwarf2_per_cu_data *this_cu;
1628 unsigned long offset;
1629 unsigned int bytes_read;
1631 offset = info_ptr - dwarf2_per_objfile->info_buffer;
1633 /* Read just enough information to find out where the next
1634 compilation unit is. */
1635 cu_header.initial_length_size = 0;
1636 cu_header.length = read_initial_length (objfile->obfd, info_ptr,
1637 &cu_header, &bytes_read);
1639 /* Save the compilation unit for later lookup. */
1640 this_cu = obstack_alloc (&objfile->objfile_obstack,
1641 sizeof (struct dwarf2_per_cu_data));
1642 memset (this_cu, 0, sizeof (*this_cu));
1643 this_cu->offset = offset;
1644 this_cu->length = cu_header.length + cu_header.initial_length_size;
1646 if (n_comp_units == n_allocated)
1649 all_comp_units = xrealloc (all_comp_units,
1651 * sizeof (struct dwarf2_per_cu_data *));
1653 all_comp_units[n_comp_units++] = this_cu;
1655 info_ptr = info_ptr + this_cu->length;
1658 dwarf2_per_objfile->all_comp_units
1659 = obstack_alloc (&objfile->objfile_obstack,
1660 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1661 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
1662 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1663 xfree (all_comp_units);
1664 dwarf2_per_objfile->n_comp_units = n_comp_units;
1667 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1668 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1672 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1673 CORE_ADDR *highpc, struct dwarf2_cu *cu)
1675 struct objfile *objfile = cu->objfile;
1676 bfd *abfd = objfile->obfd;
1677 struct partial_die_info *pdi;
1679 /* Now, march along the PDI's, descending into ones which have
1680 interesting children but skipping the children of the other ones,
1681 until we reach the end of the compilation unit. */
1687 fixup_partial_die (pdi, cu);
1689 /* Anonymous namespaces have no name but have interesting
1690 children, so we need to look at them. Ditto for anonymous
1693 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1694 || pdi->tag == DW_TAG_enumeration_type)
1698 case DW_TAG_subprogram:
1699 if (pdi->has_pc_info)
1701 if (pdi->lowpc < *lowpc)
1703 *lowpc = pdi->lowpc;
1705 if (pdi->highpc > *highpc)
1707 *highpc = pdi->highpc;
1709 if (!pdi->is_declaration)
1711 add_partial_symbol (pdi, cu);
1715 case DW_TAG_variable:
1716 case DW_TAG_typedef:
1717 case DW_TAG_union_type:
1718 if (!pdi->is_declaration)
1720 add_partial_symbol (pdi, cu);
1723 case DW_TAG_class_type:
1724 case DW_TAG_structure_type:
1725 if (!pdi->is_declaration)
1727 add_partial_symbol (pdi, cu);
1730 case DW_TAG_enumeration_type:
1731 if (!pdi->is_declaration)
1732 add_partial_enumeration (pdi, cu);
1734 case DW_TAG_base_type:
1735 case DW_TAG_subrange_type:
1736 /* File scope base type definitions are added to the partial
1738 add_partial_symbol (pdi, cu);
1740 case DW_TAG_namespace:
1741 add_partial_namespace (pdi, lowpc, highpc, cu);
1748 /* If the die has a sibling, skip to the sibling. */
1750 pdi = pdi->die_sibling;
1754 /* Functions used to compute the fully scoped name of a partial DIE.
1756 Normally, this is simple. For C++, the parent DIE's fully scoped
1757 name is concatenated with "::" and the partial DIE's name. For
1758 Java, the same thing occurs except that "." is used instead of "::".
1759 Enumerators are an exception; they use the scope of their parent
1760 enumeration type, i.e. the name of the enumeration type is not
1761 prepended to the enumerator.
1763 There are two complexities. One is DW_AT_specification; in this
1764 case "parent" means the parent of the target of the specification,
1765 instead of the direct parent of the DIE. The other is compilers
1766 which do not emit DW_TAG_namespace; in this case we try to guess
1767 the fully qualified name of structure types from their members'
1768 linkage names. This must be done using the DIE's children rather
1769 than the children of any DW_AT_specification target. We only need
1770 to do this for structures at the top level, i.e. if the target of
1771 any DW_AT_specification (if any; otherwise the DIE itself) does not
1774 /* Compute the scope prefix associated with PDI's parent, in
1775 compilation unit CU. The result will be allocated on CU's
1776 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1777 field. NULL is returned if no prefix is necessary. */
1779 partial_die_parent_scope (struct partial_die_info *pdi,
1780 struct dwarf2_cu *cu)
1782 char *grandparent_scope;
1783 struct partial_die_info *parent, *real_pdi;
1785 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1786 then this means the parent of the specification DIE. */
1789 while (real_pdi->has_specification)
1790 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
1792 parent = real_pdi->die_parent;
1796 if (parent->scope_set)
1797 return parent->scope;
1799 fixup_partial_die (parent, cu);
1801 grandparent_scope = partial_die_parent_scope (parent, cu);
1803 if (parent->tag == DW_TAG_namespace
1804 || parent->tag == DW_TAG_structure_type
1805 || parent->tag == DW_TAG_class_type
1806 || parent->tag == DW_TAG_union_type)
1808 if (grandparent_scope == NULL)
1809 parent->scope = parent->name;
1811 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
1814 else if (parent->tag == DW_TAG_enumeration_type)
1815 /* Enumerators should not get the name of the enumeration as a prefix. */
1816 parent->scope = grandparent_scope;
1819 /* FIXME drow/2004-04-01: What should we be doing with
1820 function-local names? For partial symbols, we should probably be
1822 complaint (&symfile_complaints,
1823 _("unhandled containing DIE tag %d for DIE at %d"),
1824 parent->tag, pdi->offset);
1825 parent->scope = grandparent_scope;
1828 parent->scope_set = 1;
1829 return parent->scope;
1832 /* Return the fully scoped name associated with PDI, from compilation unit
1833 CU. The result will be allocated with malloc. */
1835 partial_die_full_name (struct partial_die_info *pdi,
1836 struct dwarf2_cu *cu)
1840 parent_scope = partial_die_parent_scope (pdi, cu);
1841 if (parent_scope == NULL)
1844 return typename_concat (NULL, parent_scope, pdi->name, cu);
1848 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1850 struct objfile *objfile = cu->objfile;
1853 const char *my_prefix;
1854 const struct partial_symbol *psym = NULL;
1856 int built_actual_name = 0;
1858 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1862 if (pdi_needs_namespace (pdi->tag))
1864 actual_name = partial_die_full_name (pdi, cu);
1866 built_actual_name = 1;
1869 if (actual_name == NULL)
1870 actual_name = pdi->name;
1874 case DW_TAG_subprogram:
1875 if (pdi->is_external)
1877 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1878 mst_text, objfile); */
1879 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1880 VAR_DOMAIN, LOC_BLOCK,
1881 &objfile->global_psymbols,
1882 0, pdi->lowpc + baseaddr,
1883 cu->language, objfile);
1887 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1888 mst_file_text, objfile); */
1889 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1890 VAR_DOMAIN, LOC_BLOCK,
1891 &objfile->static_psymbols,
1892 0, pdi->lowpc + baseaddr,
1893 cu->language, objfile);
1896 case DW_TAG_variable:
1897 if (pdi->is_external)
1900 Don't enter into the minimal symbol tables as there is
1901 a minimal symbol table entry from the ELF symbols already.
1902 Enter into partial symbol table if it has a location
1903 descriptor or a type.
1904 If the location descriptor is missing, new_symbol will create
1905 a LOC_UNRESOLVED symbol, the address of the variable will then
1906 be determined from the minimal symbol table whenever the variable
1908 The address for the partial symbol table entry is not
1909 used by GDB, but it comes in handy for debugging partial symbol
1913 addr = decode_locdesc (pdi->locdesc, cu);
1914 if (pdi->locdesc || pdi->has_type)
1915 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1916 VAR_DOMAIN, LOC_STATIC,
1917 &objfile->global_psymbols,
1919 cu->language, objfile);
1923 /* Static Variable. Skip symbols without location descriptors. */
1924 if (pdi->locdesc == NULL)
1926 addr = decode_locdesc (pdi->locdesc, cu);
1927 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1928 mst_file_data, objfile); */
1929 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1930 VAR_DOMAIN, LOC_STATIC,
1931 &objfile->static_psymbols,
1933 cu->language, objfile);
1936 case DW_TAG_typedef:
1937 case DW_TAG_base_type:
1938 case DW_TAG_subrange_type:
1939 add_psymbol_to_list (actual_name, strlen (actual_name),
1940 VAR_DOMAIN, LOC_TYPEDEF,
1941 &objfile->static_psymbols,
1942 0, (CORE_ADDR) 0, cu->language, objfile);
1944 case DW_TAG_namespace:
1945 add_psymbol_to_list (actual_name, strlen (actual_name),
1946 VAR_DOMAIN, LOC_TYPEDEF,
1947 &objfile->global_psymbols,
1948 0, (CORE_ADDR) 0, cu->language, objfile);
1950 case DW_TAG_class_type:
1951 case DW_TAG_structure_type:
1952 case DW_TAG_union_type:
1953 case DW_TAG_enumeration_type:
1954 /* Skip aggregate types without children, these are external
1956 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1957 static vs. global. */
1958 if (pdi->has_children == 0)
1960 add_psymbol_to_list (actual_name, strlen (actual_name),
1961 STRUCT_DOMAIN, LOC_TYPEDEF,
1962 (cu->language == language_cplus
1963 || cu->language == language_java)
1964 ? &objfile->global_psymbols
1965 : &objfile->static_psymbols,
1966 0, (CORE_ADDR) 0, cu->language, objfile);
1968 if (cu->language == language_cplus
1969 || cu->language == language_java)
1971 /* For C++ and Java, these implicitly act as typedefs as well. */
1972 add_psymbol_to_list (actual_name, strlen (actual_name),
1973 VAR_DOMAIN, LOC_TYPEDEF,
1974 &objfile->global_psymbols,
1975 0, (CORE_ADDR) 0, cu->language, objfile);
1978 case DW_TAG_enumerator:
1979 add_psymbol_to_list (actual_name, strlen (actual_name),
1980 VAR_DOMAIN, LOC_CONST,
1981 (cu->language == language_cplus
1982 || cu->language == language_java)
1983 ? &objfile->global_psymbols
1984 : &objfile->static_psymbols,
1985 0, (CORE_ADDR) 0, cu->language, objfile);
1991 /* Check to see if we should scan the name for possible namespace
1992 info. Only do this if this is C++, if we don't have namespace
1993 debugging info in the file, if the psym is of an appropriate type
1994 (otherwise we'll have psym == NULL), and if we actually had a
1995 mangled name to begin with. */
1997 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1998 cases which do not set PSYM above? */
2000 if (cu->language == language_cplus
2001 && cu->has_namespace_info == 0
2003 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2004 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2007 if (built_actual_name)
2008 xfree (actual_name);
2011 /* Determine whether a die of type TAG living in a C++ class or
2012 namespace needs to have the name of the scope prepended to the
2013 name listed in the die. */
2016 pdi_needs_namespace (enum dwarf_tag tag)
2020 case DW_TAG_namespace:
2021 case DW_TAG_typedef:
2022 case DW_TAG_class_type:
2023 case DW_TAG_structure_type:
2024 case DW_TAG_union_type:
2025 case DW_TAG_enumeration_type:
2026 case DW_TAG_enumerator:
2033 /* Read a partial die corresponding to a namespace; also, add a symbol
2034 corresponding to that namespace to the symbol table. NAMESPACE is
2035 the name of the enclosing namespace. */
2038 add_partial_namespace (struct partial_die_info *pdi,
2039 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2040 struct dwarf2_cu *cu)
2042 struct objfile *objfile = cu->objfile;
2044 /* Add a symbol for the namespace. */
2046 add_partial_symbol (pdi, cu);
2048 /* Now scan partial symbols in that namespace. */
2050 if (pdi->has_children)
2051 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
2054 /* See if we can figure out if the class lives in a namespace. We do
2055 this by looking for a member function; its demangled name will
2056 contain namespace info, if there is any. */
2059 guess_structure_name (struct partial_die_info *struct_pdi,
2060 struct dwarf2_cu *cu)
2062 if ((cu->language == language_cplus
2063 || cu->language == language_java)
2064 && cu->has_namespace_info == 0
2065 && struct_pdi->has_children)
2067 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2068 what template types look like, because the demangler
2069 frequently doesn't give the same name as the debug info. We
2070 could fix this by only using the demangled name to get the
2071 prefix (but see comment in read_structure_type). */
2073 struct partial_die_info *child_pdi = struct_pdi->die_child;
2074 struct partial_die_info *real_pdi;
2076 /* If this DIE (this DIE's specification, if any) has a parent, then
2077 we should not do this. We'll prepend the parent's fully qualified
2078 name when we create the partial symbol. */
2080 real_pdi = struct_pdi;
2081 while (real_pdi->has_specification)
2082 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2084 if (real_pdi->die_parent != NULL)
2087 while (child_pdi != NULL)
2089 if (child_pdi->tag == DW_TAG_subprogram)
2091 char *actual_class_name
2092 = language_class_name_from_physname (cu->language_defn,
2094 if (actual_class_name != NULL)
2097 = obsavestring (actual_class_name,
2098 strlen (actual_class_name),
2099 &cu->comp_unit_obstack);
2100 xfree (actual_class_name);
2105 child_pdi = child_pdi->die_sibling;
2110 /* Read a partial die corresponding to an enumeration type. */
2113 add_partial_enumeration (struct partial_die_info *enum_pdi,
2114 struct dwarf2_cu *cu)
2116 struct objfile *objfile = cu->objfile;
2117 bfd *abfd = objfile->obfd;
2118 struct partial_die_info *pdi;
2120 if (enum_pdi->name != NULL)
2121 add_partial_symbol (enum_pdi, cu);
2123 pdi = enum_pdi->die_child;
2126 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2127 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2129 add_partial_symbol (pdi, cu);
2130 pdi = pdi->die_sibling;
2134 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2135 Return the corresponding abbrev, or NULL if the number is zero (indicating
2136 an empty DIE). In either case *BYTES_READ will be set to the length of
2137 the initial number. */
2139 static struct abbrev_info *
2140 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
2141 struct dwarf2_cu *cu)
2143 bfd *abfd = cu->objfile->obfd;
2144 unsigned int abbrev_number;
2145 struct abbrev_info *abbrev;
2147 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2149 if (abbrev_number == 0)
2152 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2155 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2156 bfd_get_filename (abfd));
2162 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2163 pointer to the end of a series of DIEs, terminated by an empty
2164 DIE. Any children of the skipped DIEs will also be skipped. */
2167 skip_children (gdb_byte *info_ptr, struct dwarf2_cu *cu)
2169 struct abbrev_info *abbrev;
2170 unsigned int bytes_read;
2174 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2176 return info_ptr + bytes_read;
2178 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
2182 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2183 should point just after the initial uleb128 of a DIE, and the
2184 abbrev corresponding to that skipped uleb128 should be passed in
2185 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2189 skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
2190 struct dwarf2_cu *cu)
2192 unsigned int bytes_read;
2193 struct attribute attr;
2194 bfd *abfd = cu->objfile->obfd;
2195 unsigned int form, i;
2197 for (i = 0; i < abbrev->num_attrs; i++)
2199 /* The only abbrev we care about is DW_AT_sibling. */
2200 if (abbrev->attrs[i].name == DW_AT_sibling)
2202 read_attribute (&attr, &abbrev->attrs[i],
2203 abfd, info_ptr, cu);
2204 if (attr.form == DW_FORM_ref_addr)
2205 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2207 return dwarf2_per_objfile->info_buffer
2208 + dwarf2_get_ref_die_offset (&attr, cu);
2211 /* If it isn't DW_AT_sibling, skip this attribute. */
2212 form = abbrev->attrs[i].form;
2217 case DW_FORM_ref_addr:
2218 info_ptr += cu->header.addr_size;
2237 case DW_FORM_string:
2238 read_string (abfd, info_ptr, &bytes_read);
2239 info_ptr += bytes_read;
2242 info_ptr += cu->header.offset_size;
2245 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2246 info_ptr += bytes_read;
2248 case DW_FORM_block1:
2249 info_ptr += 1 + read_1_byte (abfd, info_ptr);
2251 case DW_FORM_block2:
2252 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2254 case DW_FORM_block4:
2255 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2259 case DW_FORM_ref_udata:
2260 info_ptr = skip_leb128 (abfd, info_ptr);
2262 case DW_FORM_indirect:
2263 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2264 info_ptr += bytes_read;
2265 /* We need to continue parsing from here, so just go back to
2267 goto skip_attribute;
2270 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2271 dwarf_form_name (form),
2272 bfd_get_filename (abfd));
2276 if (abbrev->has_children)
2277 return skip_children (info_ptr, cu);
2282 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2283 the next DIE after ORIG_PDI. */
2286 locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr,
2287 bfd *abfd, struct dwarf2_cu *cu)
2289 /* Do we know the sibling already? */
2291 if (orig_pdi->sibling)
2292 return orig_pdi->sibling;
2294 /* Are there any children to deal with? */
2296 if (!orig_pdi->has_children)
2299 /* Skip the children the long way. */
2301 return skip_children (info_ptr, cu);
2304 /* Expand this partial symbol table into a full symbol table. */
2307 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2309 /* FIXME: This is barely more than a stub. */
2314 warning (_("bug: psymtab for %s is already read in."), pst->filename);
2320 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
2321 gdb_flush (gdb_stdout);
2324 /* Restore our global data. */
2325 dwarf2_per_objfile = objfile_data (pst->objfile,
2326 dwarf2_objfile_data_key);
2328 psymtab_to_symtab_1 (pst);
2330 /* Finish up the debug error message. */
2332 printf_filtered (_("done.\n"));
2337 /* Add PER_CU to the queue. */
2340 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
2342 struct dwarf2_queue_item *item;
2345 item = xmalloc (sizeof (*item));
2346 item->per_cu = per_cu;
2349 if (dwarf2_queue == NULL)
2350 dwarf2_queue = item;
2352 dwarf2_queue_tail->next = item;
2354 dwarf2_queue_tail = item;
2357 /* Process the queue. */
2360 process_queue (struct objfile *objfile)
2362 struct dwarf2_queue_item *item, *next_item;
2364 /* Initially, there is just one item on the queue. Load its DIEs,
2365 and the DIEs of any other compilation units it requires,
2368 for (item = dwarf2_queue; item != NULL; item = item->next)
2370 /* Read in this compilation unit. This may add new items to
2371 the end of the queue. */
2372 load_full_comp_unit (item->per_cu);
2374 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
2375 dwarf2_per_objfile->read_in_chain = item->per_cu;
2377 /* If this compilation unit has already had full symbols created,
2378 reset the TYPE fields in each DIE. */
2379 if (item->per_cu->psymtab->readin)
2380 reset_die_and_siblings_types (item->per_cu->cu->dies,
2384 /* Now everything left on the queue needs to be read in. Process
2385 them, one at a time, removing from the queue as we finish. */
2386 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
2388 if (!item->per_cu->psymtab->readin)
2389 process_full_comp_unit (item->per_cu);
2391 item->per_cu->queued = 0;
2392 next_item = item->next;
2396 dwarf2_queue_tail = NULL;
2399 /* Free all allocated queue entries. This function only releases anything if
2400 an error was thrown; if the queue was processed then it would have been
2401 freed as we went along. */
2404 dwarf2_release_queue (void *dummy)
2406 struct dwarf2_queue_item *item, *last;
2408 item = dwarf2_queue;
2411 /* Anything still marked queued is likely to be in an
2412 inconsistent state, so discard it. */
2413 if (item->per_cu->queued)
2415 if (item->per_cu->cu != NULL)
2416 free_one_cached_comp_unit (item->per_cu->cu);
2417 item->per_cu->queued = 0;
2425 dwarf2_queue = dwarf2_queue_tail = NULL;
2428 /* Read in full symbols for PST, and anything it depends on. */
2431 psymtab_to_symtab_1 (struct partial_symtab *pst)
2433 struct dwarf2_per_cu_data *per_cu;
2434 struct cleanup *back_to;
2437 for (i = 0; i < pst->number_of_dependencies; i++)
2438 if (!pst->dependencies[i]->readin)
2440 /* Inform about additional files that need to be read in. */
2443 /* FIXME: i18n: Need to make this a single string. */
2444 fputs_filtered (" ", gdb_stdout);
2446 fputs_filtered ("and ", gdb_stdout);
2448 printf_filtered ("%s...", pst->dependencies[i]->filename);
2449 wrap_here (""); /* Flush output */
2450 gdb_flush (gdb_stdout);
2452 psymtab_to_symtab_1 (pst->dependencies[i]);
2455 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
2459 /* It's an include file, no symbols to read for it.
2460 Everything is in the parent symtab. */
2465 back_to = make_cleanup (dwarf2_release_queue, NULL);
2467 queue_comp_unit (per_cu);
2469 process_queue (pst->objfile);
2471 /* Age the cache, releasing compilation units that have not
2472 been used recently. */
2473 age_cached_comp_units ();
2475 do_cleanups (back_to);
2478 /* Load the DIEs associated with PST and PER_CU into memory. */
2480 static struct dwarf2_cu *
2481 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2483 struct partial_symtab *pst = per_cu->psymtab;
2484 bfd *abfd = pst->objfile->obfd;
2485 struct dwarf2_cu *cu;
2486 unsigned long offset;
2488 struct cleanup *back_to, *free_cu_cleanup;
2489 struct attribute *attr;
2492 /* Set local variables from the partial symbol table info. */
2493 offset = per_cu->offset;
2495 info_ptr = dwarf2_per_objfile->info_buffer + offset;
2497 cu = xmalloc (sizeof (struct dwarf2_cu));
2498 memset (cu, 0, sizeof (struct dwarf2_cu));
2500 /* If an error occurs while loading, release our storage. */
2501 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
2503 cu->objfile = pst->objfile;
2505 /* read in the comp_unit header */
2506 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
2508 /* Read the abbrevs for this compilation unit */
2509 dwarf2_read_abbrevs (abfd, cu);
2510 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2512 cu->header.offset = offset;
2514 cu->per_cu = per_cu;
2517 /* We use this obstack for block values in dwarf_alloc_block. */
2518 obstack_init (&cu->comp_unit_obstack);
2520 cu->dies = read_comp_unit (info_ptr, abfd, cu);
2522 /* We try not to read any attributes in this function, because not
2523 all objfiles needed for references have been loaded yet, and symbol
2524 table processing isn't initialized. But we have to set the CU language,
2525 or we won't be able to build types correctly. */
2526 attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
2528 set_cu_language (DW_UNSND (attr), cu);
2530 set_cu_language (language_minimal, cu);
2532 do_cleanups (back_to);
2534 /* We've successfully allocated this compilation unit. Let our caller
2535 clean it up when finished with it. */
2536 discard_cleanups (free_cu_cleanup);
2541 /* Generate full symbol information for PST and CU, whose DIEs have
2542 already been loaded into memory. */
2545 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2547 struct partial_symtab *pst = per_cu->psymtab;
2548 struct dwarf2_cu *cu = per_cu->cu;
2549 struct objfile *objfile = pst->objfile;
2550 bfd *abfd = objfile->obfd;
2551 CORE_ADDR lowpc, highpc;
2552 struct symtab *symtab;
2553 struct cleanup *back_to;
2554 struct attribute *attr;
2557 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2559 /* We're in the global namespace. */
2560 processing_current_prefix = "";
2563 back_to = make_cleanup (really_free_pendings, NULL);
2565 cu->list_in_scope = &file_symbols;
2567 /* Find the base address of the compilation unit for range lists and
2568 location lists. It will normally be specified by DW_AT_low_pc.
2569 In DWARF-3 draft 4, the base address could be overridden by
2570 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2571 compilation units with discontinuous ranges. */
2573 cu->header.base_known = 0;
2574 cu->header.base_address = 0;
2576 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
2579 cu->header.base_address = DW_ADDR (attr);
2580 cu->header.base_known = 1;
2584 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
2587 cu->header.base_address = DW_ADDR (attr);
2588 cu->header.base_known = 1;
2592 /* Do line number decoding in read_file_scope () */
2593 process_die (cu->dies, cu);
2595 /* Some compilers don't define a DW_AT_high_pc attribute for the
2596 compilation unit. If the DW_AT_high_pc is missing, synthesize
2597 it, by scanning the DIE's below the compilation unit. */
2598 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
2600 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2602 /* Set symtab language to language from DW_AT_language.
2603 If the compilation is from a C file generated by language preprocessors,
2604 do not set the language if it was already deduced by start_subfile. */
2606 && !(cu->language == language_c && symtab->language != language_c))
2608 symtab->language = cu->language;
2610 pst->symtab = symtab;
2613 do_cleanups (back_to);
2616 /* Process a die and its children. */
2619 process_die (struct die_info *die, struct dwarf2_cu *cu)
2623 case DW_TAG_padding:
2625 case DW_TAG_compile_unit:
2626 read_file_scope (die, cu);
2628 case DW_TAG_subprogram:
2629 read_subroutine_type (die, cu);
2630 read_func_scope (die, cu);
2632 case DW_TAG_inlined_subroutine:
2633 /* FIXME: These are ignored for now.
2634 They could be used to set breakpoints on all inlined instances
2635 of a function and make GDB `next' properly over inlined functions. */
2637 case DW_TAG_lexical_block:
2638 case DW_TAG_try_block:
2639 case DW_TAG_catch_block:
2640 read_lexical_block_scope (die, cu);
2642 case DW_TAG_class_type:
2643 case DW_TAG_structure_type:
2644 case DW_TAG_union_type:
2645 read_structure_type (die, cu);
2646 process_structure_scope (die, cu);
2648 case DW_TAG_enumeration_type:
2649 read_enumeration_type (die, cu);
2650 process_enumeration_scope (die, cu);
2653 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2654 a symbol or process any children. Therefore it doesn't do anything
2655 that won't be done on-demand by read_type_die. */
2656 case DW_TAG_subroutine_type:
2657 read_subroutine_type (die, cu);
2659 case DW_TAG_array_type:
2660 read_array_type (die, cu);
2662 case DW_TAG_pointer_type:
2663 read_tag_pointer_type (die, cu);
2665 case DW_TAG_ptr_to_member_type:
2666 read_tag_ptr_to_member_type (die, cu);
2668 case DW_TAG_reference_type:
2669 read_tag_reference_type (die, cu);
2671 case DW_TAG_string_type:
2672 read_tag_string_type (die, cu);
2676 case DW_TAG_base_type:
2677 read_base_type (die, cu);
2678 /* Add a typedef symbol for the type definition, if it has a
2680 new_symbol (die, die->type, cu);
2682 case DW_TAG_subrange_type:
2683 read_subrange_type (die, cu);
2684 /* Add a typedef symbol for the type definition, if it has a
2686 new_symbol (die, die->type, cu);
2688 case DW_TAG_common_block:
2689 read_common_block (die, cu);
2691 case DW_TAG_common_inclusion:
2693 case DW_TAG_namespace:
2694 processing_has_namespace_info = 1;
2695 read_namespace (die, cu);
2697 case DW_TAG_imported_declaration:
2698 case DW_TAG_imported_module:
2699 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2700 information contained in these. DW_TAG_imported_declaration
2701 dies shouldn't have children; DW_TAG_imported_module dies
2702 shouldn't in the C++ case, but conceivably could in the
2703 Fortran case, so we'll have to replace this gdb_assert if
2704 Fortran compilers start generating that info. */
2705 processing_has_namespace_info = 1;
2706 gdb_assert (die->child == NULL);
2709 new_symbol (die, NULL, cu);
2715 initialize_cu_func_list (struct dwarf2_cu *cu)
2717 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2721 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2723 struct objfile *objfile = cu->objfile;
2724 struct comp_unit_head *cu_header = &cu->header;
2725 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2726 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2727 CORE_ADDR highpc = ((CORE_ADDR) 0);
2728 struct attribute *attr;
2729 char *name = "<unknown>";
2730 char *comp_dir = NULL;
2731 struct die_info *child_die;
2732 bfd *abfd = objfile->obfd;
2733 struct line_header *line_header = 0;
2736 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2738 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2740 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2741 from finish_block. */
2742 if (lowpc == ((CORE_ADDR) -1))
2747 attr = dwarf2_attr (die, DW_AT_name, cu);
2750 name = DW_STRING (attr);
2752 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2755 comp_dir = DW_STRING (attr);
2758 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2759 directory, get rid of it. */
2760 char *cp = strchr (comp_dir, ':');
2762 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2767 attr = dwarf2_attr (die, DW_AT_language, cu);
2770 set_cu_language (DW_UNSND (attr), cu);
2773 attr = dwarf2_attr (die, DW_AT_producer, cu);
2775 cu->producer = DW_STRING (attr);
2777 /* We assume that we're processing GCC output. */
2778 processing_gcc_compilation = 2;
2780 /* FIXME:Do something here. */
2781 if (dip->at_producer != NULL)
2783 handle_producer (dip->at_producer);
2787 /* The compilation unit may be in a different language or objfile,
2788 zero out all remembered fundamental types. */
2789 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2791 start_symtab (name, comp_dir, lowpc);
2792 record_debugformat ("DWARF 2");
2794 initialize_cu_func_list (cu);
2796 /* Process all dies in compilation unit. */
2797 if (die->child != NULL)
2799 child_die = die->child;
2800 while (child_die && child_die->tag)
2802 process_die (child_die, cu);
2803 child_die = sibling_die (child_die);
2807 /* Decode line number information if present. */
2808 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2811 unsigned int line_offset = DW_UNSND (attr);
2812 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2815 make_cleanup ((make_cleanup_ftype *) free_line_header,
2816 (void *) line_header);
2817 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2821 /* Decode macro information, if present. Dwarf 2 macro information
2822 refers to information in the line number info statement program
2823 header, so we can only read it if we've read the header
2825 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2826 if (attr && line_header)
2828 unsigned int macro_offset = DW_UNSND (attr);
2829 dwarf_decode_macros (line_header, macro_offset,
2830 comp_dir, abfd, cu);
2832 do_cleanups (back_to);
2836 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2837 struct dwarf2_cu *cu)
2839 struct function_range *thisfn;
2841 thisfn = (struct function_range *)
2842 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2843 thisfn->name = name;
2844 thisfn->lowpc = lowpc;
2845 thisfn->highpc = highpc;
2846 thisfn->seen_line = 0;
2847 thisfn->next = NULL;
2849 if (cu->last_fn == NULL)
2850 cu->first_fn = thisfn;
2852 cu->last_fn->next = thisfn;
2854 cu->last_fn = thisfn;
2858 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2860 struct objfile *objfile = cu->objfile;
2861 struct context_stack *new;
2864 struct die_info *child_die;
2865 struct attribute *attr;
2867 const char *previous_prefix = processing_current_prefix;
2868 struct cleanup *back_to = NULL;
2871 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2873 name = dwarf2_linkage_name (die, cu);
2875 /* Ignore functions with missing or empty names and functions with
2876 missing or invalid low and high pc attributes. */
2877 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2880 if (cu->language == language_cplus
2881 || cu->language == language_java)
2883 struct die_info *spec_die = die_specification (die, cu);
2885 /* NOTE: carlton/2004-01-23: We have to be careful in the
2886 presence of DW_AT_specification. For example, with GCC 3.4,
2891 // Definition of N::foo.
2895 then we'll have a tree of DIEs like this:
2897 1: DW_TAG_compile_unit
2898 2: DW_TAG_namespace // N
2899 3: DW_TAG_subprogram // declaration of N::foo
2900 4: DW_TAG_subprogram // definition of N::foo
2901 DW_AT_specification // refers to die #3
2903 Thus, when processing die #4, we have to pretend that we're
2904 in the context of its DW_AT_specification, namely the contex
2907 if (spec_die != NULL)
2909 char *specification_prefix = determine_prefix (spec_die, cu);
2910 processing_current_prefix = specification_prefix;
2911 back_to = make_cleanup (xfree, specification_prefix);
2918 /* Record the function range for dwarf_decode_lines. */
2919 add_to_cu_func_list (name, lowpc, highpc, cu);
2921 new = push_context (0, lowpc);
2922 new->name = new_symbol (die, die->type, cu);
2924 /* If there is a location expression for DW_AT_frame_base, record
2926 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2928 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2929 expression is being recorded directly in the function's symbol
2930 and not in a separate frame-base object. I guess this hack is
2931 to avoid adding some sort of frame-base adjunct/annex to the
2932 function's symbol :-(. The problem with doing this is that it
2933 results in a function symbol with a location expression that
2934 has nothing to do with the location of the function, ouch! The
2935 relationship should be: a function's symbol has-a frame base; a
2936 frame-base has-a location expression. */
2937 dwarf2_symbol_mark_computed (attr, new->name, cu);
2939 cu->list_in_scope = &local_symbols;
2941 if (die->child != NULL)
2943 child_die = die->child;
2944 while (child_die && child_die->tag)
2946 process_die (child_die, cu);
2947 child_die = sibling_die (child_die);
2951 new = pop_context ();
2952 /* Make a block for the local symbols within. */
2953 finish_block (new->name, &local_symbols, new->old_blocks,
2954 lowpc, highpc, objfile);
2956 /* In C++, we can have functions nested inside functions (e.g., when
2957 a function declares a class that has methods). This means that
2958 when we finish processing a function scope, we may need to go
2959 back to building a containing block's symbol lists. */
2960 local_symbols = new->locals;
2961 param_symbols = new->params;
2963 /* If we've finished processing a top-level function, subsequent
2964 symbols go in the file symbol list. */
2965 if (outermost_context_p ())
2966 cu->list_in_scope = &file_symbols;
2968 processing_current_prefix = previous_prefix;
2969 if (back_to != NULL)
2970 do_cleanups (back_to);
2973 /* Process all the DIES contained within a lexical block scope. Start
2974 a new scope, process the dies, and then close the scope. */
2977 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2979 struct objfile *objfile = cu->objfile;
2980 struct context_stack *new;
2981 CORE_ADDR lowpc, highpc;
2982 struct die_info *child_die;
2985 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2987 /* Ignore blocks with missing or invalid low and high pc attributes. */
2988 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2989 as multiple lexical blocks? Handling children in a sane way would
2990 be nasty. Might be easier to properly extend generic blocks to
2992 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2997 push_context (0, lowpc);
2998 if (die->child != NULL)
3000 child_die = die->child;
3001 while (child_die && child_die->tag)
3003 process_die (child_die, cu);
3004 child_die = sibling_die (child_die);
3007 new = pop_context ();
3009 if (local_symbols != NULL)
3011 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3014 local_symbols = new->locals;
3017 /* Get low and high pc attributes from a die. Return 1 if the attributes
3018 are present and valid, otherwise, return 0. Return -1 if the range is
3019 discontinuous, i.e. derived from DW_AT_ranges information. */
3021 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
3022 CORE_ADDR *highpc, struct dwarf2_cu *cu)
3024 struct objfile *objfile = cu->objfile;
3025 struct comp_unit_head *cu_header = &cu->header;
3026 struct attribute *attr;
3027 bfd *obfd = objfile->obfd;
3032 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
3035 high = DW_ADDR (attr);
3036 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3038 low = DW_ADDR (attr);
3040 /* Found high w/o low attribute. */
3043 /* Found consecutive range of addresses. */
3048 attr = dwarf2_attr (die, DW_AT_ranges, cu);
3051 unsigned int addr_size = cu_header->addr_size;
3052 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3053 /* Value of the DW_AT_ranges attribute is the offset in the
3054 .debug_ranges section. */
3055 unsigned int offset = DW_UNSND (attr);
3056 /* Base address selection entry. */
3064 found_base = cu_header->base_known;
3065 base = cu_header->base_address;
3067 if (offset >= dwarf2_per_objfile->ranges_size)
3069 complaint (&symfile_complaints,
3070 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3074 buffer = dwarf2_per_objfile->ranges_buffer + offset;
3076 /* Read in the largest possible address. */
3077 marker = read_address (obfd, buffer, cu, &dummy);
3078 if ((marker & mask) == mask)
3080 /* If we found the largest possible address, then
3081 read the base address. */
3082 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3083 buffer += 2 * addr_size;
3084 offset += 2 * addr_size;
3092 CORE_ADDR range_beginning, range_end;
3094 range_beginning = read_address (obfd, buffer, cu, &dummy);
3095 buffer += addr_size;
3096 range_end = read_address (obfd, buffer, cu, &dummy);
3097 buffer += addr_size;
3098 offset += 2 * addr_size;
3100 /* An end of list marker is a pair of zero addresses. */
3101 if (range_beginning == 0 && range_end == 0)
3102 /* Found the end of list entry. */
3105 /* Each base address selection entry is a pair of 2 values.
3106 The first is the largest possible address, the second is
3107 the base address. Check for a base address here. */
3108 if ((range_beginning & mask) == mask)
3110 /* If we found the largest possible address, then
3111 read the base address. */
3112 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3119 /* We have no valid base address for the ranges
3121 complaint (&symfile_complaints,
3122 _("Invalid .debug_ranges data (no base address)"));
3126 range_beginning += base;
3129 /* FIXME: This is recording everything as a low-high
3130 segment of consecutive addresses. We should have a
3131 data structure for discontiguous block ranges
3135 low = range_beginning;
3141 if (range_beginning < low)
3142 low = range_beginning;
3143 if (range_end > high)
3149 /* If the first entry is an end-of-list marker, the range
3150 describes an empty scope, i.e. no instructions. */
3160 /* When using the GNU linker, .gnu.linkonce. sections are used to
3161 eliminate duplicate copies of functions and vtables and such.
3162 The linker will arbitrarily choose one and discard the others.
3163 The AT_*_pc values for such functions refer to local labels in
3164 these sections. If the section from that file was discarded, the
3165 labels are not in the output, so the relocs get a value of 0.
3166 If this is a discarded function, mark the pc bounds as invalid,
3167 so that GDB will ignore it. */
3168 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
3176 /* Get the low and high pc's represented by the scope DIE, and store
3177 them in *LOWPC and *HIGHPC. If the correct values can't be
3178 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3181 get_scope_pc_bounds (struct die_info *die,
3182 CORE_ADDR *lowpc, CORE_ADDR *highpc,
3183 struct dwarf2_cu *cu)
3185 CORE_ADDR best_low = (CORE_ADDR) -1;
3186 CORE_ADDR best_high = (CORE_ADDR) 0;
3187 CORE_ADDR current_low, current_high;
3189 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
3191 best_low = current_low;
3192 best_high = current_high;
3196 struct die_info *child = die->child;
3198 while (child && child->tag)
3200 switch (child->tag) {
3201 case DW_TAG_subprogram:
3202 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
3204 best_low = min (best_low, current_low);
3205 best_high = max (best_high, current_high);
3208 case DW_TAG_namespace:
3209 /* FIXME: carlton/2004-01-16: Should we do this for
3210 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3211 that current GCC's always emit the DIEs corresponding
3212 to definitions of methods of classes as children of a
3213 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3214 the DIEs giving the declarations, which could be
3215 anywhere). But I don't see any reason why the
3216 standards says that they have to be there. */
3217 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
3219 if (current_low != ((CORE_ADDR) -1))
3221 best_low = min (best_low, current_low);
3222 best_high = max (best_high, current_high);
3230 child = sibling_die (child);
3235 *highpc = best_high;
3238 /* Add an aggregate field to the field list. */
3241 dwarf2_add_field (struct field_info *fip, struct die_info *die,
3242 struct dwarf2_cu *cu)
3244 struct objfile *objfile = cu->objfile;
3245 struct nextfield *new_field;
3246 struct attribute *attr;
3248 char *fieldname = "";
3250 /* Allocate a new field list entry and link it in. */
3251 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3252 make_cleanup (xfree, new_field);
3253 memset (new_field, 0, sizeof (struct nextfield));
3254 new_field->next = fip->fields;
3255 fip->fields = new_field;
3258 /* Handle accessibility and virtuality of field.
3259 The default accessibility for members is public, the default
3260 accessibility for inheritance is private. */
3261 if (die->tag != DW_TAG_inheritance)
3262 new_field->accessibility = DW_ACCESS_public;
3264 new_field->accessibility = DW_ACCESS_private;
3265 new_field->virtuality = DW_VIRTUALITY_none;
3267 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3269 new_field->accessibility = DW_UNSND (attr);
3270 if (new_field->accessibility != DW_ACCESS_public)
3271 fip->non_public_fields = 1;
3272 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
3274 new_field->virtuality = DW_UNSND (attr);
3276 fp = &new_field->field;
3278 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
3280 /* Data member other than a C++ static data member. */
3282 /* Get type of field. */
3283 fp->type = die_type (die, cu);
3285 FIELD_STATIC_KIND (*fp) = 0;
3287 /* Get bit size of field (zero if none). */
3288 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
3291 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
3295 FIELD_BITSIZE (*fp) = 0;
3298 /* Get bit offset of field. */
3299 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3302 FIELD_BITPOS (*fp) =
3303 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
3306 FIELD_BITPOS (*fp) = 0;
3307 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
3310 if (BITS_BIG_ENDIAN)
3312 /* For big endian bits, the DW_AT_bit_offset gives the
3313 additional bit offset from the MSB of the containing
3314 anonymous object to the MSB of the field. We don't
3315 have to do anything special since we don't need to
3316 know the size of the anonymous object. */
3317 FIELD_BITPOS (*fp) += DW_UNSND (attr);
3321 /* For little endian bits, compute the bit offset to the
3322 MSB of the anonymous object, subtract off the number of
3323 bits from the MSB of the field to the MSB of the
3324 object, and then subtract off the number of bits of
3325 the field itself. The result is the bit offset of
3326 the LSB of the field. */
3328 int bit_offset = DW_UNSND (attr);
3330 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3333 /* The size of the anonymous object containing
3334 the bit field is explicit, so use the
3335 indicated size (in bytes). */
3336 anonymous_size = DW_UNSND (attr);
3340 /* The size of the anonymous object containing
3341 the bit field must be inferred from the type
3342 attribute of the data member containing the
3344 anonymous_size = TYPE_LENGTH (fp->type);
3346 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
3347 - bit_offset - FIELD_BITSIZE (*fp);
3351 /* Get name of field. */
3352 attr = dwarf2_attr (die, DW_AT_name, cu);
3353 if (attr && DW_STRING (attr))
3354 fieldname = DW_STRING (attr);
3356 /* The name is already allocated along with this objfile, so we don't
3357 need to duplicate it for the type. */
3358 fp->name = fieldname;
3360 /* Change accessibility for artificial fields (e.g. virtual table
3361 pointer or virtual base class pointer) to private. */
3362 if (dwarf2_attr (die, DW_AT_artificial, cu))
3364 new_field->accessibility = DW_ACCESS_private;
3365 fip->non_public_fields = 1;
3368 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
3370 /* C++ static member. */
3372 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3373 is a declaration, but all versions of G++ as of this writing
3374 (so through at least 3.2.1) incorrectly generate
3375 DW_TAG_variable tags. */
3379 /* Get name of field. */
3380 attr = dwarf2_attr (die, DW_AT_name, cu);
3381 if (attr && DW_STRING (attr))
3382 fieldname = DW_STRING (attr);
3386 /* Get physical name. */
3387 physname = dwarf2_linkage_name (die, cu);
3389 /* The name is already allocated along with this objfile, so we don't
3390 need to duplicate it for the type. */
3391 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
3392 FIELD_TYPE (*fp) = die_type (die, cu);
3393 FIELD_NAME (*fp) = fieldname;
3395 else if (die->tag == DW_TAG_inheritance)
3397 /* C++ base class field. */
3398 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3400 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
3402 FIELD_BITSIZE (*fp) = 0;
3403 FIELD_STATIC_KIND (*fp) = 0;
3404 FIELD_TYPE (*fp) = die_type (die, cu);
3405 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
3406 fip->nbaseclasses++;
3410 /* Create the vector of fields, and attach it to the type. */
3413 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3414 struct dwarf2_cu *cu)
3416 int nfields = fip->nfields;
3418 /* Record the field count, allocate space for the array of fields,
3419 and create blank accessibility bitfields if necessary. */
3420 TYPE_NFIELDS (type) = nfields;
3421 TYPE_FIELDS (type) = (struct field *)
3422 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3423 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3425 if (fip->non_public_fields)
3427 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3429 TYPE_FIELD_PRIVATE_BITS (type) =
3430 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3431 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3433 TYPE_FIELD_PROTECTED_BITS (type) =
3434 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3435 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3437 TYPE_FIELD_IGNORE_BITS (type) =
3438 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3439 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3442 /* If the type has baseclasses, allocate and clear a bit vector for
3443 TYPE_FIELD_VIRTUAL_BITS. */
3444 if (fip->nbaseclasses)
3446 int num_bytes = B_BYTES (fip->nbaseclasses);
3447 unsigned char *pointer;
3449 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3450 pointer = TYPE_ALLOC (type, num_bytes);
3451 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
3452 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3453 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3456 /* Copy the saved-up fields into the field vector. Start from the head
3457 of the list, adding to the tail of the field array, so that they end
3458 up in the same order in the array in which they were added to the list. */
3459 while (nfields-- > 0)
3461 TYPE_FIELD (type, nfields) = fip->fields->field;
3462 switch (fip->fields->accessibility)
3464 case DW_ACCESS_private:
3465 SET_TYPE_FIELD_PRIVATE (type, nfields);
3468 case DW_ACCESS_protected:
3469 SET_TYPE_FIELD_PROTECTED (type, nfields);
3472 case DW_ACCESS_public:
3476 /* Unknown accessibility. Complain and treat it as public. */
3478 complaint (&symfile_complaints, _("unsupported accessibility %d"),
3479 fip->fields->accessibility);
3483 if (nfields < fip->nbaseclasses)
3485 switch (fip->fields->virtuality)
3487 case DW_VIRTUALITY_virtual:
3488 case DW_VIRTUALITY_pure_virtual:
3489 SET_TYPE_FIELD_VIRTUAL (type, nfields);
3493 fip->fields = fip->fields->next;
3497 /* Add a member function to the proper fieldlist. */
3500 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3501 struct type *type, struct dwarf2_cu *cu)
3503 struct objfile *objfile = cu->objfile;
3504 struct attribute *attr;
3505 struct fnfieldlist *flp;
3507 struct fn_field *fnp;
3510 struct nextfnfield *new_fnfield;
3512 /* Get name of member function. */
3513 attr = dwarf2_attr (die, DW_AT_name, cu);
3514 if (attr && DW_STRING (attr))
3515 fieldname = DW_STRING (attr);
3519 /* Get the mangled name. */
3520 physname = dwarf2_linkage_name (die, cu);
3522 /* Look up member function name in fieldlist. */
3523 for (i = 0; i < fip->nfnfields; i++)
3525 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3529 /* Create new list element if necessary. */
3530 if (i < fip->nfnfields)
3531 flp = &fip->fnfieldlists[i];
3534 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3536 fip->fnfieldlists = (struct fnfieldlist *)
3537 xrealloc (fip->fnfieldlists,
3538 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3539 * sizeof (struct fnfieldlist));
3540 if (fip->nfnfields == 0)
3541 make_cleanup (free_current_contents, &fip->fnfieldlists);
3543 flp = &fip->fnfieldlists[fip->nfnfields];
3544 flp->name = fieldname;
3550 /* Create a new member function field and chain it to the field list
3552 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3553 make_cleanup (xfree, new_fnfield);
3554 memset (new_fnfield, 0, sizeof (struct nextfnfield));
3555 new_fnfield->next = flp->head;
3556 flp->head = new_fnfield;
3559 /* Fill in the member function field info. */
3560 fnp = &new_fnfield->fnfield;
3561 /* The name is already allocated along with this objfile, so we don't
3562 need to duplicate it for the type. */
3563 fnp->physname = physname ? physname : "";
3564 fnp->type = alloc_type (objfile);
3565 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3567 int nparams = TYPE_NFIELDS (die->type);
3569 /* TYPE is the domain of this method, and DIE->TYPE is the type
3570 of the method itself (TYPE_CODE_METHOD). */
3571 smash_to_method_type (fnp->type, type,
3572 TYPE_TARGET_TYPE (die->type),
3573 TYPE_FIELDS (die->type),
3574 TYPE_NFIELDS (die->type),
3575 TYPE_VARARGS (die->type));
3577 /* Handle static member functions.
3578 Dwarf2 has no clean way to discern C++ static and non-static
3579 member functions. G++ helps GDB by marking the first
3580 parameter for non-static member functions (which is the
3581 this pointer) as artificial. We obtain this information
3582 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3583 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3584 fnp->voffset = VOFFSET_STATIC;
3587 complaint (&symfile_complaints, _("member function type missing for '%s'"),
3590 /* Get fcontext from DW_AT_containing_type if present. */
3591 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3592 fnp->fcontext = die_containing_type (die, cu);
3594 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3595 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3597 /* Get accessibility. */
3598 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3601 switch (DW_UNSND (attr))
3603 case DW_ACCESS_private:
3604 fnp->is_private = 1;
3606 case DW_ACCESS_protected:
3607 fnp->is_protected = 1;
3612 /* Check for artificial methods. */
3613 attr = dwarf2_attr (die, DW_AT_artificial, cu);
3614 if (attr && DW_UNSND (attr) != 0)
3615 fnp->is_artificial = 1;
3617 /* Get index in virtual function table if it is a virtual member function. */
3618 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3621 /* Support the .debug_loc offsets */
3622 if (attr_form_is_block (attr))
3624 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3626 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3628 dwarf2_complex_location_expr_complaint ();
3632 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3638 /* Create the vector of member function fields, and attach it to the type. */
3641 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3642 struct dwarf2_cu *cu)
3644 struct fnfieldlist *flp;
3645 int total_length = 0;
3648 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3649 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3650 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3652 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3654 struct nextfnfield *nfp = flp->head;
3655 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3658 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3659 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3660 fn_flp->fn_fields = (struct fn_field *)
3661 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3662 for (k = flp->length; (k--, nfp); nfp = nfp->next)
3663 fn_flp->fn_fields[k] = nfp->fnfield;
3665 total_length += flp->length;
3668 TYPE_NFN_FIELDS (type) = fip->nfnfields;
3669 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3673 /* Returns non-zero if NAME is the name of a vtable member in CU's
3674 language, zero otherwise. */
3676 is_vtable_name (const char *name, struct dwarf2_cu *cu)
3678 static const char vptr[] = "_vptr";
3679 static const char vtable[] = "vtable";
3681 /* Look for the C++ and Java forms of the vtable. */
3682 if ((cu->language == language_java
3683 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
3684 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
3685 && is_cplus_marker (name[sizeof (vptr) - 1])))
3692 /* Called when we find the DIE that starts a structure or union scope
3693 (definition) to process all dies that define the members of the
3696 NOTE: we need to call struct_type regardless of whether or not the
3697 DIE has an at_name attribute, since it might be an anonymous
3698 structure or union. This gets the type entered into our set of
3701 However, if the structure is incomplete (an opaque struct/union)
3702 then suppress creating a symbol table entry for it since gdb only
3703 wants to find the one with the complete definition. Note that if
3704 it is complete, we just call new_symbol, which does it's own
3705 checking about whether the struct/union is anonymous or not (and
3706 suppresses creating a symbol table entry itself). */
3709 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3711 struct objfile *objfile = cu->objfile;
3713 struct attribute *attr;
3714 const char *previous_prefix = processing_current_prefix;
3715 struct cleanup *back_to = NULL;
3720 type = alloc_type (objfile);
3722 INIT_CPLUS_SPECIFIC (type);
3723 attr = dwarf2_attr (die, DW_AT_name, cu);
3724 if (attr && DW_STRING (attr))
3726 if (cu->language == language_cplus
3727 || cu->language == language_java)
3729 char *new_prefix = determine_class_name (die, cu);
3730 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3731 strlen (new_prefix),
3732 &objfile->objfile_obstack);
3733 back_to = make_cleanup (xfree, new_prefix);
3734 processing_current_prefix = new_prefix;
3738 /* The name is already allocated along with this objfile, so
3739 we don't need to duplicate it for the type. */
3740 TYPE_TAG_NAME (type) = DW_STRING (attr);
3744 if (die->tag == DW_TAG_structure_type)
3746 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3748 else if (die->tag == DW_TAG_union_type)
3750 TYPE_CODE (type) = TYPE_CODE_UNION;
3754 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3756 TYPE_CODE (type) = TYPE_CODE_CLASS;
3759 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3762 TYPE_LENGTH (type) = DW_UNSND (attr);
3766 TYPE_LENGTH (type) = 0;
3769 if (die_is_declaration (die, cu))
3770 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3772 /* We need to add the type field to the die immediately so we don't
3773 infinitely recurse when dealing with pointers to the structure
3774 type within the structure itself. */
3775 set_die_type (die, type, cu);
3777 if (die->child != NULL && ! die_is_declaration (die, cu))
3779 struct field_info fi;
3780 struct die_info *child_die;
3781 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3783 memset (&fi, 0, sizeof (struct field_info));
3785 child_die = die->child;
3787 while (child_die && child_die->tag)
3789 if (child_die->tag == DW_TAG_member
3790 || child_die->tag == DW_TAG_variable)
3792 /* NOTE: carlton/2002-11-05: A C++ static data member
3793 should be a DW_TAG_member that is a declaration, but
3794 all versions of G++ as of this writing (so through at
3795 least 3.2.1) incorrectly generate DW_TAG_variable
3796 tags for them instead. */
3797 dwarf2_add_field (&fi, child_die, cu);
3799 else if (child_die->tag == DW_TAG_subprogram)
3801 /* C++ member function. */
3802 read_type_die (child_die, cu);
3803 dwarf2_add_member_fn (&fi, child_die, type, cu);
3805 else if (child_die->tag == DW_TAG_inheritance)
3807 /* C++ base class field. */
3808 dwarf2_add_field (&fi, child_die, cu);
3810 child_die = sibling_die (child_die);
3813 /* Attach fields and member functions to the type. */
3815 dwarf2_attach_fields_to_type (&fi, type, cu);
3818 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3820 /* Get the type which refers to the base class (possibly this
3821 class itself) which contains the vtable pointer for the current
3822 class from the DW_AT_containing_type attribute. */
3824 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3826 struct type *t = die_containing_type (die, cu);
3828 TYPE_VPTR_BASETYPE (type) = t;
3833 /* Our own class provides vtbl ptr. */
3834 for (i = TYPE_NFIELDS (t) - 1;
3835 i >= TYPE_N_BASECLASSES (t);
3838 char *fieldname = TYPE_FIELD_NAME (t, i);
3840 if (is_vtable_name (fieldname, cu))
3842 TYPE_VPTR_FIELDNO (type) = i;
3847 /* Complain if virtual function table field not found. */
3848 if (i < TYPE_N_BASECLASSES (t))
3849 complaint (&symfile_complaints,
3850 _("virtual function table pointer not found when defining class '%s'"),
3851 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3856 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3859 else if (cu->producer
3860 && strncmp (cu->producer,
3861 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3863 /* The IBM XLC compiler does not provide direct indication
3864 of the containing type, but the vtable pointer is
3865 always named __vfp. */
3869 for (i = TYPE_NFIELDS (type) - 1;
3870 i >= TYPE_N_BASECLASSES (type);
3873 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
3875 TYPE_VPTR_FIELDNO (type) = i;
3876 TYPE_VPTR_BASETYPE (type) = type;
3883 do_cleanups (back_to);
3886 processing_current_prefix = previous_prefix;
3887 if (back_to != NULL)
3888 do_cleanups (back_to);
3892 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3894 struct objfile *objfile = cu->objfile;
3895 const char *previous_prefix = processing_current_prefix;
3896 struct die_info *child_die = die->child;
3898 if (TYPE_TAG_NAME (die->type) != NULL)
3899 processing_current_prefix = TYPE_TAG_NAME (die->type);
3901 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3902 snapshots) has been known to create a die giving a declaration
3903 for a class that has, as a child, a die giving a definition for a
3904 nested class. So we have to process our children even if the
3905 current die is a declaration. Normally, of course, a declaration
3906 won't have any children at all. */
3908 while (child_die != NULL && child_die->tag)
3910 if (child_die->tag == DW_TAG_member
3911 || child_die->tag == DW_TAG_variable
3912 || child_die->tag == DW_TAG_inheritance)
3917 process_die (child_die, cu);
3919 child_die = sibling_die (child_die);
3922 if (die->child != NULL && ! die_is_declaration (die, cu))
3923 new_symbol (die, die->type, cu);
3925 processing_current_prefix = previous_prefix;
3928 /* Given a DW_AT_enumeration_type die, set its type. We do not
3929 complete the type's fields yet, or create any symbols. */
3932 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
3934 struct objfile *objfile = cu->objfile;
3936 struct attribute *attr;
3941 type = alloc_type (objfile);
3943 TYPE_CODE (type) = TYPE_CODE_ENUM;
3944 attr = dwarf2_attr (die, DW_AT_name, cu);
3945 if (attr && DW_STRING (attr))
3947 char *name = DW_STRING (attr);
3949 if (processing_has_namespace_info)
3951 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
3952 processing_current_prefix,
3957 /* The name is already allocated along with this objfile, so
3958 we don't need to duplicate it for the type. */
3959 TYPE_TAG_NAME (type) = name;
3963 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3966 TYPE_LENGTH (type) = DW_UNSND (attr);
3970 TYPE_LENGTH (type) = 0;
3973 set_die_type (die, type, cu);
3976 /* Determine the name of the type represented by DIE, which should be
3977 a named C++ or Java compound type. Return the name in question; the caller
3978 is responsible for xfree()'ing it. */
3981 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
3983 struct cleanup *back_to = NULL;
3984 struct die_info *spec_die = die_specification (die, cu);
3985 char *new_prefix = NULL;
3987 /* If this is the definition of a class that is declared by another
3988 die, then processing_current_prefix may not be accurate; see
3989 read_func_scope for a similar example. */
3990 if (spec_die != NULL)
3992 char *specification_prefix = determine_prefix (spec_die, cu);
3993 processing_current_prefix = specification_prefix;
3994 back_to = make_cleanup (xfree, specification_prefix);
3997 /* If we don't have namespace debug info, guess the name by trying
3998 to demangle the names of members, just like we did in
3999 guess_structure_name. */
4000 if (!processing_has_namespace_info)
4002 struct die_info *child;
4004 for (child = die->child;
4005 child != NULL && child->tag != 0;
4006 child = sibling_die (child))
4008 if (child->tag == DW_TAG_subprogram)
4011 = language_class_name_from_physname (cu->language_defn,
4015 if (new_prefix != NULL)
4021 if (new_prefix == NULL)
4023 const char *name = dwarf2_name (die, cu);
4024 new_prefix = typename_concat (NULL, processing_current_prefix,
4025 name ? name : "<<anonymous>>",
4029 if (back_to != NULL)
4030 do_cleanups (back_to);
4035 /* Given a pointer to a die which begins an enumeration, process all
4036 the dies that define the members of the enumeration, and create the
4037 symbol for the enumeration type.
4039 NOTE: We reverse the order of the element list. */
4042 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4044 struct objfile *objfile = cu->objfile;
4045 struct die_info *child_die;
4046 struct field *fields;
4047 struct attribute *attr;
4050 int unsigned_enum = 1;
4054 if (die->child != NULL)
4056 child_die = die->child;
4057 while (child_die && child_die->tag)
4059 if (child_die->tag != DW_TAG_enumerator)
4061 process_die (child_die, cu);
4065 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4068 sym = new_symbol (child_die, die->type, cu);
4069 if (SYMBOL_VALUE (sym) < 0)
4072 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4074 fields = (struct field *)
4076 (num_fields + DW_FIELD_ALLOC_CHUNK)
4077 * sizeof (struct field));
4080 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4081 FIELD_TYPE (fields[num_fields]) = NULL;
4082 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4083 FIELD_BITSIZE (fields[num_fields]) = 0;
4084 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4090 child_die = sibling_die (child_die);
4095 TYPE_NFIELDS (die->type) = num_fields;
4096 TYPE_FIELDS (die->type) = (struct field *)
4097 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4098 memcpy (TYPE_FIELDS (die->type), fields,
4099 sizeof (struct field) * num_fields);
4103 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4106 new_symbol (die, die->type, cu);
4109 /* Extract all information from a DW_TAG_array_type DIE and put it in
4110 the DIE's type field. For now, this only handles one dimensional
4114 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4116 struct objfile *objfile = cu->objfile;
4117 struct die_info *child_die;
4118 struct type *type = NULL;
4119 struct type *element_type, *range_type, *index_type;
4120 struct type **range_types = NULL;
4121 struct attribute *attr;
4123 struct cleanup *back_to;
4125 /* Return if we've already decoded this type. */
4131 element_type = die_type (die, cu);
4133 /* Irix 6.2 native cc creates array types without children for
4134 arrays with unspecified length. */
4135 if (die->child == NULL)
4137 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4138 range_type = create_range_type (NULL, index_type, 0, -1);
4139 set_die_type (die, create_array_type (NULL, element_type, range_type),
4144 back_to = make_cleanup (null_cleanup, NULL);
4145 child_die = die->child;
4146 while (child_die && child_die->tag)
4148 if (child_die->tag == DW_TAG_subrange_type)
4150 read_subrange_type (child_die, cu);
4152 if (child_die->type != NULL)
4154 /* The range type was succesfully read. Save it for
4155 the array type creation. */
4156 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4158 range_types = (struct type **)
4159 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4160 * sizeof (struct type *));
4162 make_cleanup (free_current_contents, &range_types);
4164 range_types[ndim++] = child_die->type;
4167 child_die = sibling_die (child_die);
4170 /* Dwarf2 dimensions are output from left to right, create the
4171 necessary array types in backwards order. */
4173 type = element_type;
4175 if (read_array_order (die, cu) == DW_ORD_col_major)
4179 type = create_array_type (NULL, type, range_types[i++]);
4184 type = create_array_type (NULL, type, range_types[ndim]);
4187 /* Understand Dwarf2 support for vector types (like they occur on
4188 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4189 array type. This is not part of the Dwarf2/3 standard yet, but a
4190 custom vendor extension. The main difference between a regular
4191 array and the vector variant is that vectors are passed by value
4193 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4195 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4197 do_cleanups (back_to);
4199 /* Install the type in the die. */
4200 set_die_type (die, type, cu);
4203 static enum dwarf_array_dim_ordering
4204 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4206 struct attribute *attr;
4208 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4210 if (attr) return DW_SND (attr);
4213 GNU F77 is a special case, as at 08/2004 array type info is the
4214 opposite order to the dwarf2 specification, but data is still
4215 laid out as per normal fortran.
4217 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4221 if (cu->language == language_fortran &&
4222 cu->producer && strstr (cu->producer, "GNU F77"))
4224 return DW_ORD_row_major;
4227 switch (cu->language_defn->la_array_ordering)
4229 case array_column_major:
4230 return DW_ORD_col_major;
4231 case array_row_major:
4233 return DW_ORD_row_major;
4238 /* First cut: install each common block member as a global variable. */
4241 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4243 struct die_info *child_die;
4244 struct attribute *attr;
4246 CORE_ADDR base = (CORE_ADDR) 0;
4248 attr = dwarf2_attr (die, DW_AT_location, cu);
4251 /* Support the .debug_loc offsets */
4252 if (attr_form_is_block (attr))
4254 base = decode_locdesc (DW_BLOCK (attr), cu);
4256 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4258 dwarf2_complex_location_expr_complaint ();
4262 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4263 "common block member");
4266 if (die->child != NULL)
4268 child_die = die->child;
4269 while (child_die && child_die->tag)
4271 sym = new_symbol (child_die, NULL, cu);
4272 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4275 SYMBOL_VALUE_ADDRESS (sym) =
4276 base + decode_locdesc (DW_BLOCK (attr), cu);
4277 add_symbol_to_list (sym, &global_symbols);
4279 child_die = sibling_die (child_die);
4284 /* Read a C++ namespace. */
4287 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4289 struct objfile *objfile = cu->objfile;
4290 const char *previous_prefix = processing_current_prefix;
4293 struct die_info *current_die;
4294 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4296 name = namespace_name (die, &is_anonymous, cu);
4298 /* Now build the name of the current namespace. */
4300 if (previous_prefix[0] == '\0')
4302 processing_current_prefix = name;
4306 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4307 make_cleanup (xfree, temp_name);
4308 processing_current_prefix = temp_name;
4311 /* Add a symbol associated to this if we haven't seen the namespace
4312 before. Also, add a using directive if it's an anonymous
4315 if (dwarf2_extension (die, cu) == NULL)
4319 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4320 this cast will hopefully become unnecessary. */
4321 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4322 (char *) processing_current_prefix,
4324 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4326 new_symbol (die, type, cu);
4327 set_die_type (die, type, cu);
4330 cp_add_using_directive (processing_current_prefix,
4331 strlen (previous_prefix),
4332 strlen (processing_current_prefix));
4335 if (die->child != NULL)
4337 struct die_info *child_die = die->child;
4339 while (child_die && child_die->tag)
4341 process_die (child_die, cu);
4342 child_die = sibling_die (child_die);
4346 processing_current_prefix = previous_prefix;
4347 do_cleanups (back_to);
4350 /* Return the name of the namespace represented by DIE. Set
4351 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4355 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4357 struct die_info *current_die;
4358 const char *name = NULL;
4360 /* Loop through the extensions until we find a name. */
4362 for (current_die = die;
4363 current_die != NULL;
4364 current_die = dwarf2_extension (die, cu))
4366 name = dwarf2_name (current_die, cu);
4371 /* Is it an anonymous namespace? */
4373 *is_anonymous = (name == NULL);
4375 name = "(anonymous namespace)";
4380 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4381 the user defined type vector. */
4384 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4386 struct comp_unit_head *cu_header = &cu->header;
4388 struct attribute *attr_byte_size;
4389 struct attribute *attr_address_class;
4390 int byte_size, addr_class;
4397 type = lookup_pointer_type (die_type (die, cu));
4399 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4401 byte_size = DW_UNSND (attr_byte_size);
4403 byte_size = cu_header->addr_size;
4405 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4406 if (attr_address_class)
4407 addr_class = DW_UNSND (attr_address_class);
4409 addr_class = DW_ADDR_none;
4411 /* If the pointer size or address class is different than the
4412 default, create a type variant marked as such and set the
4413 length accordingly. */
4414 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4416 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4420 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
4421 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4422 type = make_type_with_address_space (type, type_flags);
4424 else if (TYPE_LENGTH (type) != byte_size)
4426 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4429 /* Should we also complain about unhandled address classes? */
4433 TYPE_LENGTH (type) = byte_size;
4434 set_die_type (die, type, cu);
4437 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4438 the user defined type vector. */
4441 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4443 struct objfile *objfile = cu->objfile;
4445 struct type *to_type;
4446 struct type *domain;
4453 type = alloc_type (objfile);
4454 to_type = die_type (die, cu);
4455 domain = die_containing_type (die, cu);
4456 smash_to_member_type (type, domain, to_type);
4458 set_die_type (die, type, cu);
4461 /* Extract all information from a DW_TAG_reference_type DIE and add to
4462 the user defined type vector. */
4465 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4467 struct comp_unit_head *cu_header = &cu->header;
4469 struct attribute *attr;
4476 type = lookup_reference_type (die_type (die, cu));
4477 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4480 TYPE_LENGTH (type) = DW_UNSND (attr);
4484 TYPE_LENGTH (type) = cu_header->addr_size;
4486 set_die_type (die, type, cu);
4490 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4492 struct type *base_type;
4499 base_type = die_type (die, cu);
4500 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4505 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4507 struct type *base_type;
4514 base_type = die_type (die, cu);
4515 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4519 /* Extract all information from a DW_TAG_string_type DIE and add to
4520 the user defined type vector. It isn't really a user defined type,
4521 but it behaves like one, with other DIE's using an AT_user_def_type
4522 attribute to reference it. */
4525 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4527 struct objfile *objfile = cu->objfile;
4528 struct type *type, *range_type, *index_type, *char_type;
4529 struct attribute *attr;
4530 unsigned int length;
4537 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4540 length = DW_UNSND (attr);
4544 /* check for the DW_AT_byte_size attribute */
4545 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4548 length = DW_UNSND (attr);
4555 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4556 range_type = create_range_type (NULL, index_type, 1, length);
4557 if (cu->language == language_fortran)
4559 /* Need to create a unique string type for bounds
4561 type = create_string_type (0, range_type);
4565 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4566 type = create_string_type (char_type, range_type);
4568 set_die_type (die, type, cu);
4571 /* Handle DIES due to C code like:
4575 int (*funcp)(int a, long l);
4579 ('funcp' generates a DW_TAG_subroutine_type DIE)
4583 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4585 struct type *type; /* Type that this function returns */
4586 struct type *ftype; /* Function that returns above type */
4587 struct attribute *attr;
4589 /* Decode the type that this subroutine returns */
4594 type = die_type (die, cu);
4595 ftype = make_function_type (type, (struct type **) 0);
4597 /* All functions in C++ and Java have prototypes. */
4598 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4599 if ((attr && (DW_UNSND (attr) != 0))
4600 || cu->language == language_cplus
4601 || cu->language == language_java)
4602 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4604 if (die->child != NULL)
4606 struct die_info *child_die;
4610 /* Count the number of parameters.
4611 FIXME: GDB currently ignores vararg functions, but knows about
4612 vararg member functions. */
4613 child_die = die->child;
4614 while (child_die && child_die->tag)
4616 if (child_die->tag == DW_TAG_formal_parameter)
4618 else if (child_die->tag == DW_TAG_unspecified_parameters)
4619 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4620 child_die = sibling_die (child_die);
4623 /* Allocate storage for parameters and fill them in. */
4624 TYPE_NFIELDS (ftype) = nparams;
4625 TYPE_FIELDS (ftype) = (struct field *)
4626 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4628 child_die = die->child;
4629 while (child_die && child_die->tag)
4631 if (child_die->tag == DW_TAG_formal_parameter)
4633 /* Dwarf2 has no clean way to discern C++ static and non-static
4634 member functions. G++ helps GDB by marking the first
4635 parameter for non-static member functions (which is the
4636 this pointer) as artificial. We pass this information
4637 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4638 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4640 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4642 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4643 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4646 child_die = sibling_die (child_die);
4650 set_die_type (die, ftype, cu);
4654 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4656 struct objfile *objfile = cu->objfile;
4657 struct attribute *attr;
4662 attr = dwarf2_attr (die, DW_AT_name, cu);
4663 if (attr && DW_STRING (attr))
4665 name = DW_STRING (attr);
4667 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4668 TYPE_FLAG_TARGET_STUB, name, objfile),
4670 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4674 /* Find a representation of a given base type and install
4675 it in the TYPE field of the die. */
4678 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4680 struct objfile *objfile = cu->objfile;
4682 struct attribute *attr;
4683 int encoding = 0, size = 0;
4685 /* If we've already decoded this die, this is a no-op. */
4691 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4694 encoding = DW_UNSND (attr);
4696 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4699 size = DW_UNSND (attr);
4701 attr = dwarf2_attr (die, DW_AT_name, cu);
4702 if (attr && DW_STRING (attr))
4704 enum type_code code = TYPE_CODE_INT;
4709 case DW_ATE_address:
4710 /* Turn DW_ATE_address into a void * pointer. */
4711 code = TYPE_CODE_PTR;
4712 type_flags |= TYPE_FLAG_UNSIGNED;
4714 case DW_ATE_boolean:
4715 code = TYPE_CODE_BOOL;
4716 type_flags |= TYPE_FLAG_UNSIGNED;
4718 case DW_ATE_complex_float:
4719 code = TYPE_CODE_COMPLEX;
4722 code = TYPE_CODE_FLT;
4725 case DW_ATE_signed_char:
4727 case DW_ATE_unsigned:
4728 case DW_ATE_unsigned_char:
4729 type_flags |= TYPE_FLAG_UNSIGNED;
4732 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4733 dwarf_type_encoding_name (encoding));
4736 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4737 if (encoding == DW_ATE_address)
4738 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4740 else if (encoding == DW_ATE_complex_float)
4743 TYPE_TARGET_TYPE (type)
4744 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4745 else if (size == 16)
4746 TYPE_TARGET_TYPE (type)
4747 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4749 TYPE_TARGET_TYPE (type)
4750 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4755 type = dwarf_base_type (encoding, size, cu);
4757 set_die_type (die, type, cu);
4760 /* Read the given DW_AT_subrange DIE. */
4763 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4765 struct type *base_type;
4766 struct type *range_type;
4767 struct attribute *attr;
4771 /* If we have already decoded this die, then nothing more to do. */
4775 base_type = die_type (die, cu);
4776 if (base_type == NULL)
4778 complaint (&symfile_complaints,
4779 _("DW_AT_type missing from DW_TAG_subrange_type"));
4783 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4784 base_type = alloc_type (NULL);
4786 if (cu->language == language_fortran)
4788 /* FORTRAN implies a lower bound of 1, if not given. */
4792 /* FIXME: For variable sized arrays either of these could be
4793 a variable rather than a constant value. We'll allow it,
4794 but we don't know how to handle it. */
4795 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4797 low = dwarf2_get_attr_constant_value (attr, 0);
4799 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4802 if (attr->form == DW_FORM_block1)
4804 /* GCC encodes arrays with unspecified or dynamic length
4805 with a DW_FORM_block1 attribute.
4806 FIXME: GDB does not yet know how to handle dynamic
4807 arrays properly, treat them as arrays with unspecified
4810 FIXME: jimb/2003-09-22: GDB does not really know
4811 how to handle arrays of unspecified length
4812 either; we just represent them as zero-length
4813 arrays. Choose an appropriate upper bound given
4814 the lower bound we've computed above. */
4818 high = dwarf2_get_attr_constant_value (attr, 1);
4821 range_type = create_range_type (NULL, base_type, low, high);
4823 attr = dwarf2_attr (die, DW_AT_name, cu);
4824 if (attr && DW_STRING (attr))
4825 TYPE_NAME (range_type) = DW_STRING (attr);
4827 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4829 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4831 set_die_type (die, range_type, cu);
4835 /* Read a whole compilation unit into a linked list of dies. */
4837 static struct die_info *
4838 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4840 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4843 /* Read a single die and all its descendents. Set the die's sibling
4844 field to NULL; set other fields in the die correctly, and set all
4845 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4846 location of the info_ptr after reading all of those dies. PARENT
4847 is the parent of the die in question. */
4849 static struct die_info *
4850 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
4851 struct dwarf2_cu *cu,
4852 gdb_byte **new_info_ptr,
4853 struct die_info *parent)
4855 struct die_info *die;
4859 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4860 store_in_ref_table (die->offset, die, cu);
4864 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4870 *new_info_ptr = cur_ptr;
4873 die->sibling = NULL;
4874 die->parent = parent;
4878 /* Read a die, all of its descendents, and all of its siblings; set
4879 all of the fields of all of the dies correctly. Arguments are as
4880 in read_die_and_children. */
4882 static struct die_info *
4883 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
4884 struct dwarf2_cu *cu,
4885 gdb_byte **new_info_ptr,
4886 struct die_info *parent)
4888 struct die_info *first_die, *last_sibling;
4892 first_die = last_sibling = NULL;
4896 struct die_info *die
4897 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
4905 last_sibling->sibling = die;
4910 *new_info_ptr = cur_ptr;
4920 /* Free a linked list of dies. */
4923 free_die_list (struct die_info *dies)
4925 struct die_info *die, *next;
4930 if (die->child != NULL)
4931 free_die_list (die->child);
4932 next = die->sibling;
4939 /* Read the contents of the section at OFFSET and of size SIZE from the
4940 object file specified by OBJFILE into the objfile_obstack and return it. */
4943 dwarf2_read_section (struct objfile *objfile, asection *sectp)
4945 bfd *abfd = objfile->obfd;
4946 gdb_byte *buf, *retbuf;
4947 bfd_size_type size = bfd_get_section_size (sectp);
4952 buf = obstack_alloc (&objfile->objfile_obstack, size);
4953 retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
4957 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
4958 || bfd_bread (buf, size, abfd) != size)
4959 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4960 bfd_get_filename (abfd));
4965 /* In DWARF version 2, the description of the debugging information is
4966 stored in a separate .debug_abbrev section. Before we read any
4967 dies from a section we read in all abbreviations and install them
4968 in a hash table. This function also sets flags in CU describing
4969 the data found in the abbrev table. */
4972 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
4974 struct comp_unit_head *cu_header = &cu->header;
4975 gdb_byte *abbrev_ptr;
4976 struct abbrev_info *cur_abbrev;
4977 unsigned int abbrev_number, bytes_read, abbrev_name;
4978 unsigned int abbrev_form, hash_number;
4979 struct attr_abbrev *cur_attrs;
4980 unsigned int allocated_attrs;
4982 /* Initialize dwarf2 abbrevs */
4983 obstack_init (&cu->abbrev_obstack);
4984 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
4986 * sizeof (struct abbrev_info *)));
4987 memset (cu->dwarf2_abbrevs, 0,
4988 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
4990 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
4991 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4992 abbrev_ptr += bytes_read;
4994 allocated_attrs = ATTR_ALLOC_CHUNK;
4995 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
4997 /* loop until we reach an abbrev number of 0 */
4998 while (abbrev_number)
5000 cur_abbrev = dwarf_alloc_abbrev (cu);
5002 /* read in abbrev header */
5003 cur_abbrev->number = abbrev_number;
5004 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5005 abbrev_ptr += bytes_read;
5006 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5009 if (cur_abbrev->tag == DW_TAG_namespace)
5010 cu->has_namespace_info = 1;
5012 /* now read in declarations */
5013 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5014 abbrev_ptr += bytes_read;
5015 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5016 abbrev_ptr += bytes_read;
5019 if (cur_abbrev->num_attrs == allocated_attrs)
5021 allocated_attrs += ATTR_ALLOC_CHUNK;
5023 = xrealloc (cur_attrs, (allocated_attrs
5024 * sizeof (struct attr_abbrev)));
5027 /* Record whether this compilation unit might have
5028 inter-compilation-unit references. If we don't know what form
5029 this attribute will have, then it might potentially be a
5030 DW_FORM_ref_addr, so we conservatively expect inter-CU
5033 if (abbrev_form == DW_FORM_ref_addr
5034 || abbrev_form == DW_FORM_indirect)
5035 cu->has_form_ref_addr = 1;
5037 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5038 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5039 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5040 abbrev_ptr += bytes_read;
5041 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5042 abbrev_ptr += bytes_read;
5045 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5046 (cur_abbrev->num_attrs
5047 * sizeof (struct attr_abbrev)));
5048 memcpy (cur_abbrev->attrs, cur_attrs,
5049 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5051 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5052 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5053 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5055 /* Get next abbreviation.
5056 Under Irix6 the abbreviations for a compilation unit are not
5057 always properly terminated with an abbrev number of 0.
5058 Exit loop if we encounter an abbreviation which we have
5059 already read (which means we are about to read the abbreviations
5060 for the next compile unit) or if the end of the abbreviation
5061 table is reached. */
5062 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5063 >= dwarf2_per_objfile->abbrev_size)
5065 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5066 abbrev_ptr += bytes_read;
5067 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5074 /* Release the memory used by the abbrev table for a compilation unit. */
5077 dwarf2_free_abbrev_table (void *ptr_to_cu)
5079 struct dwarf2_cu *cu = ptr_to_cu;
5081 obstack_free (&cu->abbrev_obstack, NULL);
5082 cu->dwarf2_abbrevs = NULL;
5085 /* Lookup an abbrev_info structure in the abbrev hash table. */
5087 static struct abbrev_info *
5088 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5090 unsigned int hash_number;
5091 struct abbrev_info *abbrev;
5093 hash_number = number % ABBREV_HASH_SIZE;
5094 abbrev = cu->dwarf2_abbrevs[hash_number];
5098 if (abbrev->number == number)
5101 abbrev = abbrev->next;
5106 /* Returns nonzero if TAG represents a type that we might generate a partial
5110 is_type_tag_for_partial (int tag)
5115 /* Some types that would be reasonable to generate partial symbols for,
5116 that we don't at present. */
5117 case DW_TAG_array_type:
5118 case DW_TAG_file_type:
5119 case DW_TAG_ptr_to_member_type:
5120 case DW_TAG_set_type:
5121 case DW_TAG_string_type:
5122 case DW_TAG_subroutine_type:
5124 case DW_TAG_base_type:
5125 case DW_TAG_class_type:
5126 case DW_TAG_enumeration_type:
5127 case DW_TAG_structure_type:
5128 case DW_TAG_subrange_type:
5129 case DW_TAG_typedef:
5130 case DW_TAG_union_type:
5137 /* Load all DIEs that are interesting for partial symbols into memory. */
5139 static struct partial_die_info *
5140 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5141 struct dwarf2_cu *cu)
5143 struct partial_die_info *part_die;
5144 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5145 struct abbrev_info *abbrev;
5146 unsigned int bytes_read;
5148 int nesting_level = 1;
5154 = htab_create_alloc_ex (cu->header.length / 12,
5158 &cu->comp_unit_obstack,
5159 hashtab_obstack_allocate,
5160 dummy_obstack_deallocate);
5162 part_die = obstack_alloc (&cu->comp_unit_obstack,
5163 sizeof (struct partial_die_info));
5167 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5169 /* A NULL abbrev means the end of a series of children. */
5172 if (--nesting_level == 0)
5174 /* PART_DIE was probably the last thing allocated on the
5175 comp_unit_obstack, so we could call obstack_free
5176 here. We don't do that because the waste is small,
5177 and will be cleaned up when we're done with this
5178 compilation unit. This way, we're also more robust
5179 against other users of the comp_unit_obstack. */
5182 info_ptr += bytes_read;
5183 last_die = parent_die;
5184 parent_die = parent_die->die_parent;
5188 /* Check whether this DIE is interesting enough to save. */
5189 if (!is_type_tag_for_partial (abbrev->tag)
5190 && abbrev->tag != DW_TAG_enumerator
5191 && abbrev->tag != DW_TAG_subprogram
5192 && abbrev->tag != DW_TAG_variable
5193 && abbrev->tag != DW_TAG_namespace)
5195 /* Otherwise we skip to the next sibling, if any. */
5196 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5200 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5201 abfd, info_ptr, cu);
5203 /* This two-pass algorithm for processing partial symbols has a
5204 high cost in cache pressure. Thus, handle some simple cases
5205 here which cover the majority of C partial symbols. DIEs
5206 which neither have specification tags in them, nor could have
5207 specification tags elsewhere pointing at them, can simply be
5208 processed and discarded.
5210 This segment is also optional; scan_partial_symbols and
5211 add_partial_symbol will handle these DIEs if we chain
5212 them in normally. When compilers which do not emit large
5213 quantities of duplicate debug information are more common,
5214 this code can probably be removed. */
5216 /* Any complete simple types at the top level (pretty much all
5217 of them, for a language without namespaces), can be processed
5219 if (parent_die == NULL
5220 && part_die->has_specification == 0
5221 && part_die->is_declaration == 0
5222 && (part_die->tag == DW_TAG_typedef
5223 || part_die->tag == DW_TAG_base_type
5224 || part_die->tag == DW_TAG_subrange_type))
5226 if (building_psymtab && part_die->name != NULL)
5227 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5228 VAR_DOMAIN, LOC_TYPEDEF,
5229 &cu->objfile->static_psymbols,
5230 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5231 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5235 /* If we're at the second level, and we're an enumerator, and
5236 our parent has no specification (meaning possibly lives in a
5237 namespace elsewhere), then we can add the partial symbol now
5238 instead of queueing it. */
5239 if (part_die->tag == DW_TAG_enumerator
5240 && parent_die != NULL
5241 && parent_die->die_parent == NULL
5242 && parent_die->tag == DW_TAG_enumeration_type
5243 && parent_die->has_specification == 0)
5245 if (part_die->name == NULL)
5246 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5247 else if (building_psymtab)
5248 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5249 VAR_DOMAIN, LOC_CONST,
5250 (cu->language == language_cplus
5251 || cu->language == language_java)
5252 ? &cu->objfile->global_psymbols
5253 : &cu->objfile->static_psymbols,
5254 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5256 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5260 /* We'll save this DIE so link it in. */
5261 part_die->die_parent = parent_die;
5262 part_die->die_sibling = NULL;
5263 part_die->die_child = NULL;
5265 if (last_die && last_die == parent_die)
5266 last_die->die_child = part_die;
5268 last_die->die_sibling = part_die;
5270 last_die = part_die;
5272 if (first_die == NULL)
5273 first_die = part_die;
5275 /* Maybe add the DIE to the hash table. Not all DIEs that we
5276 find interesting need to be in the hash table, because we
5277 also have the parent/sibling/child chains; only those that we
5278 might refer to by offset later during partial symbol reading.
5280 For now this means things that might have be the target of a
5281 DW_AT_specification, DW_AT_abstract_origin, or
5282 DW_AT_extension. DW_AT_extension will refer only to
5283 namespaces; DW_AT_abstract_origin refers to functions (and
5284 many things under the function DIE, but we do not recurse
5285 into function DIEs during partial symbol reading) and
5286 possibly variables as well; DW_AT_specification refers to
5287 declarations. Declarations ought to have the DW_AT_declaration
5288 flag. It happens that GCC forgets to put it in sometimes, but
5289 only for functions, not for types.
5291 Adding more things than necessary to the hash table is harmless
5292 except for the performance cost. Adding too few will result in
5293 internal errors in find_partial_die. */
5295 if (abbrev->tag == DW_TAG_subprogram
5296 || abbrev->tag == DW_TAG_variable
5297 || abbrev->tag == DW_TAG_namespace
5298 || part_die->is_declaration)
5302 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5303 part_die->offset, INSERT);
5307 part_die = obstack_alloc (&cu->comp_unit_obstack,
5308 sizeof (struct partial_die_info));
5310 /* For some DIEs we want to follow their children (if any). For C
5311 we have no reason to follow the children of structures; for other
5312 languages we have to, both so that we can get at method physnames
5313 to infer fully qualified class names, and for DW_AT_specification. */
5314 if (last_die->has_children
5315 && (last_die->tag == DW_TAG_namespace
5316 || last_die->tag == DW_TAG_enumeration_type
5317 || (cu->language != language_c
5318 && (last_die->tag == DW_TAG_class_type
5319 || last_die->tag == DW_TAG_structure_type
5320 || last_die->tag == DW_TAG_union_type))))
5323 parent_die = last_die;
5327 /* Otherwise we skip to the next sibling, if any. */
5328 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5330 /* Back to the top, do it again. */
5334 /* Read a minimal amount of information into the minimal die structure. */
5337 read_partial_die (struct partial_die_info *part_die,
5338 struct abbrev_info *abbrev,
5339 unsigned int abbrev_len, bfd *abfd,
5340 gdb_byte *info_ptr, struct dwarf2_cu *cu)
5342 unsigned int bytes_read, i;
5343 struct attribute attr;
5344 int has_low_pc_attr = 0;
5345 int has_high_pc_attr = 0;
5347 memset (part_die, 0, sizeof (struct partial_die_info));
5349 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5351 info_ptr += abbrev_len;
5356 part_die->tag = abbrev->tag;
5357 part_die->has_children = abbrev->has_children;
5359 for (i = 0; i < abbrev->num_attrs; ++i)
5361 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5363 /* Store the data if it is of an attribute we want to keep in a
5364 partial symbol table. */
5369 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5370 if (part_die->name == NULL)
5371 part_die->name = DW_STRING (&attr);
5373 case DW_AT_comp_dir:
5374 if (part_die->dirname == NULL)
5375 part_die->dirname = DW_STRING (&attr);
5377 case DW_AT_MIPS_linkage_name:
5378 part_die->name = DW_STRING (&attr);
5381 has_low_pc_attr = 1;
5382 part_die->lowpc = DW_ADDR (&attr);
5385 has_high_pc_attr = 1;
5386 part_die->highpc = DW_ADDR (&attr);
5388 case DW_AT_location:
5389 /* Support the .debug_loc offsets */
5390 if (attr_form_is_block (&attr))
5392 part_die->locdesc = DW_BLOCK (&attr);
5394 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5396 dwarf2_complex_location_expr_complaint ();
5400 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5401 "partial symbol information");
5404 case DW_AT_language:
5405 part_die->language = DW_UNSND (&attr);
5407 case DW_AT_external:
5408 part_die->is_external = DW_UNSND (&attr);
5410 case DW_AT_declaration:
5411 part_die->is_declaration = DW_UNSND (&attr);
5414 part_die->has_type = 1;
5416 case DW_AT_abstract_origin:
5417 case DW_AT_specification:
5418 case DW_AT_extension:
5419 part_die->has_specification = 1;
5420 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5423 /* Ignore absolute siblings, they might point outside of
5424 the current compile unit. */
5425 if (attr.form == DW_FORM_ref_addr)
5426 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5428 part_die->sibling = dwarf2_per_objfile->info_buffer
5429 + dwarf2_get_ref_die_offset (&attr, cu);
5431 case DW_AT_stmt_list:
5432 part_die->has_stmt_list = 1;
5433 part_die->line_offset = DW_UNSND (&attr);
5440 /* When using the GNU linker, .gnu.linkonce. sections are used to
5441 eliminate duplicate copies of functions and vtables and such.
5442 The linker will arbitrarily choose one and discard the others.
5443 The AT_*_pc values for such functions refer to local labels in
5444 these sections. If the section from that file was discarded, the
5445 labels are not in the output, so the relocs get a value of 0.
5446 If this is a discarded function, mark the pc bounds as invalid,
5447 so that GDB will ignore it. */
5448 if (has_low_pc_attr && has_high_pc_attr
5449 && part_die->lowpc < part_die->highpc
5450 && (part_die->lowpc != 0
5451 || (bfd_get_file_flags (abfd) & HAS_RELOC)))
5452 part_die->has_pc_info = 1;
5456 /* Find a cached partial DIE at OFFSET in CU. */
5458 static struct partial_die_info *
5459 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5461 struct partial_die_info *lookup_die = NULL;
5462 struct partial_die_info part_die;
5464 part_die.offset = offset;
5465 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5467 if (lookup_die == NULL)
5468 internal_error (__FILE__, __LINE__,
5469 _("could not find partial DIE in cache\n"));
5474 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5476 static struct partial_die_info *
5477 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5479 struct dwarf2_per_cu_data *per_cu;
5481 if (offset >= cu->header.offset
5482 && offset < cu->header.offset + cu->header.length)
5483 return find_partial_die_in_comp_unit (offset, cu);
5485 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5487 if (per_cu->cu == NULL)
5489 load_comp_unit (per_cu, cu->objfile);
5490 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5491 dwarf2_per_objfile->read_in_chain = per_cu;
5494 per_cu->cu->last_used = 0;
5495 return find_partial_die_in_comp_unit (offset, per_cu->cu);
5498 /* Adjust PART_DIE before generating a symbol for it. This function
5499 may set the is_external flag or change the DIE's name. */
5502 fixup_partial_die (struct partial_die_info *part_die,
5503 struct dwarf2_cu *cu)
5505 /* If we found a reference attribute and the DIE has no name, try
5506 to find a name in the referred to DIE. */
5508 if (part_die->name == NULL && part_die->has_specification)
5510 struct partial_die_info *spec_die;
5512 spec_die = find_partial_die (part_die->spec_offset, cu);
5514 fixup_partial_die (spec_die, cu);
5518 part_die->name = spec_die->name;
5520 /* Copy DW_AT_external attribute if it is set. */
5521 if (spec_die->is_external)
5522 part_die->is_external = spec_die->is_external;
5526 /* Set default names for some unnamed DIEs. */
5527 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5528 || part_die->tag == DW_TAG_class_type))
5529 part_die->name = "(anonymous class)";
5531 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5532 part_die->name = "(anonymous namespace)";
5534 if (part_die->tag == DW_TAG_structure_type
5535 || part_die->tag == DW_TAG_class_type
5536 || part_die->tag == DW_TAG_union_type)
5537 guess_structure_name (part_die, cu);
5540 /* Read the die from the .debug_info section buffer. Set DIEP to
5541 point to a newly allocated die with its information, except for its
5542 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5543 whether the die has children or not. */
5546 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5547 struct dwarf2_cu *cu, int *has_children)
5549 unsigned int abbrev_number, bytes_read, i, offset;
5550 struct abbrev_info *abbrev;
5551 struct die_info *die;
5553 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5554 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5555 info_ptr += bytes_read;
5558 die = dwarf_alloc_die ();
5560 die->abbrev = abbrev_number;
5567 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5570 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5572 bfd_get_filename (abfd));
5574 die = dwarf_alloc_die ();
5575 die->offset = offset;
5576 die->tag = abbrev->tag;
5577 die->abbrev = abbrev_number;
5580 die->num_attrs = abbrev->num_attrs;
5581 die->attrs = (struct attribute *)
5582 xmalloc (die->num_attrs * sizeof (struct attribute));
5584 for (i = 0; i < abbrev->num_attrs; ++i)
5586 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5587 abfd, info_ptr, cu);
5589 /* If this attribute is an absolute reference to a different
5590 compilation unit, make sure that compilation unit is loaded
5592 if (die->attrs[i].form == DW_FORM_ref_addr
5593 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5594 || (DW_ADDR (&die->attrs[i])
5595 >= cu->header.offset + cu->header.length)))
5597 struct dwarf2_per_cu_data *per_cu;
5598 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5601 /* Mark the dependence relation so that we don't flush PER_CU
5603 dwarf2_add_dependence (cu, per_cu);
5605 /* If it's already on the queue, we have nothing to do. */
5609 /* If the compilation unit is already loaded, just mark it as
5611 if (per_cu->cu != NULL)
5613 per_cu->cu->last_used = 0;
5617 /* Add it to the queue. */
5618 queue_comp_unit (per_cu);
5623 *has_children = abbrev->has_children;
5627 /* Read an attribute value described by an attribute form. */
5630 read_attribute_value (struct attribute *attr, unsigned form,
5631 bfd *abfd, gdb_byte *info_ptr,
5632 struct dwarf2_cu *cu)
5634 struct comp_unit_head *cu_header = &cu->header;
5635 unsigned int bytes_read;
5636 struct dwarf_block *blk;
5642 case DW_FORM_ref_addr:
5643 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5644 info_ptr += bytes_read;
5646 case DW_FORM_block2:
5647 blk = dwarf_alloc_block (cu);
5648 blk->size = read_2_bytes (abfd, info_ptr);
5650 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5651 info_ptr += blk->size;
5652 DW_BLOCK (attr) = blk;
5654 case DW_FORM_block4:
5655 blk = dwarf_alloc_block (cu);
5656 blk->size = read_4_bytes (abfd, info_ptr);
5658 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5659 info_ptr += blk->size;
5660 DW_BLOCK (attr) = blk;
5663 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5667 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5671 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5674 case DW_FORM_string:
5675 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5676 info_ptr += bytes_read;
5679 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5681 info_ptr += bytes_read;
5684 blk = dwarf_alloc_block (cu);
5685 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5686 info_ptr += bytes_read;
5687 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5688 info_ptr += blk->size;
5689 DW_BLOCK (attr) = blk;
5691 case DW_FORM_block1:
5692 blk = dwarf_alloc_block (cu);
5693 blk->size = read_1_byte (abfd, info_ptr);
5695 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5696 info_ptr += blk->size;
5697 DW_BLOCK (attr) = blk;
5700 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5704 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5708 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5709 info_ptr += bytes_read;
5712 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5713 info_ptr += bytes_read;
5716 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5720 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5724 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5728 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5731 case DW_FORM_ref_udata:
5732 DW_ADDR (attr) = (cu->header.offset
5733 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5734 info_ptr += bytes_read;
5736 case DW_FORM_indirect:
5737 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5738 info_ptr += bytes_read;
5739 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5742 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5743 dwarf_form_name (form),
5744 bfd_get_filename (abfd));
5749 /* Read an attribute described by an abbreviated attribute. */
5752 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5753 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
5755 attr->name = abbrev->name;
5756 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5759 /* read dwarf information from a buffer */
5762 read_1_byte (bfd *abfd, gdb_byte *buf)
5764 return bfd_get_8 (abfd, buf);
5768 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
5770 return bfd_get_signed_8 (abfd, buf);
5774 read_2_bytes (bfd *abfd, gdb_byte *buf)
5776 return bfd_get_16 (abfd, buf);
5780 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
5782 return bfd_get_signed_16 (abfd, buf);
5786 read_4_bytes (bfd *abfd, gdb_byte *buf)
5788 return bfd_get_32 (abfd, buf);
5792 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
5794 return bfd_get_signed_32 (abfd, buf);
5797 static unsigned long
5798 read_8_bytes (bfd *abfd, gdb_byte *buf)
5800 return bfd_get_64 (abfd, buf);
5804 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
5805 unsigned int *bytes_read)
5807 struct comp_unit_head *cu_header = &cu->header;
5808 CORE_ADDR retval = 0;
5810 if (cu_header->signed_addr_p)
5812 switch (cu_header->addr_size)
5815 retval = bfd_get_signed_16 (abfd, buf);
5818 retval = bfd_get_signed_32 (abfd, buf);
5821 retval = bfd_get_signed_64 (abfd, buf);
5824 internal_error (__FILE__, __LINE__,
5825 _("read_address: bad switch, signed [in module %s]"),
5826 bfd_get_filename (abfd));
5831 switch (cu_header->addr_size)
5834 retval = bfd_get_16 (abfd, buf);
5837 retval = bfd_get_32 (abfd, buf);
5840 retval = bfd_get_64 (abfd, buf);
5843 internal_error (__FILE__, __LINE__,
5844 _("read_address: bad switch, unsigned [in module %s]"),
5845 bfd_get_filename (abfd));
5849 *bytes_read = cu_header->addr_size;
5853 /* Read the initial length from a section. The (draft) DWARF 3
5854 specification allows the initial length to take up either 4 bytes
5855 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5856 bytes describe the length and all offsets will be 8 bytes in length
5859 An older, non-standard 64-bit format is also handled by this
5860 function. The older format in question stores the initial length
5861 as an 8-byte quantity without an escape value. Lengths greater
5862 than 2^32 aren't very common which means that the initial 4 bytes
5863 is almost always zero. Since a length value of zero doesn't make
5864 sense for the 32-bit format, this initial zero can be considered to
5865 be an escape value which indicates the presence of the older 64-bit
5866 format. As written, the code can't detect (old format) lengths
5867 greater than 4GB. If it becomes necessary to handle lengths
5868 somewhat larger than 4GB, we could allow other small values (such
5869 as the non-sensical values of 1, 2, and 3) to also be used as
5870 escape values indicating the presence of the old format.
5872 The value returned via bytes_read should be used to increment the
5873 relevant pointer after calling read_initial_length().
5875 As a side effect, this function sets the fields initial_length_size
5876 and offset_size in cu_header to the values appropriate for the
5877 length field. (The format of the initial length field determines
5878 the width of file offsets to be fetched later with read_offset().)
5880 [ Note: read_initial_length() and read_offset() are based on the
5881 document entitled "DWARF Debugging Information Format", revision
5882 3, draft 8, dated November 19, 2001. This document was obtained
5885 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5887 This document is only a draft and is subject to change. (So beware.)
5889 Details regarding the older, non-standard 64-bit format were
5890 determined empirically by examining 64-bit ELF files produced by
5891 the SGI toolchain on an IRIX 6.5 machine.
5893 - Kevin, July 16, 2002
5897 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
5898 unsigned int *bytes_read)
5900 LONGEST length = bfd_get_32 (abfd, buf);
5902 if (length == 0xffffffff)
5904 length = bfd_get_64 (abfd, buf + 4);
5907 else if (length == 0)
5909 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5910 length = bfd_get_64 (abfd, buf);
5920 gdb_assert (cu_header->initial_length_size == 0
5921 || cu_header->initial_length_size == 4
5922 || cu_header->initial_length_size == 8
5923 || cu_header->initial_length_size == 12);
5925 if (cu_header->initial_length_size != 0
5926 && cu_header->initial_length_size != *bytes_read)
5927 complaint (&symfile_complaints,
5928 _("intermixed 32-bit and 64-bit DWARF sections"));
5930 cu_header->initial_length_size = *bytes_read;
5931 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
5937 /* Read an offset from the data stream. The size of the offset is
5938 given by cu_header->offset_size. */
5941 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
5942 unsigned int *bytes_read)
5946 switch (cu_header->offset_size)
5949 retval = bfd_get_32 (abfd, buf);
5953 retval = bfd_get_64 (abfd, buf);
5957 internal_error (__FILE__, __LINE__,
5958 _("read_offset: bad switch [in module %s]"),
5959 bfd_get_filename (abfd));
5966 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
5968 /* If the size of a host char is 8 bits, we can return a pointer
5969 to the buffer, otherwise we have to copy the data to a buffer
5970 allocated on the temporary obstack. */
5971 gdb_assert (HOST_CHAR_BIT == 8);
5976 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
5978 /* If the size of a host char is 8 bits, we can return a pointer
5979 to the string, otherwise we have to copy the string to a buffer
5980 allocated on the temporary obstack. */
5981 gdb_assert (HOST_CHAR_BIT == 8);
5984 *bytes_read_ptr = 1;
5987 *bytes_read_ptr = strlen ((char *) buf) + 1;
5988 return (char *) buf;
5992 read_indirect_string (bfd *abfd, gdb_byte *buf,
5993 const struct comp_unit_head *cu_header,
5994 unsigned int *bytes_read_ptr)
5996 LONGEST str_offset = read_offset (abfd, buf, cu_header,
5999 if (dwarf2_per_objfile->str_buffer == NULL)
6001 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6002 bfd_get_filename (abfd));
6005 if (str_offset >= dwarf2_per_objfile->str_size)
6007 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6008 bfd_get_filename (abfd));
6011 gdb_assert (HOST_CHAR_BIT == 8);
6012 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6014 return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6017 static unsigned long
6018 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6020 unsigned long result;
6021 unsigned int num_read;
6031 byte = bfd_get_8 (abfd, buf);
6034 result |= ((unsigned long)(byte & 127) << shift);
6035 if ((byte & 128) == 0)
6041 *bytes_read_ptr = num_read;
6046 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6049 int i, shift, num_read;
6058 byte = bfd_get_8 (abfd, buf);
6061 result |= ((long)(byte & 127) << shift);
6063 if ((byte & 128) == 0)
6068 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6069 result |= -(((long)1) << shift);
6070 *bytes_read_ptr = num_read;
6074 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6077 skip_leb128 (bfd *abfd, gdb_byte *buf)
6083 byte = bfd_get_8 (abfd, buf);
6085 if ((byte & 128) == 0)
6091 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6097 cu->language = language_c;
6099 case DW_LANG_C_plus_plus:
6100 cu->language = language_cplus;
6102 case DW_LANG_Fortran77:
6103 case DW_LANG_Fortran90:
6104 case DW_LANG_Fortran95:
6105 cu->language = language_fortran;
6107 case DW_LANG_Mips_Assembler:
6108 cu->language = language_asm;
6111 cu->language = language_java;
6115 cu->language = language_ada;
6117 case DW_LANG_Cobol74:
6118 case DW_LANG_Cobol85:
6119 case DW_LANG_Pascal83:
6120 case DW_LANG_Modula2:
6122 cu->language = language_minimal;
6125 cu->language_defn = language_def (cu->language);
6128 /* Return the named attribute or NULL if not there. */
6130 static struct attribute *
6131 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6134 struct attribute *spec = NULL;
6136 for (i = 0; i < die->num_attrs; ++i)
6138 if (die->attrs[i].name == name)
6139 return &die->attrs[i];
6140 if (die->attrs[i].name == DW_AT_specification
6141 || die->attrs[i].name == DW_AT_abstract_origin)
6142 spec = &die->attrs[i];
6146 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6151 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6152 and holds a non-zero value. This function should only be used for
6153 DW_FORM_flag attributes. */
6156 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6158 struct attribute *attr = dwarf2_attr (die, name, cu);
6160 return (attr && DW_UNSND (attr));
6164 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6166 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6167 which value is non-zero. However, we have to be careful with
6168 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6169 (via dwarf2_flag_true_p) follows this attribute. So we may
6170 end up accidently finding a declaration attribute that belongs
6171 to a different DIE referenced by the specification attribute,
6172 even though the given DIE does not have a declaration attribute. */
6173 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6174 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6177 /* Return the die giving the specification for DIE, if there is
6180 static struct die_info *
6181 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6183 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6185 if (spec_attr == NULL)
6188 return follow_die_ref (die, spec_attr, cu);
6191 /* Free the line_header structure *LH, and any arrays and strings it
6194 free_line_header (struct line_header *lh)
6196 if (lh->standard_opcode_lengths)
6197 xfree (lh->standard_opcode_lengths);
6199 /* Remember that all the lh->file_names[i].name pointers are
6200 pointers into debug_line_buffer, and don't need to be freed. */
6202 xfree (lh->file_names);
6204 /* Similarly for the include directory names. */
6205 if (lh->include_dirs)
6206 xfree (lh->include_dirs);
6212 /* Add an entry to LH's include directory table. */
6214 add_include_dir (struct line_header *lh, char *include_dir)
6216 /* Grow the array if necessary. */
6217 if (lh->include_dirs_size == 0)
6219 lh->include_dirs_size = 1; /* for testing */
6220 lh->include_dirs = xmalloc (lh->include_dirs_size
6221 * sizeof (*lh->include_dirs));
6223 else if (lh->num_include_dirs >= lh->include_dirs_size)
6225 lh->include_dirs_size *= 2;
6226 lh->include_dirs = xrealloc (lh->include_dirs,
6227 (lh->include_dirs_size
6228 * sizeof (*lh->include_dirs)));
6231 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6235 /* Add an entry to LH's file name table. */
6237 add_file_name (struct line_header *lh,
6239 unsigned int dir_index,
6240 unsigned int mod_time,
6241 unsigned int length)
6243 struct file_entry *fe;
6245 /* Grow the array if necessary. */
6246 if (lh->file_names_size == 0)
6248 lh->file_names_size = 1; /* for testing */
6249 lh->file_names = xmalloc (lh->file_names_size
6250 * sizeof (*lh->file_names));
6252 else if (lh->num_file_names >= lh->file_names_size)
6254 lh->file_names_size *= 2;
6255 lh->file_names = xrealloc (lh->file_names,
6256 (lh->file_names_size
6257 * sizeof (*lh->file_names)));
6260 fe = &lh->file_names[lh->num_file_names++];
6262 fe->dir_index = dir_index;
6263 fe->mod_time = mod_time;
6264 fe->length = length;
6269 /* Read the statement program header starting at OFFSET in
6270 .debug_line, according to the endianness of ABFD. Return a pointer
6271 to a struct line_header, allocated using xmalloc.
6273 NOTE: the strings in the include directory and file name tables of
6274 the returned object point into debug_line_buffer, and must not be
6276 static struct line_header *
6277 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6278 struct dwarf2_cu *cu)
6280 struct cleanup *back_to;
6281 struct line_header *lh;
6283 unsigned int bytes_read;
6285 char *cur_dir, *cur_file;
6287 if (dwarf2_per_objfile->line_buffer == NULL)
6289 complaint (&symfile_complaints, _("missing .debug_line section"));
6293 /* Make sure that at least there's room for the total_length field.
6294 That could be 12 bytes long, but we're just going to fudge that. */
6295 if (offset + 4 >= dwarf2_per_objfile->line_size)
6297 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6301 lh = xmalloc (sizeof (*lh));
6302 memset (lh, 0, sizeof (*lh));
6303 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6306 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6308 /* Read in the header. */
6310 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6311 line_ptr += bytes_read;
6312 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6313 + dwarf2_per_objfile->line_size))
6315 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6318 lh->statement_program_end = line_ptr + lh->total_length;
6319 lh->version = read_2_bytes (abfd, line_ptr);
6321 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6322 line_ptr += bytes_read;
6323 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6325 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6327 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6329 lh->line_range = read_1_byte (abfd, line_ptr);
6331 lh->opcode_base = read_1_byte (abfd, line_ptr);
6333 lh->standard_opcode_lengths
6334 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6336 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6337 for (i = 1; i < lh->opcode_base; ++i)
6339 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6343 /* Read directory table. */
6344 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6346 line_ptr += bytes_read;
6347 add_include_dir (lh, cur_dir);
6349 line_ptr += bytes_read;
6351 /* Read file name table. */
6352 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6354 unsigned int dir_index, mod_time, length;
6356 line_ptr += bytes_read;
6357 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6358 line_ptr += bytes_read;
6359 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6360 line_ptr += bytes_read;
6361 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6362 line_ptr += bytes_read;
6364 add_file_name (lh, cur_file, dir_index, mod_time, length);
6366 line_ptr += bytes_read;
6367 lh->statement_program_start = line_ptr;
6369 if (line_ptr > (dwarf2_per_objfile->line_buffer
6370 + dwarf2_per_objfile->line_size))
6371 complaint (&symfile_complaints,
6372 _("line number info header doesn't fit in `.debug_line' section"));
6374 discard_cleanups (back_to);
6378 /* This function exists to work around a bug in certain compilers
6379 (particularly GCC 2.95), in which the first line number marker of a
6380 function does not show up until after the prologue, right before
6381 the second line number marker. This function shifts ADDRESS down
6382 to the beginning of the function if necessary, and is called on
6383 addresses passed to record_line. */
6386 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6388 struct function_range *fn;
6390 /* Find the function_range containing address. */
6395 cu->cached_fn = cu->first_fn;
6399 if (fn->lowpc <= address && fn->highpc > address)
6405 while (fn && fn != cu->cached_fn)
6406 if (fn->lowpc <= address && fn->highpc > address)
6416 if (address != fn->lowpc)
6417 complaint (&symfile_complaints,
6418 _("misplaced first line number at 0x%lx for '%s'"),
6419 (unsigned long) address, fn->name);
6424 /* Decode the Line Number Program (LNP) for the given line_header
6425 structure and CU. The actual information extracted and the type
6426 of structures created from the LNP depends on the value of PST.
6428 1. If PST is NULL, then this procedure uses the data from the program
6429 to create all necessary symbol tables, and their linetables.
6430 The compilation directory of the file is passed in COMP_DIR,
6431 and must not be NULL.
6433 2. If PST is not NULL, this procedure reads the program to determine
6434 the list of files included by the unit represented by PST, and
6435 builds all the associated partial symbol tables. In this case,
6436 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6437 is not used to compute the full name of the symtab, and therefore
6438 omitting it when building the partial symtab does not introduce
6439 the potential for inconsistency - a partial symtab and its associated
6440 symbtab having a different fullname -). */
6443 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6444 struct dwarf2_cu *cu, struct partial_symtab *pst)
6448 unsigned int bytes_read;
6449 unsigned char op_code, extended_op, adj_opcode;
6451 struct objfile *objfile = cu->objfile;
6452 const int decode_for_pst_p = (pst != NULL);
6454 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6456 line_ptr = lh->statement_program_start;
6457 line_end = lh->statement_program_end;
6459 /* Read the statement sequences until there's nothing left. */
6460 while (line_ptr < line_end)
6462 /* state machine registers */
6463 CORE_ADDR address = 0;
6464 unsigned int file = 1;
6465 unsigned int line = 1;
6466 unsigned int column = 0;
6467 int is_stmt = lh->default_is_stmt;
6468 int basic_block = 0;
6469 int end_sequence = 0;
6471 if (!decode_for_pst_p && lh->num_file_names >= file)
6473 /* Start a subfile for the current file of the state machine. */
6474 /* lh->include_dirs and lh->file_names are 0-based, but the
6475 directory and file name numbers in the statement program
6477 struct file_entry *fe = &lh->file_names[file - 1];
6481 dir = lh->include_dirs[fe->dir_index - 1];
6484 dwarf2_start_subfile (fe->name, dir);
6487 /* Decode the table. */
6488 while (!end_sequence)
6490 op_code = read_1_byte (abfd, line_ptr);
6493 if (op_code >= lh->opcode_base)
6495 /* Special operand. */
6496 adj_opcode = op_code - lh->opcode_base;
6497 address += (adj_opcode / lh->line_range)
6498 * lh->minimum_instruction_length;
6499 line += lh->line_base + (adj_opcode % lh->line_range);
6500 lh->file_names[file - 1].included_p = 1;
6501 if (!decode_for_pst_p)
6503 /* Append row to matrix using current values. */
6504 record_line (current_subfile, line,
6505 check_cu_functions (address, cu));
6509 else switch (op_code)
6511 case DW_LNS_extended_op:
6512 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6513 line_ptr += bytes_read;
6514 extended_op = read_1_byte (abfd, line_ptr);
6516 switch (extended_op)
6518 case DW_LNE_end_sequence:
6520 lh->file_names[file - 1].included_p = 1;
6521 if (!decode_for_pst_p)
6522 record_line (current_subfile, 0, address);
6524 case DW_LNE_set_address:
6525 address = read_address (abfd, line_ptr, cu, &bytes_read);
6526 line_ptr += bytes_read;
6527 address += baseaddr;
6529 case DW_LNE_define_file:
6532 unsigned int dir_index, mod_time, length;
6534 cur_file = read_string (abfd, line_ptr, &bytes_read);
6535 line_ptr += bytes_read;
6537 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6538 line_ptr += bytes_read;
6540 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6541 line_ptr += bytes_read;
6543 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6544 line_ptr += bytes_read;
6545 add_file_name (lh, cur_file, dir_index, mod_time, length);
6549 complaint (&symfile_complaints,
6550 _("mangled .debug_line section"));
6555 lh->file_names[file - 1].included_p = 1;
6556 if (!decode_for_pst_p)
6557 record_line (current_subfile, line,
6558 check_cu_functions (address, cu));
6561 case DW_LNS_advance_pc:
6562 address += lh->minimum_instruction_length
6563 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6564 line_ptr += bytes_read;
6566 case DW_LNS_advance_line:
6567 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6568 line_ptr += bytes_read;
6570 case DW_LNS_set_file:
6572 /* The arrays lh->include_dirs and lh->file_names are
6573 0-based, but the directory and file name numbers in
6574 the statement program are 1-based. */
6575 struct file_entry *fe;
6578 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6579 line_ptr += bytes_read;
6580 fe = &lh->file_names[file - 1];
6582 dir = lh->include_dirs[fe->dir_index - 1];
6585 if (!decode_for_pst_p)
6586 dwarf2_start_subfile (fe->name, dir);
6589 case DW_LNS_set_column:
6590 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6591 line_ptr += bytes_read;
6593 case DW_LNS_negate_stmt:
6594 is_stmt = (!is_stmt);
6596 case DW_LNS_set_basic_block:
6599 /* Add to the address register of the state machine the
6600 address increment value corresponding to special opcode
6601 255. I.e., this value is scaled by the minimum
6602 instruction length since special opcode 255 would have
6603 scaled the the increment. */
6604 case DW_LNS_const_add_pc:
6605 address += (lh->minimum_instruction_length
6606 * ((255 - lh->opcode_base) / lh->line_range));
6608 case DW_LNS_fixed_advance_pc:
6609 address += read_2_bytes (abfd, line_ptr);
6614 /* Unknown standard opcode, ignore it. */
6617 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6619 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6620 line_ptr += bytes_read;
6627 if (decode_for_pst_p)
6631 /* Now that we're done scanning the Line Header Program, we can
6632 create the psymtab of each included file. */
6633 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6634 if (lh->file_names[file_index].included_p == 1)
6636 const struct file_entry fe = lh->file_names [file_index];
6637 char *include_name = fe.name;
6638 char *dir_name = NULL;
6639 char *pst_filename = pst->filename;
6642 dir_name = lh->include_dirs[fe.dir_index - 1];
6644 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6646 include_name = concat (dir_name, SLASH_STRING,
6647 include_name, (char *)NULL);
6648 make_cleanup (xfree, include_name);
6651 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6653 pst_filename = concat (pst->dirname, SLASH_STRING,
6654 pst_filename, (char *)NULL);
6655 make_cleanup (xfree, pst_filename);
6658 if (strcmp (include_name, pst_filename) != 0)
6659 dwarf2_create_include_psymtab (include_name, pst, objfile);
6664 /* Start a subfile for DWARF. FILENAME is the name of the file and
6665 DIRNAME the name of the source directory which contains FILENAME
6666 or NULL if not known.
6667 This routine tries to keep line numbers from identical absolute and
6668 relative file names in a common subfile.
6670 Using the `list' example from the GDB testsuite, which resides in
6671 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6672 of /srcdir/list0.c yields the following debugging information for list0.c:
6674 DW_AT_name: /srcdir/list0.c
6675 DW_AT_comp_dir: /compdir
6676 files.files[0].name: list0.h
6677 files.files[0].dir: /srcdir
6678 files.files[1].name: list0.c
6679 files.files[1].dir: /srcdir
6681 The line number information for list0.c has to end up in a single
6682 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6685 dwarf2_start_subfile (char *filename, char *dirname)
6687 /* If the filename isn't absolute, try to match an existing subfile
6688 with the full pathname. */
6690 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6692 struct subfile *subfile;
6693 char *fullname = concat (dirname, "/", filename, (char *)NULL);
6695 for (subfile = subfiles; subfile; subfile = subfile->next)
6697 if (FILENAME_CMP (subfile->name, fullname) == 0)
6699 current_subfile = subfile;
6706 start_subfile (filename, dirname);
6710 var_decode_location (struct attribute *attr, struct symbol *sym,
6711 struct dwarf2_cu *cu)
6713 struct objfile *objfile = cu->objfile;
6714 struct comp_unit_head *cu_header = &cu->header;
6716 /* NOTE drow/2003-01-30: There used to be a comment and some special
6717 code here to turn a symbol with DW_AT_external and a
6718 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6719 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6720 with some versions of binutils) where shared libraries could have
6721 relocations against symbols in their debug information - the
6722 minimal symbol would have the right address, but the debug info
6723 would not. It's no longer necessary, because we will explicitly
6724 apply relocations when we read in the debug information now. */
6726 /* A DW_AT_location attribute with no contents indicates that a
6727 variable has been optimized away. */
6728 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6730 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6734 /* Handle one degenerate form of location expression specially, to
6735 preserve GDB's previous behavior when section offsets are
6736 specified. If this is just a DW_OP_addr then mark this symbol
6739 if (attr_form_is_block (attr)
6740 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6741 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6745 SYMBOL_VALUE_ADDRESS (sym) =
6746 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6747 fixup_symbol_section (sym, objfile);
6748 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6749 SYMBOL_SECTION (sym));
6750 SYMBOL_CLASS (sym) = LOC_STATIC;
6754 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6755 expression evaluator, and use LOC_COMPUTED only when necessary
6756 (i.e. when the value of a register or memory location is
6757 referenced, or a thread-local block, etc.). Then again, it might
6758 not be worthwhile. I'm assuming that it isn't unless performance
6759 or memory numbers show me otherwise. */
6761 dwarf2_symbol_mark_computed (attr, sym, cu);
6762 SYMBOL_CLASS (sym) = LOC_COMPUTED;
6765 /* Given a pointer to a DWARF information entry, figure out if we need
6766 to make a symbol table entry for it, and if so, create a new entry
6767 and return a pointer to it.
6768 If TYPE is NULL, determine symbol type from the die, otherwise
6769 used the passed type. */
6771 static struct symbol *
6772 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6774 struct objfile *objfile = cu->objfile;
6775 struct symbol *sym = NULL;
6777 struct attribute *attr = NULL;
6778 struct attribute *attr2 = NULL;
6781 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6783 if (die->tag != DW_TAG_namespace)
6784 name = dwarf2_linkage_name (die, cu);
6786 name = TYPE_NAME (type);
6790 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6791 sizeof (struct symbol));
6792 OBJSTAT (objfile, n_syms++);
6793 memset (sym, 0, sizeof (struct symbol));
6795 /* Cache this symbol's name and the name's demangled form (if any). */
6796 SYMBOL_LANGUAGE (sym) = cu->language;
6797 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
6799 /* Default assumptions.
6800 Use the passed type or decode it from the die. */
6801 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6802 SYMBOL_CLASS (sym) = LOC_STATIC;
6804 SYMBOL_TYPE (sym) = type;
6806 SYMBOL_TYPE (sym) = die_type (die, cu);
6807 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
6810 SYMBOL_LINE (sym) = DW_UNSND (attr);
6815 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6818 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
6820 SYMBOL_CLASS (sym) = LOC_LABEL;
6822 case DW_TAG_subprogram:
6823 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6825 SYMBOL_CLASS (sym) = LOC_BLOCK;
6826 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6827 if (attr2 && (DW_UNSND (attr2) != 0))
6829 add_symbol_to_list (sym, &global_symbols);
6833 add_symbol_to_list (sym, cu->list_in_scope);
6836 case DW_TAG_variable:
6837 /* Compilation with minimal debug info may result in variables
6838 with missing type entries. Change the misleading `void' type
6839 to something sensible. */
6840 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
6841 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
6842 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
6843 "<variable, no debug info>",
6845 attr = dwarf2_attr (die, DW_AT_const_value, cu);
6848 dwarf2_const_value (attr, sym, cu);
6849 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6850 if (attr2 && (DW_UNSND (attr2) != 0))
6851 add_symbol_to_list (sym, &global_symbols);
6853 add_symbol_to_list (sym, cu->list_in_scope);
6856 attr = dwarf2_attr (die, DW_AT_location, cu);
6859 var_decode_location (attr, sym, cu);
6860 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6861 if (attr2 && (DW_UNSND (attr2) != 0))
6862 add_symbol_to_list (sym, &global_symbols);
6864 add_symbol_to_list (sym, cu->list_in_scope);
6868 /* We do not know the address of this symbol.
6869 If it is an external symbol and we have type information
6870 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6871 The address of the variable will then be determined from
6872 the minimal symbol table whenever the variable is
6874 attr2 = dwarf2_attr (die, DW_AT_external, cu);
6875 if (attr2 && (DW_UNSND (attr2) != 0)
6876 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
6878 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
6879 add_symbol_to_list (sym, &global_symbols);
6883 case DW_TAG_formal_parameter:
6884 attr = dwarf2_attr (die, DW_AT_location, cu);
6887 var_decode_location (attr, sym, cu);
6888 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6889 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
6890 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
6892 attr = dwarf2_attr (die, DW_AT_const_value, cu);
6895 dwarf2_const_value (attr, sym, cu);
6897 add_symbol_to_list (sym, cu->list_in_scope);
6899 case DW_TAG_unspecified_parameters:
6900 /* From varargs functions; gdb doesn't seem to have any
6901 interest in this information, so just ignore it for now.
6904 case DW_TAG_class_type:
6905 case DW_TAG_structure_type:
6906 case DW_TAG_union_type:
6907 case DW_TAG_enumeration_type:
6908 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6909 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
6911 /* Make sure that the symbol includes appropriate enclosing
6912 classes/namespaces in its name. These are calculated in
6913 read_structure_type, and the correct name is saved in
6916 if (cu->language == language_cplus
6917 || cu->language == language_java)
6919 struct type *type = SYMBOL_TYPE (sym);
6921 if (TYPE_TAG_NAME (type) != NULL)
6923 /* FIXME: carlton/2003-11-10: Should this use
6924 SYMBOL_SET_NAMES instead? (The same problem also
6925 arises further down in this function.) */
6926 /* The type's name is already allocated along with
6927 this objfile, so we don't need to duplicate it
6929 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
6934 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6935 really ever be static objects: otherwise, if you try
6936 to, say, break of a class's method and you're in a file
6937 which doesn't mention that class, it won't work unless
6938 the check for all static symbols in lookup_symbol_aux
6939 saves you. See the OtherFileClass tests in
6940 gdb.c++/namespace.exp. */
6942 struct pending **list_to_add;
6944 list_to_add = (cu->list_in_scope == &file_symbols
6945 && (cu->language == language_cplus
6946 || cu->language == language_java)
6947 ? &global_symbols : cu->list_in_scope);
6949 add_symbol_to_list (sym, list_to_add);
6951 /* The semantics of C++ state that "struct foo { ... }" also
6952 defines a typedef for "foo". A Java class declaration also
6953 defines a typedef for the class. Synthesize a typedef symbol
6954 so that "ptype foo" works as expected. */
6955 if (cu->language == language_cplus
6956 || cu->language == language_java)
6958 struct symbol *typedef_sym = (struct symbol *)
6959 obstack_alloc (&objfile->objfile_obstack,
6960 sizeof (struct symbol));
6961 *typedef_sym = *sym;
6962 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
6963 /* The symbol's name is already allocated along with
6964 this objfile, so we don't need to duplicate it for
6966 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
6967 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
6968 add_symbol_to_list (typedef_sym, list_to_add);
6972 case DW_TAG_typedef:
6973 if (processing_has_namespace_info
6974 && processing_current_prefix[0] != '\0')
6976 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
6977 processing_current_prefix,
6980 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6981 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6982 add_symbol_to_list (sym, cu->list_in_scope);
6984 case DW_TAG_base_type:
6985 case DW_TAG_subrange_type:
6986 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6987 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6988 add_symbol_to_list (sym, cu->list_in_scope);
6990 case DW_TAG_enumerator:
6991 if (processing_has_namespace_info
6992 && processing_current_prefix[0] != '\0')
6994 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
6995 processing_current_prefix,
6998 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7001 dwarf2_const_value (attr, sym, cu);
7004 /* NOTE: carlton/2003-11-10: See comment above in the
7005 DW_TAG_class_type, etc. block. */
7007 struct pending **list_to_add;
7009 list_to_add = (cu->list_in_scope == &file_symbols
7010 && (cu->language == language_cplus
7011 || cu->language == language_java)
7012 ? &global_symbols : cu->list_in_scope);
7014 add_symbol_to_list (sym, list_to_add);
7017 case DW_TAG_namespace:
7018 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7019 add_symbol_to_list (sym, &global_symbols);
7022 /* Not a tag we recognize. Hopefully we aren't processing
7023 trash data, but since we must specifically ignore things
7024 we don't recognize, there is nothing else we should do at
7026 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7027 dwarf_tag_name (die->tag));
7034 /* Copy constant value from an attribute to a symbol. */
7037 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7038 struct dwarf2_cu *cu)
7040 struct objfile *objfile = cu->objfile;
7041 struct comp_unit_head *cu_header = &cu->header;
7042 struct dwarf_block *blk;
7047 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7048 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7049 cu_header->addr_size,
7050 TYPE_LENGTH (SYMBOL_TYPE
7052 SYMBOL_VALUE_BYTES (sym) =
7053 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7054 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7055 it's body - store_unsigned_integer. */
7056 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7058 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7060 case DW_FORM_block1:
7061 case DW_FORM_block2:
7062 case DW_FORM_block4:
7064 blk = DW_BLOCK (attr);
7065 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7066 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7068 TYPE_LENGTH (SYMBOL_TYPE
7070 SYMBOL_VALUE_BYTES (sym) =
7071 obstack_alloc (&objfile->objfile_obstack, blk->size);
7072 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7073 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7076 /* The DW_AT_const_value attributes are supposed to carry the
7077 symbol's value "represented as it would be on the target
7078 architecture." By the time we get here, it's already been
7079 converted to host endianness, so we just need to sign- or
7080 zero-extend it as appropriate. */
7082 dwarf2_const_value_data (attr, sym, 8);
7085 dwarf2_const_value_data (attr, sym, 16);
7088 dwarf2_const_value_data (attr, sym, 32);
7091 dwarf2_const_value_data (attr, sym, 64);
7095 SYMBOL_VALUE (sym) = DW_SND (attr);
7096 SYMBOL_CLASS (sym) = LOC_CONST;
7100 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7101 SYMBOL_CLASS (sym) = LOC_CONST;
7105 complaint (&symfile_complaints,
7106 _("unsupported const value attribute form: '%s'"),
7107 dwarf_form_name (attr->form));
7108 SYMBOL_VALUE (sym) = 0;
7109 SYMBOL_CLASS (sym) = LOC_CONST;
7115 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7116 or zero-extend it as appropriate for the symbol's type. */
7118 dwarf2_const_value_data (struct attribute *attr,
7122 LONGEST l = DW_UNSND (attr);
7124 if (bits < sizeof (l) * 8)
7126 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7127 l &= ((LONGEST) 1 << bits) - 1;
7129 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7132 SYMBOL_VALUE (sym) = l;
7133 SYMBOL_CLASS (sym) = LOC_CONST;
7137 /* Return the type of the die in question using its DW_AT_type attribute. */
7139 static struct type *
7140 die_type (struct die_info *die, struct dwarf2_cu *cu)
7143 struct attribute *type_attr;
7144 struct die_info *type_die;
7146 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7149 /* A missing DW_AT_type represents a void type. */
7150 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7153 type_die = follow_die_ref (die, type_attr, cu);
7155 type = tag_type_to_type (type_die, cu);
7158 dump_die (type_die);
7159 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7165 /* Return the containing type of the die in question using its
7166 DW_AT_containing_type attribute. */
7168 static struct type *
7169 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7171 struct type *type = NULL;
7172 struct attribute *type_attr;
7173 struct die_info *type_die = NULL;
7175 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7178 type_die = follow_die_ref (die, type_attr, cu);
7179 type = tag_type_to_type (type_die, cu);
7184 dump_die (type_die);
7185 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7191 static struct type *
7192 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7200 read_type_die (die, cu);
7204 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7212 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7214 char *prefix = determine_prefix (die, cu);
7215 const char *old_prefix = processing_current_prefix;
7216 struct cleanup *back_to = make_cleanup (xfree, prefix);
7217 processing_current_prefix = prefix;
7221 case DW_TAG_class_type:
7222 case DW_TAG_structure_type:
7223 case DW_TAG_union_type:
7224 read_structure_type (die, cu);
7226 case DW_TAG_enumeration_type:
7227 read_enumeration_type (die, cu);
7229 case DW_TAG_subprogram:
7230 case DW_TAG_subroutine_type:
7231 read_subroutine_type (die, cu);
7233 case DW_TAG_array_type:
7234 read_array_type (die, cu);
7236 case DW_TAG_pointer_type:
7237 read_tag_pointer_type (die, cu);
7239 case DW_TAG_ptr_to_member_type:
7240 read_tag_ptr_to_member_type (die, cu);
7242 case DW_TAG_reference_type:
7243 read_tag_reference_type (die, cu);
7245 case DW_TAG_const_type:
7246 read_tag_const_type (die, cu);
7248 case DW_TAG_volatile_type:
7249 read_tag_volatile_type (die, cu);
7251 case DW_TAG_string_type:
7252 read_tag_string_type (die, cu);
7254 case DW_TAG_typedef:
7255 read_typedef (die, cu);
7257 case DW_TAG_subrange_type:
7258 read_subrange_type (die, cu);
7260 case DW_TAG_base_type:
7261 read_base_type (die, cu);
7264 complaint (&symfile_complaints, _("unexepected tag in read_type_die: '%s'"),
7265 dwarf_tag_name (die->tag));
7269 processing_current_prefix = old_prefix;
7270 do_cleanups (back_to);
7273 /* Return the name of the namespace/class that DIE is defined within,
7274 or "" if we can't tell. The caller should xfree the result. */
7276 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7277 therein) for an example of how to use this function to deal with
7278 DW_AT_specification. */
7281 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7283 struct die_info *parent;
7285 if (cu->language != language_cplus
7286 && cu->language != language_java)
7289 parent = die->parent;
7293 return xstrdup ("");
7297 switch (parent->tag) {
7298 case DW_TAG_namespace:
7300 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7301 before doing this check? */
7302 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7304 return xstrdup (TYPE_TAG_NAME (parent->type));
7309 char *parent_prefix = determine_prefix (parent, cu);
7310 char *retval = typename_concat (NULL, parent_prefix,
7311 namespace_name (parent, &dummy,
7314 xfree (parent_prefix);
7319 case DW_TAG_class_type:
7320 case DW_TAG_structure_type:
7322 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7324 return xstrdup (TYPE_TAG_NAME (parent->type));
7328 const char *old_prefix = processing_current_prefix;
7329 char *new_prefix = determine_prefix (parent, cu);
7332 processing_current_prefix = new_prefix;
7333 retval = determine_class_name (parent, cu);
7334 processing_current_prefix = old_prefix;
7341 return determine_prefix (parent, cu);
7346 /* Return a newly-allocated string formed by concatenating PREFIX and
7347 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7348 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7349 perform an obconcat, otherwise allocate storage for the result. The CU argument
7350 is used to determine the language and hence, the appropriate separator. */
7352 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7355 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7356 struct dwarf2_cu *cu)
7360 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7362 else if (cu->language == language_java)
7369 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7374 strcpy (retval, prefix);
7375 strcat (retval, sep);
7378 strcat (retval, suffix);
7384 /* We have an obstack. */
7385 return obconcat (obs, prefix, sep, suffix);
7389 static struct type *
7390 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7392 struct objfile *objfile = cu->objfile;
7394 /* FIXME - this should not produce a new (struct type *)
7395 every time. It should cache base types. */
7399 case DW_ATE_address:
7400 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7402 case DW_ATE_boolean:
7403 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7405 case DW_ATE_complex_float:
7408 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7412 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7418 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7422 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7429 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7432 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7436 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7440 case DW_ATE_signed_char:
7441 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7443 case DW_ATE_unsigned:
7447 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7450 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7454 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7458 case DW_ATE_unsigned_char:
7459 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7462 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7469 copy_die (struct die_info *old_die)
7471 struct die_info *new_die;
7474 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7475 memset (new_die, 0, sizeof (struct die_info));
7477 new_die->tag = old_die->tag;
7478 new_die->has_children = old_die->has_children;
7479 new_die->abbrev = old_die->abbrev;
7480 new_die->offset = old_die->offset;
7481 new_die->type = NULL;
7483 num_attrs = old_die->num_attrs;
7484 new_die->num_attrs = num_attrs;
7485 new_die->attrs = (struct attribute *)
7486 xmalloc (num_attrs * sizeof (struct attribute));
7488 for (i = 0; i < old_die->num_attrs; ++i)
7490 new_die->attrs[i].name = old_die->attrs[i].name;
7491 new_die->attrs[i].form = old_die->attrs[i].form;
7492 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7495 new_die->next = NULL;
7500 /* Return sibling of die, NULL if no sibling. */
7502 static struct die_info *
7503 sibling_die (struct die_info *die)
7505 return die->sibling;
7508 /* Get linkage name of a die, return NULL if not found. */
7511 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7513 struct attribute *attr;
7515 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7516 if (attr && DW_STRING (attr))
7517 return DW_STRING (attr);
7518 attr = dwarf2_attr (die, DW_AT_name, cu);
7519 if (attr && DW_STRING (attr))
7520 return DW_STRING (attr);
7524 /* Get name of a die, return NULL if not found. */
7527 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7529 struct attribute *attr;
7531 attr = dwarf2_attr (die, DW_AT_name, cu);
7532 if (attr && DW_STRING (attr))
7533 return DW_STRING (attr);
7537 /* Return the die that this die in an extension of, or NULL if there
7540 static struct die_info *
7541 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7543 struct attribute *attr;
7545 attr = dwarf2_attr (die, DW_AT_extension, cu);
7549 return follow_die_ref (die, attr, cu);
7552 /* Convert a DIE tag into its string name. */
7555 dwarf_tag_name (unsigned tag)
7559 case DW_TAG_padding:
7560 return "DW_TAG_padding";
7561 case DW_TAG_array_type:
7562 return "DW_TAG_array_type";
7563 case DW_TAG_class_type:
7564 return "DW_TAG_class_type";
7565 case DW_TAG_entry_point:
7566 return "DW_TAG_entry_point";
7567 case DW_TAG_enumeration_type:
7568 return "DW_TAG_enumeration_type";
7569 case DW_TAG_formal_parameter:
7570 return "DW_TAG_formal_parameter";
7571 case DW_TAG_imported_declaration:
7572 return "DW_TAG_imported_declaration";
7574 return "DW_TAG_label";
7575 case DW_TAG_lexical_block:
7576 return "DW_TAG_lexical_block";
7578 return "DW_TAG_member";
7579 case DW_TAG_pointer_type:
7580 return "DW_TAG_pointer_type";
7581 case DW_TAG_reference_type:
7582 return "DW_TAG_reference_type";
7583 case DW_TAG_compile_unit:
7584 return "DW_TAG_compile_unit";
7585 case DW_TAG_string_type:
7586 return "DW_TAG_string_type";
7587 case DW_TAG_structure_type:
7588 return "DW_TAG_structure_type";
7589 case DW_TAG_subroutine_type:
7590 return "DW_TAG_subroutine_type";
7591 case DW_TAG_typedef:
7592 return "DW_TAG_typedef";
7593 case DW_TAG_union_type:
7594 return "DW_TAG_union_type";
7595 case DW_TAG_unspecified_parameters:
7596 return "DW_TAG_unspecified_parameters";
7597 case DW_TAG_variant:
7598 return "DW_TAG_variant";
7599 case DW_TAG_common_block:
7600 return "DW_TAG_common_block";
7601 case DW_TAG_common_inclusion:
7602 return "DW_TAG_common_inclusion";
7603 case DW_TAG_inheritance:
7604 return "DW_TAG_inheritance";
7605 case DW_TAG_inlined_subroutine:
7606 return "DW_TAG_inlined_subroutine";
7608 return "DW_TAG_module";
7609 case DW_TAG_ptr_to_member_type:
7610 return "DW_TAG_ptr_to_member_type";
7611 case DW_TAG_set_type:
7612 return "DW_TAG_set_type";
7613 case DW_TAG_subrange_type:
7614 return "DW_TAG_subrange_type";
7615 case DW_TAG_with_stmt:
7616 return "DW_TAG_with_stmt";
7617 case DW_TAG_access_declaration:
7618 return "DW_TAG_access_declaration";
7619 case DW_TAG_base_type:
7620 return "DW_TAG_base_type";
7621 case DW_TAG_catch_block:
7622 return "DW_TAG_catch_block";
7623 case DW_TAG_const_type:
7624 return "DW_TAG_const_type";
7625 case DW_TAG_constant:
7626 return "DW_TAG_constant";
7627 case DW_TAG_enumerator:
7628 return "DW_TAG_enumerator";
7629 case DW_TAG_file_type:
7630 return "DW_TAG_file_type";
7632 return "DW_TAG_friend";
7633 case DW_TAG_namelist:
7634 return "DW_TAG_namelist";
7635 case DW_TAG_namelist_item:
7636 return "DW_TAG_namelist_item";
7637 case DW_TAG_packed_type:
7638 return "DW_TAG_packed_type";
7639 case DW_TAG_subprogram:
7640 return "DW_TAG_subprogram";
7641 case DW_TAG_template_type_param:
7642 return "DW_TAG_template_type_param";
7643 case DW_TAG_template_value_param:
7644 return "DW_TAG_template_value_param";
7645 case DW_TAG_thrown_type:
7646 return "DW_TAG_thrown_type";
7647 case DW_TAG_try_block:
7648 return "DW_TAG_try_block";
7649 case DW_TAG_variant_part:
7650 return "DW_TAG_variant_part";
7651 case DW_TAG_variable:
7652 return "DW_TAG_variable";
7653 case DW_TAG_volatile_type:
7654 return "DW_TAG_volatile_type";
7655 case DW_TAG_dwarf_procedure:
7656 return "DW_TAG_dwarf_procedure";
7657 case DW_TAG_restrict_type:
7658 return "DW_TAG_restrict_type";
7659 case DW_TAG_interface_type:
7660 return "DW_TAG_interface_type";
7661 case DW_TAG_namespace:
7662 return "DW_TAG_namespace";
7663 case DW_TAG_imported_module:
7664 return "DW_TAG_imported_module";
7665 case DW_TAG_unspecified_type:
7666 return "DW_TAG_unspecified_type";
7667 case DW_TAG_partial_unit:
7668 return "DW_TAG_partial_unit";
7669 case DW_TAG_imported_unit:
7670 return "DW_TAG_imported_unit";
7671 case DW_TAG_MIPS_loop:
7672 return "DW_TAG_MIPS_loop";
7673 case DW_TAG_format_label:
7674 return "DW_TAG_format_label";
7675 case DW_TAG_function_template:
7676 return "DW_TAG_function_template";
7677 case DW_TAG_class_template:
7678 return "DW_TAG_class_template";
7680 return "DW_TAG_<unknown>";
7684 /* Convert a DWARF attribute code into its string name. */
7687 dwarf_attr_name (unsigned attr)
7692 return "DW_AT_sibling";
7693 case DW_AT_location:
7694 return "DW_AT_location";
7696 return "DW_AT_name";
7697 case DW_AT_ordering:
7698 return "DW_AT_ordering";
7699 case DW_AT_subscr_data:
7700 return "DW_AT_subscr_data";
7701 case DW_AT_byte_size:
7702 return "DW_AT_byte_size";
7703 case DW_AT_bit_offset:
7704 return "DW_AT_bit_offset";
7705 case DW_AT_bit_size:
7706 return "DW_AT_bit_size";
7707 case DW_AT_element_list:
7708 return "DW_AT_element_list";
7709 case DW_AT_stmt_list:
7710 return "DW_AT_stmt_list";
7712 return "DW_AT_low_pc";
7714 return "DW_AT_high_pc";
7715 case DW_AT_language:
7716 return "DW_AT_language";
7718 return "DW_AT_member";
7720 return "DW_AT_discr";
7721 case DW_AT_discr_value:
7722 return "DW_AT_discr_value";
7723 case DW_AT_visibility:
7724 return "DW_AT_visibility";
7726 return "DW_AT_import";
7727 case DW_AT_string_length:
7728 return "DW_AT_string_length";
7729 case DW_AT_common_reference:
7730 return "DW_AT_common_reference";
7731 case DW_AT_comp_dir:
7732 return "DW_AT_comp_dir";
7733 case DW_AT_const_value:
7734 return "DW_AT_const_value";
7735 case DW_AT_containing_type:
7736 return "DW_AT_containing_type";
7737 case DW_AT_default_value:
7738 return "DW_AT_default_value";
7740 return "DW_AT_inline";
7741 case DW_AT_is_optional:
7742 return "DW_AT_is_optional";
7743 case DW_AT_lower_bound:
7744 return "DW_AT_lower_bound";
7745 case DW_AT_producer:
7746 return "DW_AT_producer";
7747 case DW_AT_prototyped:
7748 return "DW_AT_prototyped";
7749 case DW_AT_return_addr:
7750 return "DW_AT_return_addr";
7751 case DW_AT_start_scope:
7752 return "DW_AT_start_scope";
7753 case DW_AT_stride_size:
7754 return "DW_AT_stride_size";
7755 case DW_AT_upper_bound:
7756 return "DW_AT_upper_bound";
7757 case DW_AT_abstract_origin:
7758 return "DW_AT_abstract_origin";
7759 case DW_AT_accessibility:
7760 return "DW_AT_accessibility";
7761 case DW_AT_address_class:
7762 return "DW_AT_address_class";
7763 case DW_AT_artificial:
7764 return "DW_AT_artificial";
7765 case DW_AT_base_types:
7766 return "DW_AT_base_types";
7767 case DW_AT_calling_convention:
7768 return "DW_AT_calling_convention";
7770 return "DW_AT_count";
7771 case DW_AT_data_member_location:
7772 return "DW_AT_data_member_location";
7773 case DW_AT_decl_column:
7774 return "DW_AT_decl_column";
7775 case DW_AT_decl_file:
7776 return "DW_AT_decl_file";
7777 case DW_AT_decl_line:
7778 return "DW_AT_decl_line";
7779 case DW_AT_declaration:
7780 return "DW_AT_declaration";
7781 case DW_AT_discr_list:
7782 return "DW_AT_discr_list";
7783 case DW_AT_encoding:
7784 return "DW_AT_encoding";
7785 case DW_AT_external:
7786 return "DW_AT_external";
7787 case DW_AT_frame_base:
7788 return "DW_AT_frame_base";
7790 return "DW_AT_friend";
7791 case DW_AT_identifier_case:
7792 return "DW_AT_identifier_case";
7793 case DW_AT_macro_info:
7794 return "DW_AT_macro_info";
7795 case DW_AT_namelist_items:
7796 return "DW_AT_namelist_items";
7797 case DW_AT_priority:
7798 return "DW_AT_priority";
7800 return "DW_AT_segment";
7801 case DW_AT_specification:
7802 return "DW_AT_specification";
7803 case DW_AT_static_link:
7804 return "DW_AT_static_link";
7806 return "DW_AT_type";
7807 case DW_AT_use_location:
7808 return "DW_AT_use_location";
7809 case DW_AT_variable_parameter:
7810 return "DW_AT_variable_parameter";
7811 case DW_AT_virtuality:
7812 return "DW_AT_virtuality";
7813 case DW_AT_vtable_elem_location:
7814 return "DW_AT_vtable_elem_location";
7815 case DW_AT_allocated:
7816 return "DW_AT_allocated";
7817 case DW_AT_associated:
7818 return "DW_AT_associated";
7819 case DW_AT_data_location:
7820 return "DW_AT_data_location";
7822 return "DW_AT_stride";
7823 case DW_AT_entry_pc:
7824 return "DW_AT_entry_pc";
7825 case DW_AT_use_UTF8:
7826 return "DW_AT_use_UTF8";
7827 case DW_AT_extension:
7828 return "DW_AT_extension";
7830 return "DW_AT_ranges";
7831 case DW_AT_trampoline:
7832 return "DW_AT_trampoline";
7833 case DW_AT_call_column:
7834 return "DW_AT_call_column";
7835 case DW_AT_call_file:
7836 return "DW_AT_call_file";
7837 case DW_AT_call_line:
7838 return "DW_AT_call_line";
7840 case DW_AT_MIPS_fde:
7841 return "DW_AT_MIPS_fde";
7842 case DW_AT_MIPS_loop_begin:
7843 return "DW_AT_MIPS_loop_begin";
7844 case DW_AT_MIPS_tail_loop_begin:
7845 return "DW_AT_MIPS_tail_loop_begin";
7846 case DW_AT_MIPS_epilog_begin:
7847 return "DW_AT_MIPS_epilog_begin";
7848 case DW_AT_MIPS_loop_unroll_factor:
7849 return "DW_AT_MIPS_loop_unroll_factor";
7850 case DW_AT_MIPS_software_pipeline_depth:
7851 return "DW_AT_MIPS_software_pipeline_depth";
7853 case DW_AT_MIPS_linkage_name:
7854 return "DW_AT_MIPS_linkage_name";
7856 case DW_AT_sf_names:
7857 return "DW_AT_sf_names";
7858 case DW_AT_src_info:
7859 return "DW_AT_src_info";
7860 case DW_AT_mac_info:
7861 return "DW_AT_mac_info";
7862 case DW_AT_src_coords:
7863 return "DW_AT_src_coords";
7864 case DW_AT_body_begin:
7865 return "DW_AT_body_begin";
7866 case DW_AT_body_end:
7867 return "DW_AT_body_end";
7868 case DW_AT_GNU_vector:
7869 return "DW_AT_GNU_vector";
7871 return "DW_AT_<unknown>";
7875 /* Convert a DWARF value form code into its string name. */
7878 dwarf_form_name (unsigned form)
7883 return "DW_FORM_addr";
7884 case DW_FORM_block2:
7885 return "DW_FORM_block2";
7886 case DW_FORM_block4:
7887 return "DW_FORM_block4";
7889 return "DW_FORM_data2";
7891 return "DW_FORM_data4";
7893 return "DW_FORM_data8";
7894 case DW_FORM_string:
7895 return "DW_FORM_string";
7897 return "DW_FORM_block";
7898 case DW_FORM_block1:
7899 return "DW_FORM_block1";
7901 return "DW_FORM_data1";
7903 return "DW_FORM_flag";
7905 return "DW_FORM_sdata";
7907 return "DW_FORM_strp";
7909 return "DW_FORM_udata";
7910 case DW_FORM_ref_addr:
7911 return "DW_FORM_ref_addr";
7913 return "DW_FORM_ref1";
7915 return "DW_FORM_ref2";
7917 return "DW_FORM_ref4";
7919 return "DW_FORM_ref8";
7920 case DW_FORM_ref_udata:
7921 return "DW_FORM_ref_udata";
7922 case DW_FORM_indirect:
7923 return "DW_FORM_indirect";
7925 return "DW_FORM_<unknown>";
7929 /* Convert a DWARF stack opcode into its string name. */
7932 dwarf_stack_op_name (unsigned op)
7937 return "DW_OP_addr";
7939 return "DW_OP_deref";
7941 return "DW_OP_const1u";
7943 return "DW_OP_const1s";
7945 return "DW_OP_const2u";
7947 return "DW_OP_const2s";
7949 return "DW_OP_const4u";
7951 return "DW_OP_const4s";
7953 return "DW_OP_const8u";
7955 return "DW_OP_const8s";
7957 return "DW_OP_constu";
7959 return "DW_OP_consts";
7963 return "DW_OP_drop";
7965 return "DW_OP_over";
7967 return "DW_OP_pick";
7969 return "DW_OP_swap";
7973 return "DW_OP_xderef";
7981 return "DW_OP_minus";
7993 return "DW_OP_plus";
7994 case DW_OP_plus_uconst:
7995 return "DW_OP_plus_uconst";
8001 return "DW_OP_shra";
8019 return "DW_OP_skip";
8021 return "DW_OP_lit0";
8023 return "DW_OP_lit1";
8025 return "DW_OP_lit2";
8027 return "DW_OP_lit3";
8029 return "DW_OP_lit4";
8031 return "DW_OP_lit5";
8033 return "DW_OP_lit6";
8035 return "DW_OP_lit7";
8037 return "DW_OP_lit8";
8039 return "DW_OP_lit9";
8041 return "DW_OP_lit10";
8043 return "DW_OP_lit11";
8045 return "DW_OP_lit12";
8047 return "DW_OP_lit13";
8049 return "DW_OP_lit14";
8051 return "DW_OP_lit15";
8053 return "DW_OP_lit16";
8055 return "DW_OP_lit17";
8057 return "DW_OP_lit18";
8059 return "DW_OP_lit19";
8061 return "DW_OP_lit20";
8063 return "DW_OP_lit21";
8065 return "DW_OP_lit22";
8067 return "DW_OP_lit23";
8069 return "DW_OP_lit24";
8071 return "DW_OP_lit25";
8073 return "DW_OP_lit26";
8075 return "DW_OP_lit27";
8077 return "DW_OP_lit28";
8079 return "DW_OP_lit29";
8081 return "DW_OP_lit30";
8083 return "DW_OP_lit31";
8085 return "DW_OP_reg0";
8087 return "DW_OP_reg1";
8089 return "DW_OP_reg2";
8091 return "DW_OP_reg3";
8093 return "DW_OP_reg4";
8095 return "DW_OP_reg5";
8097 return "DW_OP_reg6";
8099 return "DW_OP_reg7";
8101 return "DW_OP_reg8";
8103 return "DW_OP_reg9";
8105 return "DW_OP_reg10";
8107 return "DW_OP_reg11";
8109 return "DW_OP_reg12";
8111 return "DW_OP_reg13";
8113 return "DW_OP_reg14";
8115 return "DW_OP_reg15";
8117 return "DW_OP_reg16";
8119 return "DW_OP_reg17";
8121 return "DW_OP_reg18";
8123 return "DW_OP_reg19";
8125 return "DW_OP_reg20";
8127 return "DW_OP_reg21";
8129 return "DW_OP_reg22";
8131 return "DW_OP_reg23";
8133 return "DW_OP_reg24";
8135 return "DW_OP_reg25";
8137 return "DW_OP_reg26";
8139 return "DW_OP_reg27";
8141 return "DW_OP_reg28";
8143 return "DW_OP_reg29";
8145 return "DW_OP_reg30";
8147 return "DW_OP_reg31";
8149 return "DW_OP_breg0";
8151 return "DW_OP_breg1";
8153 return "DW_OP_breg2";
8155 return "DW_OP_breg3";
8157 return "DW_OP_breg4";
8159 return "DW_OP_breg5";
8161 return "DW_OP_breg6";
8163 return "DW_OP_breg7";
8165 return "DW_OP_breg8";
8167 return "DW_OP_breg9";
8169 return "DW_OP_breg10";
8171 return "DW_OP_breg11";
8173 return "DW_OP_breg12";
8175 return "DW_OP_breg13";
8177 return "DW_OP_breg14";
8179 return "DW_OP_breg15";
8181 return "DW_OP_breg16";
8183 return "DW_OP_breg17";
8185 return "DW_OP_breg18";
8187 return "DW_OP_breg19";
8189 return "DW_OP_breg20";
8191 return "DW_OP_breg21";
8193 return "DW_OP_breg22";
8195 return "DW_OP_breg23";
8197 return "DW_OP_breg24";
8199 return "DW_OP_breg25";
8201 return "DW_OP_breg26";
8203 return "DW_OP_breg27";
8205 return "DW_OP_breg28";
8207 return "DW_OP_breg29";
8209 return "DW_OP_breg30";
8211 return "DW_OP_breg31";
8213 return "DW_OP_regx";
8215 return "DW_OP_fbreg";
8217 return "DW_OP_bregx";
8219 return "DW_OP_piece";
8220 case DW_OP_deref_size:
8221 return "DW_OP_deref_size";
8222 case DW_OP_xderef_size:
8223 return "DW_OP_xderef_size";
8226 /* DWARF 3 extensions. */
8227 case DW_OP_push_object_address:
8228 return "DW_OP_push_object_address";
8230 return "DW_OP_call2";
8232 return "DW_OP_call4";
8233 case DW_OP_call_ref:
8234 return "DW_OP_call_ref";
8235 /* GNU extensions. */
8236 case DW_OP_GNU_push_tls_address:
8237 return "DW_OP_GNU_push_tls_address";
8239 return "OP_<unknown>";
8244 dwarf_bool_name (unsigned mybool)
8252 /* Convert a DWARF type code into its string name. */
8255 dwarf_type_encoding_name (unsigned enc)
8259 case DW_ATE_address:
8260 return "DW_ATE_address";
8261 case DW_ATE_boolean:
8262 return "DW_ATE_boolean";
8263 case DW_ATE_complex_float:
8264 return "DW_ATE_complex_float";
8266 return "DW_ATE_float";
8268 return "DW_ATE_signed";
8269 case DW_ATE_signed_char:
8270 return "DW_ATE_signed_char";
8271 case DW_ATE_unsigned:
8272 return "DW_ATE_unsigned";
8273 case DW_ATE_unsigned_char:
8274 return "DW_ATE_unsigned_char";
8275 case DW_ATE_imaginary_float:
8276 return "DW_ATE_imaginary_float";
8278 return "DW_ATE_<unknown>";
8282 /* Convert a DWARF call frame info operation to its string name. */
8286 dwarf_cfi_name (unsigned cfi_opc)
8290 case DW_CFA_advance_loc:
8291 return "DW_CFA_advance_loc";
8293 return "DW_CFA_offset";
8294 case DW_CFA_restore:
8295 return "DW_CFA_restore";
8297 return "DW_CFA_nop";
8298 case DW_CFA_set_loc:
8299 return "DW_CFA_set_loc";
8300 case DW_CFA_advance_loc1:
8301 return "DW_CFA_advance_loc1";
8302 case DW_CFA_advance_loc2:
8303 return "DW_CFA_advance_loc2";
8304 case DW_CFA_advance_loc4:
8305 return "DW_CFA_advance_loc4";
8306 case DW_CFA_offset_extended:
8307 return "DW_CFA_offset_extended";
8308 case DW_CFA_restore_extended:
8309 return "DW_CFA_restore_extended";
8310 case DW_CFA_undefined:
8311 return "DW_CFA_undefined";
8312 case DW_CFA_same_value:
8313 return "DW_CFA_same_value";
8314 case DW_CFA_register:
8315 return "DW_CFA_register";
8316 case DW_CFA_remember_state:
8317 return "DW_CFA_remember_state";
8318 case DW_CFA_restore_state:
8319 return "DW_CFA_restore_state";
8320 case DW_CFA_def_cfa:
8321 return "DW_CFA_def_cfa";
8322 case DW_CFA_def_cfa_register:
8323 return "DW_CFA_def_cfa_register";
8324 case DW_CFA_def_cfa_offset:
8325 return "DW_CFA_def_cfa_offset";
8328 case DW_CFA_def_cfa_expression:
8329 return "DW_CFA_def_cfa_expression";
8330 case DW_CFA_expression:
8331 return "DW_CFA_expression";
8332 case DW_CFA_offset_extended_sf:
8333 return "DW_CFA_offset_extended_sf";
8334 case DW_CFA_def_cfa_sf:
8335 return "DW_CFA_def_cfa_sf";
8336 case DW_CFA_def_cfa_offset_sf:
8337 return "DW_CFA_def_cfa_offset_sf";
8339 /* SGI/MIPS specific */
8340 case DW_CFA_MIPS_advance_loc8:
8341 return "DW_CFA_MIPS_advance_loc8";
8343 /* GNU extensions */
8344 case DW_CFA_GNU_window_save:
8345 return "DW_CFA_GNU_window_save";
8346 case DW_CFA_GNU_args_size:
8347 return "DW_CFA_GNU_args_size";
8348 case DW_CFA_GNU_negative_offset_extended:
8349 return "DW_CFA_GNU_negative_offset_extended";
8352 return "DW_CFA_<unknown>";
8358 dump_die (struct die_info *die)
8362 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8363 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8364 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8365 dwarf_bool_name (die->child != NULL));
8367 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8368 for (i = 0; i < die->num_attrs; ++i)
8370 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8371 dwarf_attr_name (die->attrs[i].name),
8372 dwarf_form_name (die->attrs[i].form));
8373 switch (die->attrs[i].form)
8375 case DW_FORM_ref_addr:
8377 fprintf_unfiltered (gdb_stderr, "address: ");
8378 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8380 case DW_FORM_block2:
8381 case DW_FORM_block4:
8383 case DW_FORM_block1:
8384 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8389 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8390 (long) (DW_ADDR (&die->attrs[i])));
8398 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8400 case DW_FORM_string:
8402 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8403 DW_STRING (&die->attrs[i])
8404 ? DW_STRING (&die->attrs[i]) : "");
8407 if (DW_UNSND (&die->attrs[i]))
8408 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8410 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8412 case DW_FORM_indirect:
8413 /* the reader will have reduced the indirect form to
8414 the "base form" so this form should not occur */
8415 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8418 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8419 die->attrs[i].form);
8421 fprintf_unfiltered (gdb_stderr, "\n");
8426 dump_die_list (struct die_info *die)
8431 if (die->child != NULL)
8432 dump_die_list (die->child);
8433 if (die->sibling != NULL)
8434 dump_die_list (die->sibling);
8439 store_in_ref_table (unsigned int offset, struct die_info *die,
8440 struct dwarf2_cu *cu)
8443 struct die_info *old;
8445 h = (offset % REF_HASH_SIZE);
8446 old = cu->die_ref_table[h];
8447 die->next_ref = old;
8448 cu->die_ref_table[h] = die;
8452 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8454 unsigned int result = 0;
8458 case DW_FORM_ref_addr:
8463 case DW_FORM_ref_udata:
8464 result = DW_ADDR (attr);
8467 complaint (&symfile_complaints,
8468 _("unsupported die ref attribute form: '%s'"),
8469 dwarf_form_name (attr->form));
8474 /* Return the constant value held by the given attribute. Return -1
8475 if the value held by the attribute is not constant. */
8478 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8480 if (attr->form == DW_FORM_sdata)
8481 return DW_SND (attr);
8482 else if (attr->form == DW_FORM_udata
8483 || attr->form == DW_FORM_data1
8484 || attr->form == DW_FORM_data2
8485 || attr->form == DW_FORM_data4
8486 || attr->form == DW_FORM_data8)
8487 return DW_UNSND (attr);
8490 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8491 dwarf_form_name (attr->form));
8492 return default_value;
8496 static struct die_info *
8497 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8498 struct dwarf2_cu *cu)
8500 struct die_info *die;
8501 unsigned int offset;
8503 struct die_info temp_die;
8504 struct dwarf2_cu *target_cu;
8506 offset = dwarf2_get_ref_die_offset (attr, cu);
8508 if (DW_ADDR (attr) < cu->header.offset
8509 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
8511 struct dwarf2_per_cu_data *per_cu;
8512 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
8514 target_cu = per_cu->cu;
8519 h = (offset % REF_HASH_SIZE);
8520 die = target_cu->die_ref_table[h];
8523 if (die->offset == offset)
8525 die = die->next_ref;
8528 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8529 "at 0x%lx [in module %s]"),
8530 (long) src_die->offset, (long) offset, cu->objfile->name);
8535 static struct type *
8536 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
8537 struct dwarf2_cu *cu)
8539 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
8541 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8542 typeid, objfile->name);
8545 /* Look for this particular type in the fundamental type vector. If
8546 one is not found, create and install one appropriate for the
8547 current language and the current target machine. */
8549 if (cu->ftypes[typeid] == NULL)
8551 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8554 return (cu->ftypes[typeid]);
8557 /* Decode simple location descriptions.
8558 Given a pointer to a dwarf block that defines a location, compute
8559 the location and return the value.
8561 NOTE drow/2003-11-18: This function is called in two situations
8562 now: for the address of static or global variables (partial symbols
8563 only) and for offsets into structures which are expected to be
8564 (more or less) constant. The partial symbol case should go away,
8565 and only the constant case should remain. That will let this
8566 function complain more accurately. A few special modes are allowed
8567 without complaint for global variables (for instance, global
8568 register values and thread-local values).
8570 A location description containing no operations indicates that the
8571 object is optimized out. The return value is 0 for that case.
8572 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8573 callers will only want a very basic result and this can become a
8576 Note that stack[0] is unused except as a default error return.
8577 Note that stack overflow is not yet handled. */
8580 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8582 struct objfile *objfile = cu->objfile;
8583 struct comp_unit_head *cu_header = &cu->header;
8585 int size = blk->size;
8586 gdb_byte *data = blk->data;
8587 CORE_ADDR stack[64];
8589 unsigned int bytes_read, unsnd;
8633 stack[++stacki] = op - DW_OP_lit0;
8668 stack[++stacki] = op - DW_OP_reg0;
8670 dwarf2_complex_location_expr_complaint ();
8674 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8676 stack[++stacki] = unsnd;
8678 dwarf2_complex_location_expr_complaint ();
8682 stack[++stacki] = read_address (objfile->obfd, &data[i],
8688 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8693 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8698 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8703 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8708 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8713 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8718 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8724 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8729 stack[stacki + 1] = stack[stacki];
8734 stack[stacki - 1] += stack[stacki];
8738 case DW_OP_plus_uconst:
8739 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8744 stack[stacki - 1] -= stack[stacki];
8749 /* If we're not the last op, then we definitely can't encode
8750 this using GDB's address_class enum. This is valid for partial
8751 global symbols, although the variable's address will be bogus
8754 dwarf2_complex_location_expr_complaint ();
8757 case DW_OP_GNU_push_tls_address:
8758 /* The top of the stack has the offset from the beginning
8759 of the thread control block at which the variable is located. */
8760 /* Nothing should follow this operator, so the top of stack would
8762 /* This is valid for partial global symbols, but the variable's
8763 address will be bogus in the psymtab. */
8765 dwarf2_complex_location_expr_complaint ();
8769 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
8770 dwarf_stack_op_name (op));
8771 return (stack[stacki]);
8774 return (stack[stacki]);
8777 /* memory allocation interface */
8779 static struct dwarf_block *
8780 dwarf_alloc_block (struct dwarf2_cu *cu)
8782 struct dwarf_block *blk;
8784 blk = (struct dwarf_block *)
8785 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8789 static struct abbrev_info *
8790 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8792 struct abbrev_info *abbrev;
8794 abbrev = (struct abbrev_info *)
8795 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
8796 memset (abbrev, 0, sizeof (struct abbrev_info));
8800 static struct die_info *
8801 dwarf_alloc_die (void)
8803 struct die_info *die;
8805 die = (struct die_info *) xmalloc (sizeof (struct die_info));
8806 memset (die, 0, sizeof (struct die_info));
8811 /* Macro support. */
8814 /* Return the full name of file number I in *LH's file name table.
8815 Use COMP_DIR as the name of the current directory of the
8816 compilation. The result is allocated using xmalloc; the caller is
8817 responsible for freeing it. */
8819 file_full_name (int file, struct line_header *lh, const char *comp_dir)
8821 /* Is the file number a valid index into the line header's file name
8822 table? Remember that file numbers start with one, not zero. */
8823 if (1 <= file && file <= lh->num_file_names)
8825 struct file_entry *fe = &lh->file_names[file - 1];
8827 if (IS_ABSOLUTE_PATH (fe->name))
8828 return xstrdup (fe->name);
8836 dir = lh->include_dirs[fe->dir_index - 1];
8842 dir_len = strlen (dir);
8843 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
8844 strcpy (full_name, dir);
8845 full_name[dir_len] = '/';
8846 strcpy (full_name + dir_len + 1, fe->name);
8850 return xstrdup (fe->name);
8855 /* The compiler produced a bogus file number. We can at least
8856 record the macro definitions made in the file, even if we
8857 won't be able to find the file by name. */
8859 sprintf (fake_name, "<bad macro file number %d>", file);
8861 complaint (&symfile_complaints,
8862 _("bad file number in macro information (%d)"),
8865 return xstrdup (fake_name);
8870 static struct macro_source_file *
8871 macro_start_file (int file, int line,
8872 struct macro_source_file *current_file,
8873 const char *comp_dir,
8874 struct line_header *lh, struct objfile *objfile)
8876 /* The full name of this source file. */
8877 char *full_name = file_full_name (file, lh, comp_dir);
8879 /* We don't create a macro table for this compilation unit
8880 at all until we actually get a filename. */
8881 if (! pending_macros)
8882 pending_macros = new_macro_table (&objfile->objfile_obstack,
8883 objfile->macro_cache);
8886 /* If we have no current file, then this must be the start_file
8887 directive for the compilation unit's main source file. */
8888 current_file = macro_set_main (pending_macros, full_name);
8890 current_file = macro_include (current_file, line, full_name);
8894 return current_file;
8898 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8899 followed by a null byte. */
8901 copy_string (const char *buf, int len)
8903 char *s = xmalloc (len + 1);
8904 memcpy (s, buf, len);
8912 consume_improper_spaces (const char *p, const char *body)
8916 complaint (&symfile_complaints,
8917 _("macro definition contains spaces in formal argument list:\n`%s'"),
8929 parse_macro_definition (struct macro_source_file *file, int line,
8934 /* The body string takes one of two forms. For object-like macro
8935 definitions, it should be:
8937 <macro name> " " <definition>
8939 For function-like macro definitions, it should be:
8941 <macro name> "() " <definition>
8943 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8945 Spaces may appear only where explicitly indicated, and in the
8948 The Dwarf 2 spec says that an object-like macro's name is always
8949 followed by a space, but versions of GCC around March 2002 omit
8950 the space when the macro's definition is the empty string.
8952 The Dwarf 2 spec says that there should be no spaces between the
8953 formal arguments in a function-like macro's formal argument list,
8954 but versions of GCC around March 2002 include spaces after the
8958 /* Find the extent of the macro name. The macro name is terminated
8959 by either a space or null character (for an object-like macro) or
8960 an opening paren (for a function-like macro). */
8961 for (p = body; *p; p++)
8962 if (*p == ' ' || *p == '(')
8965 if (*p == ' ' || *p == '\0')
8967 /* It's an object-like macro. */
8968 int name_len = p - body;
8969 char *name = copy_string (body, name_len);
8970 const char *replacement;
8973 replacement = body + name_len + 1;
8976 dwarf2_macro_malformed_definition_complaint (body);
8977 replacement = body + name_len;
8980 macro_define_object (file, line, name, replacement);
8986 /* It's a function-like macro. */
8987 char *name = copy_string (body, p - body);
8990 char **argv = xmalloc (argv_size * sizeof (*argv));
8994 p = consume_improper_spaces (p, body);
8996 /* Parse the formal argument list. */
8997 while (*p && *p != ')')
8999 /* Find the extent of the current argument name. */
9000 const char *arg_start = p;
9002 while (*p && *p != ',' && *p != ')' && *p != ' ')
9005 if (! *p || p == arg_start)
9006 dwarf2_macro_malformed_definition_complaint (body);
9009 /* Make sure argv has room for the new argument. */
9010 if (argc >= argv_size)
9013 argv = xrealloc (argv, argv_size * sizeof (*argv));
9016 argv[argc++] = copy_string (arg_start, p - arg_start);
9019 p = consume_improper_spaces (p, body);
9021 /* Consume the comma, if present. */
9026 p = consume_improper_spaces (p, body);
9035 /* Perfectly formed definition, no complaints. */
9036 macro_define_function (file, line, name,
9037 argc, (const char **) argv,
9039 else if (*p == '\0')
9041 /* Complain, but do define it. */
9042 dwarf2_macro_malformed_definition_complaint (body);
9043 macro_define_function (file, line, name,
9044 argc, (const char **) argv,
9048 /* Just complain. */
9049 dwarf2_macro_malformed_definition_complaint (body);
9052 /* Just complain. */
9053 dwarf2_macro_malformed_definition_complaint (body);
9059 for (i = 0; i < argc; i++)
9065 dwarf2_macro_malformed_definition_complaint (body);
9070 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9071 char *comp_dir, bfd *abfd,
9072 struct dwarf2_cu *cu)
9074 gdb_byte *mac_ptr, *mac_end;
9075 struct macro_source_file *current_file = 0;
9077 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9079 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9083 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9084 mac_end = dwarf2_per_objfile->macinfo_buffer
9085 + dwarf2_per_objfile->macinfo_size;
9089 enum dwarf_macinfo_record_type macinfo_type;
9091 /* Do we at least have room for a macinfo type byte? */
9092 if (mac_ptr >= mac_end)
9094 dwarf2_macros_too_long_complaint ();
9098 macinfo_type = read_1_byte (abfd, mac_ptr);
9101 switch (macinfo_type)
9103 /* A zero macinfo type indicates the end of the macro
9108 case DW_MACINFO_define:
9109 case DW_MACINFO_undef:
9111 unsigned int bytes_read;
9115 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9116 mac_ptr += bytes_read;
9117 body = read_string (abfd, mac_ptr, &bytes_read);
9118 mac_ptr += bytes_read;
9121 complaint (&symfile_complaints,
9122 _("debug info gives macro %s outside of any file: %s"),
9124 DW_MACINFO_define ? "definition" : macinfo_type ==
9125 DW_MACINFO_undef ? "undefinition" :
9126 "something-or-other", body);
9129 if (macinfo_type == DW_MACINFO_define)
9130 parse_macro_definition (current_file, line, body);
9131 else if (macinfo_type == DW_MACINFO_undef)
9132 macro_undef (current_file, line, body);
9137 case DW_MACINFO_start_file:
9139 unsigned int bytes_read;
9142 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9143 mac_ptr += bytes_read;
9144 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9145 mac_ptr += bytes_read;
9147 current_file = macro_start_file (file, line,
9148 current_file, comp_dir,
9153 case DW_MACINFO_end_file:
9155 complaint (&symfile_complaints,
9156 _("macro debug info has an unmatched `close_file' directive"));
9159 current_file = current_file->included_by;
9162 enum dwarf_macinfo_record_type next_type;
9164 /* GCC circa March 2002 doesn't produce the zero
9165 type byte marking the end of the compilation
9166 unit. Complain if it's not there, but exit no
9169 /* Do we at least have room for a macinfo type byte? */
9170 if (mac_ptr >= mac_end)
9172 dwarf2_macros_too_long_complaint ();
9176 /* We don't increment mac_ptr here, so this is just
9178 next_type = read_1_byte (abfd, mac_ptr);
9180 complaint (&symfile_complaints,
9181 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9188 case DW_MACINFO_vendor_ext:
9190 unsigned int bytes_read;
9194 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9195 mac_ptr += bytes_read;
9196 string = read_string (abfd, mac_ptr, &bytes_read);
9197 mac_ptr += bytes_read;
9199 /* We don't recognize any vendor extensions. */
9206 /* Check if the attribute's form is a DW_FORM_block*
9207 if so return true else false. */
9209 attr_form_is_block (struct attribute *attr)
9211 return (attr == NULL ? 0 :
9212 attr->form == DW_FORM_block1
9213 || attr->form == DW_FORM_block2
9214 || attr->form == DW_FORM_block4
9215 || attr->form == DW_FORM_block);
9219 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9220 struct dwarf2_cu *cu)
9222 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9224 struct dwarf2_loclist_baton *baton;
9226 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9227 sizeof (struct dwarf2_loclist_baton));
9228 baton->objfile = cu->objfile;
9230 /* We don't know how long the location list is, but make sure we
9231 don't run off the edge of the section. */
9232 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9233 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9234 baton->base_address = cu->header.base_address;
9235 if (cu->header.base_known == 0)
9236 complaint (&symfile_complaints,
9237 _("Location list used without specifying the CU base address."));
9239 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9240 SYMBOL_LOCATION_BATON (sym) = baton;
9244 struct dwarf2_locexpr_baton *baton;
9246 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9247 sizeof (struct dwarf2_locexpr_baton));
9248 baton->objfile = cu->objfile;
9250 if (attr_form_is_block (attr))
9252 /* Note that we're just copying the block's data pointer
9253 here, not the actual data. We're still pointing into the
9254 info_buffer for SYM's objfile; right now we never release
9255 that buffer, but when we do clean up properly this may
9257 baton->size = DW_BLOCK (attr)->size;
9258 baton->data = DW_BLOCK (attr)->data;
9262 dwarf2_invalid_attrib_class_complaint ("location description",
9263 SYMBOL_NATURAL_NAME (sym));
9268 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9269 SYMBOL_LOCATION_BATON (sym) = baton;
9273 /* Locate the compilation unit from CU's objfile which contains the
9274 DIE at OFFSET. Raises an error on failure. */
9276 static struct dwarf2_per_cu_data *
9277 dwarf2_find_containing_comp_unit (unsigned long offset,
9278 struct objfile *objfile)
9280 struct dwarf2_per_cu_data *this_cu;
9284 high = dwarf2_per_objfile->n_comp_units - 1;
9287 int mid = low + (high - low) / 2;
9288 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9293 gdb_assert (low == high);
9294 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9297 error (_("Dwarf Error: could not find partial DIE containing "
9298 "offset 0x%lx [in module %s]"),
9299 (long) offset, bfd_get_filename (objfile->obfd));
9301 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9302 return dwarf2_per_objfile->all_comp_units[low-1];
9306 this_cu = dwarf2_per_objfile->all_comp_units[low];
9307 if (low == dwarf2_per_objfile->n_comp_units - 1
9308 && offset >= this_cu->offset + this_cu->length)
9309 error (_("invalid dwarf2 offset %ld"), offset);
9310 gdb_assert (offset < this_cu->offset + this_cu->length);
9315 /* Locate the compilation unit from OBJFILE which is located at exactly
9316 OFFSET. Raises an error on failure. */
9318 static struct dwarf2_per_cu_data *
9319 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9321 struct dwarf2_per_cu_data *this_cu;
9322 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9323 if (this_cu->offset != offset)
9324 error (_("no compilation unit with offset %ld."), offset);
9328 /* Release one cached compilation unit, CU. We unlink it from the tree
9329 of compilation units, but we don't remove it from the read_in_chain;
9330 the caller is responsible for that. */
9333 free_one_comp_unit (void *data)
9335 struct dwarf2_cu *cu = data;
9337 if (cu->per_cu != NULL)
9338 cu->per_cu->cu = NULL;
9341 obstack_free (&cu->comp_unit_obstack, NULL);
9343 free_die_list (cu->dies);
9348 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9349 when we're finished with it. We can't free the pointer itself, but be
9350 sure to unlink it from the cache. Also release any associated storage
9351 and perform cache maintenance.
9353 Only used during partial symbol parsing. */
9356 free_stack_comp_unit (void *data)
9358 struct dwarf2_cu *cu = data;
9360 obstack_free (&cu->comp_unit_obstack, NULL);
9361 cu->partial_dies = NULL;
9363 if (cu->per_cu != NULL)
9365 /* This compilation unit is on the stack in our caller, so we
9366 should not xfree it. Just unlink it. */
9367 cu->per_cu->cu = NULL;
9370 /* If we had a per-cu pointer, then we may have other compilation
9371 units loaded, so age them now. */
9372 age_cached_comp_units ();
9376 /* Free all cached compilation units. */
9379 free_cached_comp_units (void *data)
9381 struct dwarf2_per_cu_data *per_cu, **last_chain;
9383 per_cu = dwarf2_per_objfile->read_in_chain;
9384 last_chain = &dwarf2_per_objfile->read_in_chain;
9385 while (per_cu != NULL)
9387 struct dwarf2_per_cu_data *next_cu;
9389 next_cu = per_cu->cu->read_in_chain;
9391 free_one_comp_unit (per_cu->cu);
9392 *last_chain = next_cu;
9398 /* Increase the age counter on each cached compilation unit, and free
9399 any that are too old. */
9402 age_cached_comp_units (void)
9404 struct dwarf2_per_cu_data *per_cu, **last_chain;
9406 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9407 per_cu = dwarf2_per_objfile->read_in_chain;
9408 while (per_cu != NULL)
9410 per_cu->cu->last_used ++;
9411 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9412 dwarf2_mark (per_cu->cu);
9413 per_cu = per_cu->cu->read_in_chain;
9416 per_cu = dwarf2_per_objfile->read_in_chain;
9417 last_chain = &dwarf2_per_objfile->read_in_chain;
9418 while (per_cu != NULL)
9420 struct dwarf2_per_cu_data *next_cu;
9422 next_cu = per_cu->cu->read_in_chain;
9424 if (!per_cu->cu->mark)
9426 free_one_comp_unit (per_cu->cu);
9427 *last_chain = next_cu;
9430 last_chain = &per_cu->cu->read_in_chain;
9436 /* Remove a single compilation unit from the cache. */
9439 free_one_cached_comp_unit (void *target_cu)
9441 struct dwarf2_per_cu_data *per_cu, **last_chain;
9443 per_cu = dwarf2_per_objfile->read_in_chain;
9444 last_chain = &dwarf2_per_objfile->read_in_chain;
9445 while (per_cu != NULL)
9447 struct dwarf2_per_cu_data *next_cu;
9449 next_cu = per_cu->cu->read_in_chain;
9451 if (per_cu->cu == target_cu)
9453 free_one_comp_unit (per_cu->cu);
9454 *last_chain = next_cu;
9458 last_chain = &per_cu->cu->read_in_chain;
9464 /* A pair of DIE offset and GDB type pointer. We store these
9465 in a hash table separate from the DIEs, and preserve them
9466 when the DIEs are flushed out of cache. */
9468 struct dwarf2_offset_and_type
9470 unsigned int offset;
9474 /* Hash function for a dwarf2_offset_and_type. */
9477 offset_and_type_hash (const void *item)
9479 const struct dwarf2_offset_and_type *ofs = item;
9483 /* Equality function for a dwarf2_offset_and_type. */
9486 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9488 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9489 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9490 return ofs_lhs->offset == ofs_rhs->offset;
9493 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9494 table if necessary. */
9497 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
9499 struct dwarf2_offset_and_type **slot, ofs;
9503 if (cu->per_cu == NULL)
9506 if (cu->per_cu->type_hash == NULL)
9507 cu->per_cu->type_hash
9508 = htab_create_alloc_ex (cu->header.length / 24,
9509 offset_and_type_hash,
9512 &cu->objfile->objfile_obstack,
9513 hashtab_obstack_allocate,
9514 dummy_obstack_deallocate);
9516 ofs.offset = die->offset;
9518 slot = (struct dwarf2_offset_and_type **)
9519 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
9520 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
9524 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9525 have a saved type. */
9527 static struct type *
9528 get_die_type (struct die_info *die, htab_t type_hash)
9530 struct dwarf2_offset_and_type *slot, ofs;
9532 ofs.offset = die->offset;
9533 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
9540 /* Restore the types of the DIE tree starting at START_DIE from the hash
9541 table saved in CU. */
9544 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
9546 struct die_info *die;
9548 if (cu->per_cu->type_hash == NULL)
9551 for (die = start_die; die != NULL; die = die->sibling)
9553 die->type = get_die_type (die, cu->per_cu->type_hash);
9554 if (die->child != NULL)
9555 reset_die_and_siblings_types (die->child, cu);
9559 /* Set the mark field in CU and in every other compilation unit in the
9560 cache that we must keep because we are keeping CU. */
9562 /* Add a dependence relationship from CU to REF_PER_CU. */
9565 dwarf2_add_dependence (struct dwarf2_cu *cu,
9566 struct dwarf2_per_cu_data *ref_per_cu)
9570 if (cu->dependencies == NULL)
9572 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
9573 NULL, &cu->comp_unit_obstack,
9574 hashtab_obstack_allocate,
9575 dummy_obstack_deallocate);
9577 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
9582 /* Set the mark field in CU and in every other compilation unit in the
9583 cache that we must keep because we are keeping CU. */
9586 dwarf2_mark_helper (void **slot, void *data)
9588 struct dwarf2_per_cu_data *per_cu;
9590 per_cu = (struct dwarf2_per_cu_data *) *slot;
9591 if (per_cu->cu->mark)
9593 per_cu->cu->mark = 1;
9595 if (per_cu->cu->dependencies != NULL)
9596 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
9602 dwarf2_mark (struct dwarf2_cu *cu)
9607 if (cu->dependencies != NULL)
9608 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
9612 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
9616 per_cu->cu->mark = 0;
9617 per_cu = per_cu->cu->read_in_chain;
9621 /* Trivial hash function for partial_die_info: the hash value of a DIE
9622 is its offset in .debug_info for this objfile. */
9625 partial_die_hash (const void *item)
9627 const struct partial_die_info *part_die = item;
9628 return part_die->offset;
9631 /* Trivial comparison function for partial_die_info structures: two DIEs
9632 are equal if they have the same offset. */
9635 partial_die_eq (const void *item_lhs, const void *item_rhs)
9637 const struct partial_die_info *part_die_lhs = item_lhs;
9638 const struct partial_die_info *part_die_rhs = item_rhs;
9639 return part_die_lhs->offset == part_die_rhs->offset;
9642 static struct cmd_list_element *set_dwarf2_cmdlist;
9643 static struct cmd_list_element *show_dwarf2_cmdlist;
9646 set_dwarf2_cmd (char *args, int from_tty)
9648 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
9652 show_dwarf2_cmd (char *args, int from_tty)
9654 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
9657 void _initialize_dwarf2_read (void);
9660 _initialize_dwarf2_read (void)
9662 dwarf2_objfile_data_key = register_objfile_data ();
9664 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
9665 Set DWARF 2 specific variables.\n\
9666 Configure DWARF 2 variables such as the cache size"),
9667 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
9668 0/*allow-unknown*/, &maintenance_set_cmdlist);
9670 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
9671 Show DWARF 2 specific variables\n\
9672 Show DWARF 2 variables such as the cache size"),
9673 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
9674 0/*allow-unknown*/, &maintenance_show_cmdlist);
9676 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
9677 &dwarf2_max_cache_age, _("\
9678 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9679 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9680 A higher limit means that cached compilation units will be stored\n\
9681 in memory longer, and more total memory will be used. Zero disables\n\
9682 caching, which can slow down startup."),
9684 show_dwarf2_max_cache_age,
9685 &set_dwarf2_cmdlist,
9686 &show_dwarf2_cmdlist);