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**30-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 : 30;
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 /* This flag will be set if we need to load absolutely all DIEs
374 for this compilation unit, instead of just the ones we think
375 are interesting. It gets set if we look for a DIE in the
376 hash table and don't find it. */
377 unsigned int load_all_dies : 1;
379 /* Set iff currently read in. */
380 struct dwarf2_cu *cu;
382 /* If full symbols for this CU have been read in, then this field
383 holds a map of DIE offsets to types. It isn't always possible
384 to reconstruct this information later, so we have to preserve
388 /* The partial symbol table associated with this compilation unit. */
389 struct partial_symtab *psymtab;
392 /* The line number information for a compilation unit (found in the
393 .debug_line section) begins with a "statement program header",
394 which contains the following information. */
397 unsigned int total_length;
398 unsigned short version;
399 unsigned int header_length;
400 unsigned char minimum_instruction_length;
401 unsigned char default_is_stmt;
403 unsigned char line_range;
404 unsigned char opcode_base;
406 /* standard_opcode_lengths[i] is the number of operands for the
407 standard opcode whose value is i. This means that
408 standard_opcode_lengths[0] is unused, and the last meaningful
409 element is standard_opcode_lengths[opcode_base - 1]. */
410 unsigned char *standard_opcode_lengths;
412 /* The include_directories table. NOTE! These strings are not
413 allocated with xmalloc; instead, they are pointers into
414 debug_line_buffer. If you try to free them, `free' will get
416 unsigned int num_include_dirs, include_dirs_size;
419 /* The file_names table. NOTE! These strings are not allocated
420 with xmalloc; instead, they are pointers into debug_line_buffer.
421 Don't try to free them directly. */
422 unsigned int num_file_names, file_names_size;
426 unsigned int dir_index;
427 unsigned int mod_time;
429 int included_p; /* Non-zero if referenced by the Line Number Program. */
432 /* The start and end of the statement program following this
433 header. These point into dwarf2_per_objfile->line_buffer. */
434 gdb_byte *statement_program_start, *statement_program_end;
437 /* When we construct a partial symbol table entry we only
438 need this much information. */
439 struct partial_die_info
441 /* Offset of this DIE. */
444 /* DWARF-2 tag for this DIE. */
445 ENUM_BITFIELD(dwarf_tag) tag : 16;
447 /* Language code associated with this DIE. This is only used
448 for the compilation unit DIE. */
449 unsigned int language : 8;
451 /* Assorted flags describing the data found in this DIE. */
452 unsigned int has_children : 1;
453 unsigned int is_external : 1;
454 unsigned int is_declaration : 1;
455 unsigned int has_type : 1;
456 unsigned int has_specification : 1;
457 unsigned int has_stmt_list : 1;
458 unsigned int has_pc_info : 1;
460 /* Flag set if the SCOPE field of this structure has been
462 unsigned int scope_set : 1;
464 /* The name of this DIE. Normally the value of DW_AT_name, but
465 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
470 /* The scope to prepend to our children. This is generally
471 allocated on the comp_unit_obstack, so will disappear
472 when this compilation unit leaves the cache. */
475 /* The location description associated with this DIE, if any. */
476 struct dwarf_block *locdesc;
478 /* If HAS_PC_INFO, the PC range associated with this DIE. */
482 /* Pointer into the info_buffer pointing at the target of
483 DW_AT_sibling, if any. */
486 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
487 DW_AT_specification (or DW_AT_abstract_origin or
489 unsigned int spec_offset;
491 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
492 unsigned int line_offset;
494 /* Pointers to this DIE's parent, first child, and next sibling,
496 struct partial_die_info *die_parent, *die_child, *die_sibling;
499 /* This data structure holds the information of an abbrev. */
502 unsigned int number; /* number identifying abbrev */
503 enum dwarf_tag tag; /* dwarf tag */
504 unsigned short has_children; /* boolean */
505 unsigned short num_attrs; /* number of attributes */
506 struct attr_abbrev *attrs; /* an array of attribute descriptions */
507 struct abbrev_info *next; /* next in chain */
512 enum dwarf_attribute name;
513 enum dwarf_form form;
516 /* This data structure holds a complete die structure. */
519 enum dwarf_tag tag; /* Tag indicating type of die */
520 unsigned int abbrev; /* Abbrev number */
521 unsigned int offset; /* Offset in .debug_info section */
522 unsigned int num_attrs; /* Number of attributes */
523 struct attribute *attrs; /* An array of attributes */
524 struct die_info *next_ref; /* Next die in ref hash table */
526 /* The dies in a compilation unit form an n-ary tree. PARENT
527 points to this die's parent; CHILD points to the first child of
528 this node; and all the children of a given node are chained
529 together via their SIBLING fields, terminated by a die whose
531 struct die_info *child; /* Its first child, if any. */
532 struct die_info *sibling; /* Its next sibling, if any. */
533 struct die_info *parent; /* Its parent, if any. */
535 struct type *type; /* Cached type information */
538 /* Attributes have a name and a value */
541 enum dwarf_attribute name;
542 enum dwarf_form form;
546 struct dwarf_block *blk;
554 struct function_range
557 CORE_ADDR lowpc, highpc;
559 struct function_range *next;
562 /* Get at parts of an attribute structure */
564 #define DW_STRING(attr) ((attr)->u.str)
565 #define DW_UNSND(attr) ((attr)->u.unsnd)
566 #define DW_BLOCK(attr) ((attr)->u.blk)
567 #define DW_SND(attr) ((attr)->u.snd)
568 #define DW_ADDR(attr) ((attr)->u.addr)
570 /* Blocks are a bunch of untyped bytes. */
577 #ifndef ATTR_ALLOC_CHUNK
578 #define ATTR_ALLOC_CHUNK 4
581 /* Allocate fields for structs, unions and enums in this size. */
582 #ifndef DW_FIELD_ALLOC_CHUNK
583 #define DW_FIELD_ALLOC_CHUNK 4
586 /* A zeroed version of a partial die for initialization purposes. */
587 static struct partial_die_info zeroed_partial_die;
589 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
590 but this would require a corresponding change in unpack_field_as_long
592 static int bits_per_byte = 8;
594 /* The routines that read and process dies for a C struct or C++ class
595 pass lists of data member fields and lists of member function fields
596 in an instance of a field_info structure, as defined below. */
599 /* List of data member and baseclasses fields. */
602 struct nextfield *next;
607 *fields, *baseclasses;
609 /* Number of fields (including baseclasses). */
612 /* Number of baseclasses. */
615 /* Set if the accesibility of one of the fields is not public. */
616 int non_public_fields;
618 /* Member function fields array, entries are allocated in the order they
619 are encountered in the object file. */
622 struct nextfnfield *next;
623 struct fn_field fnfield;
627 /* Member function fieldlist array, contains name of possibly overloaded
628 member function, number of overloaded member functions and a pointer
629 to the head of the member function field chain. */
634 struct nextfnfield *head;
638 /* Number of entries in the fnfieldlists array. */
642 /* One item on the queue of compilation units to read in full symbols
644 struct dwarf2_queue_item
646 struct dwarf2_per_cu_data *per_cu;
647 struct dwarf2_queue_item *next;
650 /* The current queue. */
651 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
653 /* Loaded secondary compilation units are kept in memory until they
654 have not been referenced for the processing of this many
655 compilation units. Set this to zero to disable caching. Cache
656 sizes of up to at least twenty will improve startup time for
657 typical inter-CU-reference binaries, at an obvious memory cost. */
658 static int dwarf2_max_cache_age = 5;
660 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
661 struct cmd_list_element *c, const char *value)
663 fprintf_filtered (file, _("\
664 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
669 /* Various complaints about symbol reading that don't abort the process */
672 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
674 complaint (&symfile_complaints,
675 _("statement list doesn't fit in .debug_line section"));
679 dwarf2_complex_location_expr_complaint (void)
681 complaint (&symfile_complaints, _("location expression too complex"));
685 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
688 complaint (&symfile_complaints,
689 _("const value length mismatch for '%s', got %d, expected %d"), arg1,
694 dwarf2_macros_too_long_complaint (void)
696 complaint (&symfile_complaints,
697 _("macro info runs off end of `.debug_macinfo' section"));
701 dwarf2_macro_malformed_definition_complaint (const char *arg1)
703 complaint (&symfile_complaints,
704 _("macro debug info contains a malformed macro definition:\n`%s'"),
709 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
711 complaint (&symfile_complaints,
712 _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
715 /* local function prototypes */
717 static void dwarf2_locate_sections (bfd *, asection *, void *);
720 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
723 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
726 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
727 struct partial_die_info *,
728 struct partial_symtab *);
730 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
732 static void scan_partial_symbols (struct partial_die_info *,
733 CORE_ADDR *, CORE_ADDR *,
736 static void add_partial_symbol (struct partial_die_info *,
739 static int pdi_needs_namespace (enum dwarf_tag tag);
741 static void add_partial_namespace (struct partial_die_info *pdi,
742 CORE_ADDR *lowpc, CORE_ADDR *highpc,
743 struct dwarf2_cu *cu);
745 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
746 struct dwarf2_cu *cu);
748 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
751 struct dwarf2_cu *cu);
753 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
755 static void psymtab_to_symtab_1 (struct partial_symtab *);
757 gdb_byte *dwarf2_read_section (struct objfile *, asection *);
759 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
761 static void dwarf2_free_abbrev_table (void *);
763 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
766 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
769 static struct partial_die_info *load_partial_dies (bfd *, gdb_byte *, int,
772 static gdb_byte *read_partial_die (struct partial_die_info *,
773 struct abbrev_info *abbrev, unsigned int,
774 bfd *, gdb_byte *, struct dwarf2_cu *);
776 static struct partial_die_info *find_partial_die (unsigned long,
779 static void fixup_partial_die (struct partial_die_info *,
782 static gdb_byte *read_full_die (struct die_info **, bfd *, gdb_byte *,
783 struct dwarf2_cu *, int *);
785 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
786 bfd *, gdb_byte *, struct dwarf2_cu *);
788 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
789 bfd *, gdb_byte *, struct dwarf2_cu *);
791 static unsigned int read_1_byte (bfd *, gdb_byte *);
793 static int read_1_signed_byte (bfd *, gdb_byte *);
795 static unsigned int read_2_bytes (bfd *, gdb_byte *);
797 static unsigned int read_4_bytes (bfd *, gdb_byte *);
799 static unsigned long read_8_bytes (bfd *, gdb_byte *);
801 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
804 static LONGEST read_initial_length (bfd *, gdb_byte *,
805 struct comp_unit_head *, unsigned int *);
807 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
810 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
812 static char *read_string (bfd *, gdb_byte *, unsigned int *);
814 static char *read_indirect_string (bfd *, gdb_byte *,
815 const struct comp_unit_head *,
818 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
820 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
822 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
824 static void set_cu_language (unsigned int, struct dwarf2_cu *);
826 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
829 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
830 struct dwarf2_cu *cu);
832 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
834 static struct die_info *die_specification (struct die_info *die,
837 static void free_line_header (struct line_header *lh);
839 static void add_file_name (struct line_header *, char *, unsigned int,
840 unsigned int, unsigned int);
842 static struct line_header *(dwarf_decode_line_header
843 (unsigned int offset,
844 bfd *abfd, struct dwarf2_cu *cu));
846 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
847 struct dwarf2_cu *, struct partial_symtab *);
849 static void dwarf2_start_subfile (char *, char *);
851 static struct symbol *new_symbol (struct die_info *, struct type *,
854 static void dwarf2_const_value (struct attribute *, struct symbol *,
857 static void dwarf2_const_value_data (struct attribute *attr,
861 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
863 static struct type *die_containing_type (struct die_info *,
866 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
868 static void read_type_die (struct die_info *, struct dwarf2_cu *);
870 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
872 static char *typename_concat (struct obstack *,
877 static void read_typedef (struct die_info *, struct dwarf2_cu *);
879 static void read_base_type (struct die_info *, struct dwarf2_cu *);
881 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
883 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
885 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
887 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
889 static int dwarf2_get_pc_bounds (struct die_info *,
890 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
892 static void get_scope_pc_bounds (struct die_info *,
893 CORE_ADDR *, CORE_ADDR *,
896 static void dwarf2_add_field (struct field_info *, struct die_info *,
899 static void dwarf2_attach_fields_to_type (struct field_info *,
900 struct type *, struct dwarf2_cu *);
902 static void dwarf2_add_member_fn (struct field_info *,
903 struct die_info *, struct type *,
906 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
907 struct type *, struct dwarf2_cu *);
909 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
911 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
913 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
915 static void read_common_block (struct die_info *, struct dwarf2_cu *);
917 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
919 static const char *namespace_name (struct die_info *die,
920 int *is_anonymous, struct dwarf2_cu *);
922 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
924 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
926 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
928 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
930 static void read_array_type (struct die_info *, struct dwarf2_cu *);
932 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
935 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
937 static void read_tag_ptr_to_member_type (struct die_info *,
940 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
942 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
944 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
946 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
948 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
950 static struct die_info *read_comp_unit (gdb_byte *, bfd *, struct dwarf2_cu *);
952 static struct die_info *read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
954 gdb_byte **new_info_ptr,
955 struct die_info *parent);
957 static struct die_info *read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
959 gdb_byte **new_info_ptr,
960 struct die_info *parent);
962 static void free_die_list (struct die_info *);
964 static void process_die (struct die_info *, struct dwarf2_cu *);
966 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
968 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
970 static struct die_info *dwarf2_extension (struct die_info *die,
973 static char *dwarf_tag_name (unsigned int);
975 static char *dwarf_attr_name (unsigned int);
977 static char *dwarf_form_name (unsigned int);
979 static char *dwarf_stack_op_name (unsigned int);
981 static char *dwarf_bool_name (unsigned int);
983 static char *dwarf_type_encoding_name (unsigned int);
986 static char *dwarf_cfi_name (unsigned int);
988 struct die_info *copy_die (struct die_info *);
991 static struct die_info *sibling_die (struct die_info *);
993 static void dump_die (struct die_info *);
995 static void dump_die_list (struct die_info *);
997 static void store_in_ref_table (unsigned int, struct die_info *,
1000 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
1001 struct dwarf2_cu *);
1003 static int dwarf2_get_attr_constant_value (struct attribute *, int);
1005 static struct die_info *follow_die_ref (struct die_info *,
1007 struct dwarf2_cu *);
1009 static struct type *dwarf2_fundamental_type (struct objfile *, int,
1010 struct dwarf2_cu *);
1012 /* memory allocation interface */
1014 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1016 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1018 static struct die_info *dwarf_alloc_die (void);
1020 static void initialize_cu_func_list (struct dwarf2_cu *);
1022 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1023 struct dwarf2_cu *);
1025 static void dwarf_decode_macros (struct line_header *, unsigned int,
1026 char *, bfd *, struct dwarf2_cu *);
1028 static int attr_form_is_block (struct attribute *);
1031 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
1032 struct dwarf2_cu *cu);
1034 static gdb_byte *skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
1035 struct dwarf2_cu *cu);
1037 static void free_stack_comp_unit (void *);
1039 static hashval_t partial_die_hash (const void *item);
1041 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1043 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1044 (unsigned long offset, struct objfile *objfile);
1046 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1047 (unsigned long offset, struct objfile *objfile);
1049 static void free_one_comp_unit (void *);
1051 static void free_cached_comp_units (void *);
1053 static void age_cached_comp_units (void);
1055 static void free_one_cached_comp_unit (void *);
1057 static void set_die_type (struct die_info *, struct type *,
1058 struct dwarf2_cu *);
1060 static void reset_die_and_siblings_types (struct die_info *,
1061 struct dwarf2_cu *);
1063 static void create_all_comp_units (struct objfile *);
1065 static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *);
1067 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1069 static void dwarf2_add_dependence (struct dwarf2_cu *,
1070 struct dwarf2_per_cu_data *);
1072 static void dwarf2_mark (struct dwarf2_cu *);
1074 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1076 /* Try to locate the sections we need for DWARF 2 debugging
1077 information and return true if we have enough to do something. */
1080 dwarf2_has_info (struct objfile *objfile)
1082 struct dwarf2_per_objfile *data;
1084 /* Initialize per-objfile state. */
1085 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1086 memset (data, 0, sizeof (*data));
1087 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1088 dwarf2_per_objfile = data;
1090 dwarf_info_section = 0;
1091 dwarf_abbrev_section = 0;
1092 dwarf_line_section = 0;
1093 dwarf_str_section = 0;
1094 dwarf_macinfo_section = 0;
1095 dwarf_frame_section = 0;
1096 dwarf_eh_frame_section = 0;
1097 dwarf_ranges_section = 0;
1098 dwarf_loc_section = 0;
1100 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1101 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
1104 /* This function is mapped across the sections and remembers the
1105 offset and size of each of the debugging sections we are interested
1109 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
1111 if (strcmp (sectp->name, INFO_SECTION) == 0)
1113 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1114 dwarf_info_section = sectp;
1116 else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1118 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1119 dwarf_abbrev_section = sectp;
1121 else if (strcmp (sectp->name, LINE_SECTION) == 0)
1123 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1124 dwarf_line_section = sectp;
1126 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1128 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1129 dwarf_pubnames_section = sectp;
1131 else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1133 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1134 dwarf_aranges_section = sectp;
1136 else if (strcmp (sectp->name, LOC_SECTION) == 0)
1138 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1139 dwarf_loc_section = sectp;
1141 else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1143 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1144 dwarf_macinfo_section = sectp;
1146 else if (strcmp (sectp->name, STR_SECTION) == 0)
1148 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1149 dwarf_str_section = sectp;
1151 else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1153 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1154 dwarf_frame_section = sectp;
1156 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1158 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1159 if (aflag & SEC_HAS_CONTENTS)
1161 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1162 dwarf_eh_frame_section = sectp;
1165 else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1167 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1168 dwarf_ranges_section = sectp;
1172 /* Build a partial symbol table. */
1175 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1177 /* We definitely need the .debug_info and .debug_abbrev sections */
1179 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1180 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1182 if (dwarf_line_section)
1183 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1185 dwarf2_per_objfile->line_buffer = NULL;
1187 if (dwarf_str_section)
1188 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1190 dwarf2_per_objfile->str_buffer = NULL;
1192 if (dwarf_macinfo_section)
1193 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1194 dwarf_macinfo_section);
1196 dwarf2_per_objfile->macinfo_buffer = NULL;
1198 if (dwarf_ranges_section)
1199 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1201 dwarf2_per_objfile->ranges_buffer = NULL;
1203 if (dwarf_loc_section)
1204 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1206 dwarf2_per_objfile->loc_buffer = NULL;
1209 || (objfile->global_psymbols.size == 0
1210 && objfile->static_psymbols.size == 0))
1212 init_psymbol_list (objfile, 1024);
1216 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1218 /* Things are significantly easier if we have .debug_aranges and
1219 .debug_pubnames sections */
1221 dwarf2_build_psymtabs_easy (objfile, mainline);
1225 /* only test this case for now */
1227 /* In this case we have to work a bit harder */
1228 dwarf2_build_psymtabs_hard (objfile, mainline);
1233 /* Build the partial symbol table from the information in the
1234 .debug_pubnames and .debug_aranges sections. */
1237 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1239 bfd *abfd = objfile->obfd;
1240 char *aranges_buffer, *pubnames_buffer;
1241 char *aranges_ptr, *pubnames_ptr;
1242 unsigned int entry_length, version, info_offset, info_size;
1244 pubnames_buffer = dwarf2_read_section (objfile,
1245 dwarf_pubnames_section);
1246 pubnames_ptr = pubnames_buffer;
1247 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1249 struct comp_unit_head cu_header;
1250 unsigned int bytes_read;
1252 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1254 pubnames_ptr += bytes_read;
1255 version = read_1_byte (abfd, pubnames_ptr);
1257 info_offset = read_4_bytes (abfd, pubnames_ptr);
1259 info_size = read_4_bytes (abfd, pubnames_ptr);
1263 aranges_buffer = dwarf2_read_section (objfile,
1264 dwarf_aranges_section);
1269 /* Read in the comp unit header information from the debug_info at
1273 read_comp_unit_head (struct comp_unit_head *cu_header,
1274 gdb_byte *info_ptr, bfd *abfd)
1277 unsigned int bytes_read;
1278 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1280 info_ptr += bytes_read;
1281 cu_header->version = read_2_bytes (abfd, info_ptr);
1283 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1285 info_ptr += bytes_read;
1286 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1288 signed_addr = bfd_get_sign_extend_vma (abfd);
1289 if (signed_addr < 0)
1290 internal_error (__FILE__, __LINE__,
1291 _("read_comp_unit_head: dwarf from non elf file"));
1292 cu_header->signed_addr_p = signed_addr;
1297 partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
1300 gdb_byte *beg_of_comp_unit = info_ptr;
1302 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1304 if (header->version != 2 && header->version != 3)
1305 error (_("Dwarf Error: wrong version in compilation unit header "
1306 "(is %d, should be %d) [in module %s]"), header->version,
1307 2, bfd_get_filename (abfd));
1309 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1310 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1311 "(offset 0x%lx + 6) [in module %s]"),
1312 (long) header->abbrev_offset,
1313 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1314 bfd_get_filename (abfd));
1316 if (beg_of_comp_unit + header->length + header->initial_length_size
1317 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1318 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1319 "(offset 0x%lx + 0) [in module %s]"),
1320 (long) header->length,
1321 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1322 bfd_get_filename (abfd));
1327 /* Allocate a new partial symtab for file named NAME and mark this new
1328 partial symtab as being an include of PST. */
1331 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1332 struct objfile *objfile)
1334 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1336 subpst->section_offsets = pst->section_offsets;
1337 subpst->textlow = 0;
1338 subpst->texthigh = 0;
1340 subpst->dependencies = (struct partial_symtab **)
1341 obstack_alloc (&objfile->objfile_obstack,
1342 sizeof (struct partial_symtab *));
1343 subpst->dependencies[0] = pst;
1344 subpst->number_of_dependencies = 1;
1346 subpst->globals_offset = 0;
1347 subpst->n_global_syms = 0;
1348 subpst->statics_offset = 0;
1349 subpst->n_static_syms = 0;
1350 subpst->symtab = NULL;
1351 subpst->read_symtab = pst->read_symtab;
1354 /* No private part is necessary for include psymtabs. This property
1355 can be used to differentiate between such include psymtabs and
1356 the regular ones. */
1357 subpst->read_symtab_private = NULL;
1360 /* Read the Line Number Program data and extract the list of files
1361 included by the source file represented by PST. Build an include
1362 partial symtab for each of these included files.
1364 This procedure assumes that there *is* a Line Number Program in
1365 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1366 before calling this procedure. */
1369 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1370 struct partial_die_info *pdi,
1371 struct partial_symtab *pst)
1373 struct objfile *objfile = cu->objfile;
1374 bfd *abfd = objfile->obfd;
1375 struct line_header *lh;
1377 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1379 return; /* No linetable, so no includes. */
1381 dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1383 free_line_header (lh);
1387 /* Build the partial symbol table by doing a quick pass through the
1388 .debug_info and .debug_abbrev sections. */
1391 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1393 /* Instead of reading this into a big buffer, we should probably use
1394 mmap() on architectures that support it. (FIXME) */
1395 bfd *abfd = objfile->obfd;
1397 gdb_byte *beg_of_comp_unit;
1398 struct partial_die_info comp_unit_die;
1399 struct partial_symtab *pst;
1400 struct cleanup *back_to;
1401 CORE_ADDR lowpc, highpc, baseaddr;
1403 info_ptr = dwarf2_per_objfile->info_buffer;
1405 /* Any cached compilation units will be linked by the per-objfile
1406 read_in_chain. Make sure to free them when we're done. */
1407 back_to = make_cleanup (free_cached_comp_units, NULL);
1409 create_all_comp_units (objfile);
1411 /* Since the objects we're extracting from .debug_info vary in
1412 length, only the individual functions to extract them (like
1413 read_comp_unit_head and load_partial_die) can really know whether
1414 the buffer is large enough to hold another complete object.
1416 At the moment, they don't actually check that. If .debug_info
1417 holds just one extra byte after the last compilation unit's dies,
1418 then read_comp_unit_head will happily read off the end of the
1419 buffer. read_partial_die is similarly casual. Those functions
1422 For this loop condition, simply checking whether there's any data
1423 left at all should be sufficient. */
1424 while (info_ptr < (dwarf2_per_objfile->info_buffer
1425 + dwarf2_per_objfile->info_size))
1427 struct cleanup *back_to_inner;
1428 struct dwarf2_cu cu;
1429 struct abbrev_info *abbrev;
1430 unsigned int bytes_read;
1431 struct dwarf2_per_cu_data *this_cu;
1433 beg_of_comp_unit = info_ptr;
1435 memset (&cu, 0, sizeof (cu));
1437 obstack_init (&cu.comp_unit_obstack);
1439 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1441 cu.objfile = objfile;
1442 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1444 /* Complete the cu_header */
1445 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1446 cu.header.first_die_ptr = info_ptr;
1447 cu.header.cu_head_ptr = beg_of_comp_unit;
1449 cu.list_in_scope = &file_symbols;
1451 /* Read the abbrevs for this compilation unit into a table */
1452 dwarf2_read_abbrevs (abfd, &cu);
1453 make_cleanup (dwarf2_free_abbrev_table, &cu);
1455 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile);
1457 /* Read the compilation unit die */
1458 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1459 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1460 abfd, info_ptr, &cu);
1462 /* Set the language we're debugging */
1463 set_cu_language (comp_unit_die.language, &cu);
1465 /* Allocate a new partial symbol table structure */
1466 pst = start_psymtab_common (objfile, objfile->section_offsets,
1467 comp_unit_die.name ? comp_unit_die.name : "",
1468 comp_unit_die.lowpc,
1469 objfile->global_psymbols.next,
1470 objfile->static_psymbols.next);
1472 if (comp_unit_die.dirname)
1473 pst->dirname = xstrdup (comp_unit_die.dirname);
1475 pst->read_symtab_private = (char *) this_cu;
1477 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1479 /* Store the function that reads in the rest of the symbol table */
1480 pst->read_symtab = dwarf2_psymtab_to_symtab;
1482 /* If this compilation unit was already read in, free the
1483 cached copy in order to read it in again. This is
1484 necessary because we skipped some symbols when we first
1485 read in the compilation unit (see load_partial_dies).
1486 This problem could be avoided, but the benefit is
1488 if (this_cu->cu != NULL)
1489 free_one_cached_comp_unit (this_cu->cu);
1491 cu.per_cu = this_cu;
1493 /* Note that this is a pointer to our stack frame, being
1494 added to a global data structure. It will be cleaned up
1495 in free_stack_comp_unit when we finish with this
1496 compilation unit. */
1499 this_cu->psymtab = pst;
1501 /* Check if comp unit has_children.
1502 If so, read the rest of the partial symbols from this comp unit.
1503 If not, there's no more debug_info for this comp unit. */
1504 if (comp_unit_die.has_children)
1506 struct partial_die_info *first_die;
1508 lowpc = ((CORE_ADDR) -1);
1509 highpc = ((CORE_ADDR) 0);
1511 first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1513 scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1515 /* If we didn't find a lowpc, set it to highpc to avoid
1516 complaints from `maint check'. */
1517 if (lowpc == ((CORE_ADDR) -1))
1520 /* If the compilation unit didn't have an explicit address range,
1521 then use the information extracted from its child dies. */
1522 if (! comp_unit_die.has_pc_info)
1524 comp_unit_die.lowpc = lowpc;
1525 comp_unit_die.highpc = highpc;
1528 pst->textlow = comp_unit_die.lowpc + baseaddr;
1529 pst->texthigh = comp_unit_die.highpc + baseaddr;
1531 pst->n_global_syms = objfile->global_psymbols.next -
1532 (objfile->global_psymbols.list + pst->globals_offset);
1533 pst->n_static_syms = objfile->static_psymbols.next -
1534 (objfile->static_psymbols.list + pst->statics_offset);
1535 sort_pst_symbols (pst);
1537 /* If there is already a psymtab or symtab for a file of this
1538 name, remove it. (If there is a symtab, more drastic things
1539 also happen.) This happens in VxWorks. */
1540 free_named_symtabs (pst->filename);
1542 info_ptr = beg_of_comp_unit + cu.header.length
1543 + cu.header.initial_length_size;
1545 if (comp_unit_die.has_stmt_list)
1547 /* Get the list of files included in the current compilation unit,
1548 and build a psymtab for each of them. */
1549 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1552 do_cleanups (back_to_inner);
1554 do_cleanups (back_to);
1557 /* Load the DIEs for a secondary CU into memory. */
1560 load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile)
1562 bfd *abfd = objfile->obfd;
1563 gdb_byte *info_ptr, *beg_of_comp_unit;
1564 struct partial_die_info comp_unit_die;
1565 struct dwarf2_cu *cu;
1566 struct abbrev_info *abbrev;
1567 unsigned int bytes_read;
1568 struct cleanup *back_to;
1570 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset;
1571 beg_of_comp_unit = info_ptr;
1573 cu = xmalloc (sizeof (struct dwarf2_cu));
1574 memset (cu, 0, sizeof (struct dwarf2_cu));
1576 obstack_init (&cu->comp_unit_obstack);
1578 cu->objfile = objfile;
1579 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd);
1581 /* Complete the cu_header. */
1582 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1583 cu->header.first_die_ptr = info_ptr;
1584 cu->header.cu_head_ptr = beg_of_comp_unit;
1586 /* Read the abbrevs for this compilation unit into a table. */
1587 dwarf2_read_abbrevs (abfd, cu);
1588 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
1590 /* Read the compilation unit die. */
1591 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1592 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1593 abfd, info_ptr, cu);
1595 /* Set the language we're debugging. */
1596 set_cu_language (comp_unit_die.language, cu);
1598 /* Link this compilation unit into the compilation unit tree. */
1600 cu->per_cu = this_cu;
1602 /* Check if comp unit has_children.
1603 If so, read the rest of the partial symbols from this comp unit.
1604 If not, there's no more debug_info for this comp unit. */
1605 if (comp_unit_die.has_children)
1606 load_partial_dies (abfd, info_ptr, 0, cu);
1608 do_cleanups (back_to);
1611 /* Create a list of all compilation units in OBJFILE. We do this only
1612 if an inter-comp-unit reference is found; presumably if there is one,
1613 there will be many, and one will occur early in the .debug_info section.
1614 So there's no point in building this list incrementally. */
1617 create_all_comp_units (struct objfile *objfile)
1621 struct dwarf2_per_cu_data **all_comp_units;
1622 gdb_byte *info_ptr = dwarf2_per_objfile->info_buffer;
1626 all_comp_units = xmalloc (n_allocated
1627 * sizeof (struct dwarf2_per_cu_data *));
1629 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1631 struct comp_unit_head cu_header;
1632 gdb_byte *beg_of_comp_unit;
1633 struct dwarf2_per_cu_data *this_cu;
1634 unsigned long offset;
1635 unsigned int bytes_read;
1637 offset = info_ptr - dwarf2_per_objfile->info_buffer;
1639 /* Read just enough information to find out where the next
1640 compilation unit is. */
1641 cu_header.initial_length_size = 0;
1642 cu_header.length = read_initial_length (objfile->obfd, info_ptr,
1643 &cu_header, &bytes_read);
1645 /* Save the compilation unit for later lookup. */
1646 this_cu = obstack_alloc (&objfile->objfile_obstack,
1647 sizeof (struct dwarf2_per_cu_data));
1648 memset (this_cu, 0, sizeof (*this_cu));
1649 this_cu->offset = offset;
1650 this_cu->length = cu_header.length + cu_header.initial_length_size;
1652 if (n_comp_units == n_allocated)
1655 all_comp_units = xrealloc (all_comp_units,
1657 * sizeof (struct dwarf2_per_cu_data *));
1659 all_comp_units[n_comp_units++] = this_cu;
1661 info_ptr = info_ptr + this_cu->length;
1664 dwarf2_per_objfile->all_comp_units
1665 = obstack_alloc (&objfile->objfile_obstack,
1666 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1667 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
1668 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
1669 xfree (all_comp_units);
1670 dwarf2_per_objfile->n_comp_units = n_comp_units;
1673 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1674 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1678 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1679 CORE_ADDR *highpc, struct dwarf2_cu *cu)
1681 struct objfile *objfile = cu->objfile;
1682 bfd *abfd = objfile->obfd;
1683 struct partial_die_info *pdi;
1685 /* Now, march along the PDI's, descending into ones which have
1686 interesting children but skipping the children of the other ones,
1687 until we reach the end of the compilation unit. */
1693 fixup_partial_die (pdi, cu);
1695 /* Anonymous namespaces have no name but have interesting
1696 children, so we need to look at them. Ditto for anonymous
1699 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1700 || pdi->tag == DW_TAG_enumeration_type)
1704 case DW_TAG_subprogram:
1705 if (pdi->has_pc_info)
1707 if (pdi->lowpc < *lowpc)
1709 *lowpc = pdi->lowpc;
1711 if (pdi->highpc > *highpc)
1713 *highpc = pdi->highpc;
1715 if (!pdi->is_declaration)
1717 add_partial_symbol (pdi, cu);
1721 case DW_TAG_variable:
1722 case DW_TAG_typedef:
1723 case DW_TAG_union_type:
1724 if (!pdi->is_declaration)
1726 add_partial_symbol (pdi, cu);
1729 case DW_TAG_class_type:
1730 case DW_TAG_structure_type:
1731 if (!pdi->is_declaration)
1733 add_partial_symbol (pdi, cu);
1736 case DW_TAG_enumeration_type:
1737 if (!pdi->is_declaration)
1738 add_partial_enumeration (pdi, cu);
1740 case DW_TAG_base_type:
1741 case DW_TAG_subrange_type:
1742 /* File scope base type definitions are added to the partial
1744 add_partial_symbol (pdi, cu);
1746 case DW_TAG_namespace:
1747 add_partial_namespace (pdi, lowpc, highpc, cu);
1754 /* If the die has a sibling, skip to the sibling. */
1756 pdi = pdi->die_sibling;
1760 /* Functions used to compute the fully scoped name of a partial DIE.
1762 Normally, this is simple. For C++, the parent DIE's fully scoped
1763 name is concatenated with "::" and the partial DIE's name. For
1764 Java, the same thing occurs except that "." is used instead of "::".
1765 Enumerators are an exception; they use the scope of their parent
1766 enumeration type, i.e. the name of the enumeration type is not
1767 prepended to the enumerator.
1769 There are two complexities. One is DW_AT_specification; in this
1770 case "parent" means the parent of the target of the specification,
1771 instead of the direct parent of the DIE. The other is compilers
1772 which do not emit DW_TAG_namespace; in this case we try to guess
1773 the fully qualified name of structure types from their members'
1774 linkage names. This must be done using the DIE's children rather
1775 than the children of any DW_AT_specification target. We only need
1776 to do this for structures at the top level, i.e. if the target of
1777 any DW_AT_specification (if any; otherwise the DIE itself) does not
1780 /* Compute the scope prefix associated with PDI's parent, in
1781 compilation unit CU. The result will be allocated on CU's
1782 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1783 field. NULL is returned if no prefix is necessary. */
1785 partial_die_parent_scope (struct partial_die_info *pdi,
1786 struct dwarf2_cu *cu)
1788 char *grandparent_scope;
1789 struct partial_die_info *parent, *real_pdi;
1791 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1792 then this means the parent of the specification DIE. */
1795 while (real_pdi->has_specification)
1796 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
1798 parent = real_pdi->die_parent;
1802 if (parent->scope_set)
1803 return parent->scope;
1805 fixup_partial_die (parent, cu);
1807 grandparent_scope = partial_die_parent_scope (parent, cu);
1809 if (parent->tag == DW_TAG_namespace
1810 || parent->tag == DW_TAG_structure_type
1811 || parent->tag == DW_TAG_class_type
1812 || parent->tag == DW_TAG_union_type)
1814 if (grandparent_scope == NULL)
1815 parent->scope = parent->name;
1817 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
1820 else if (parent->tag == DW_TAG_enumeration_type)
1821 /* Enumerators should not get the name of the enumeration as a prefix. */
1822 parent->scope = grandparent_scope;
1825 /* FIXME drow/2004-04-01: What should we be doing with
1826 function-local names? For partial symbols, we should probably be
1828 complaint (&symfile_complaints,
1829 _("unhandled containing DIE tag %d for DIE at %d"),
1830 parent->tag, pdi->offset);
1831 parent->scope = grandparent_scope;
1834 parent->scope_set = 1;
1835 return parent->scope;
1838 /* Return the fully scoped name associated with PDI, from compilation unit
1839 CU. The result will be allocated with malloc. */
1841 partial_die_full_name (struct partial_die_info *pdi,
1842 struct dwarf2_cu *cu)
1846 parent_scope = partial_die_parent_scope (pdi, cu);
1847 if (parent_scope == NULL)
1850 return typename_concat (NULL, parent_scope, pdi->name, cu);
1854 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1856 struct objfile *objfile = cu->objfile;
1859 const char *my_prefix;
1860 const struct partial_symbol *psym = NULL;
1862 int built_actual_name = 0;
1864 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1868 if (pdi_needs_namespace (pdi->tag))
1870 actual_name = partial_die_full_name (pdi, cu);
1872 built_actual_name = 1;
1875 if (actual_name == NULL)
1876 actual_name = pdi->name;
1880 case DW_TAG_subprogram:
1881 if (pdi->is_external)
1883 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1884 mst_text, objfile); */
1885 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1886 VAR_DOMAIN, LOC_BLOCK,
1887 &objfile->global_psymbols,
1888 0, pdi->lowpc + baseaddr,
1889 cu->language, objfile);
1893 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1894 mst_file_text, objfile); */
1895 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1896 VAR_DOMAIN, LOC_BLOCK,
1897 &objfile->static_psymbols,
1898 0, pdi->lowpc + baseaddr,
1899 cu->language, objfile);
1902 case DW_TAG_variable:
1903 if (pdi->is_external)
1906 Don't enter into the minimal symbol tables as there is
1907 a minimal symbol table entry from the ELF symbols already.
1908 Enter into partial symbol table if it has a location
1909 descriptor or a type.
1910 If the location descriptor is missing, new_symbol will create
1911 a LOC_UNRESOLVED symbol, the address of the variable will then
1912 be determined from the minimal symbol table whenever the variable
1914 The address for the partial symbol table entry is not
1915 used by GDB, but it comes in handy for debugging partial symbol
1919 addr = decode_locdesc (pdi->locdesc, cu);
1920 if (pdi->locdesc || pdi->has_type)
1921 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1922 VAR_DOMAIN, LOC_STATIC,
1923 &objfile->global_psymbols,
1925 cu->language, objfile);
1929 /* Static Variable. Skip symbols without location descriptors. */
1930 if (pdi->locdesc == NULL)
1932 addr = decode_locdesc (pdi->locdesc, cu);
1933 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1934 mst_file_data, objfile); */
1935 psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1936 VAR_DOMAIN, LOC_STATIC,
1937 &objfile->static_psymbols,
1939 cu->language, objfile);
1942 case DW_TAG_typedef:
1943 case DW_TAG_base_type:
1944 case DW_TAG_subrange_type:
1945 add_psymbol_to_list (actual_name, strlen (actual_name),
1946 VAR_DOMAIN, LOC_TYPEDEF,
1947 &objfile->static_psymbols,
1948 0, (CORE_ADDR) 0, cu->language, objfile);
1950 case DW_TAG_namespace:
1951 add_psymbol_to_list (actual_name, strlen (actual_name),
1952 VAR_DOMAIN, LOC_TYPEDEF,
1953 &objfile->global_psymbols,
1954 0, (CORE_ADDR) 0, cu->language, objfile);
1956 case DW_TAG_class_type:
1957 case DW_TAG_structure_type:
1958 case DW_TAG_union_type:
1959 case DW_TAG_enumeration_type:
1960 /* Skip aggregate types without children, these are external
1962 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1963 static vs. global. */
1964 if (pdi->has_children == 0)
1966 add_psymbol_to_list (actual_name, strlen (actual_name),
1967 STRUCT_DOMAIN, LOC_TYPEDEF,
1968 (cu->language == language_cplus
1969 || cu->language == language_java)
1970 ? &objfile->global_psymbols
1971 : &objfile->static_psymbols,
1972 0, (CORE_ADDR) 0, cu->language, objfile);
1974 if (cu->language == language_cplus
1975 || cu->language == language_java)
1977 /* For C++ and Java, these implicitly act as typedefs as well. */
1978 add_psymbol_to_list (actual_name, strlen (actual_name),
1979 VAR_DOMAIN, LOC_TYPEDEF,
1980 &objfile->global_psymbols,
1981 0, (CORE_ADDR) 0, cu->language, objfile);
1984 case DW_TAG_enumerator:
1985 add_psymbol_to_list (actual_name, strlen (actual_name),
1986 VAR_DOMAIN, LOC_CONST,
1987 (cu->language == language_cplus
1988 || cu->language == language_java)
1989 ? &objfile->global_psymbols
1990 : &objfile->static_psymbols,
1991 0, (CORE_ADDR) 0, cu->language, objfile);
1997 /* Check to see if we should scan the name for possible namespace
1998 info. Only do this if this is C++, if we don't have namespace
1999 debugging info in the file, if the psym is of an appropriate type
2000 (otherwise we'll have psym == NULL), and if we actually had a
2001 mangled name to begin with. */
2003 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2004 cases which do not set PSYM above? */
2006 if (cu->language == language_cplus
2007 && cu->has_namespace_info == 0
2009 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2010 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2013 if (built_actual_name)
2014 xfree (actual_name);
2017 /* Determine whether a die of type TAG living in a C++ class or
2018 namespace needs to have the name of the scope prepended to the
2019 name listed in the die. */
2022 pdi_needs_namespace (enum dwarf_tag tag)
2026 case DW_TAG_namespace:
2027 case DW_TAG_typedef:
2028 case DW_TAG_class_type:
2029 case DW_TAG_structure_type:
2030 case DW_TAG_union_type:
2031 case DW_TAG_enumeration_type:
2032 case DW_TAG_enumerator:
2039 /* Read a partial die corresponding to a namespace; also, add a symbol
2040 corresponding to that namespace to the symbol table. NAMESPACE is
2041 the name of the enclosing namespace. */
2044 add_partial_namespace (struct partial_die_info *pdi,
2045 CORE_ADDR *lowpc, CORE_ADDR *highpc,
2046 struct dwarf2_cu *cu)
2048 struct objfile *objfile = cu->objfile;
2050 /* Add a symbol for the namespace. */
2052 add_partial_symbol (pdi, cu);
2054 /* Now scan partial symbols in that namespace. */
2056 if (pdi->has_children)
2057 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
2060 /* See if we can figure out if the class lives in a namespace. We do
2061 this by looking for a member function; its demangled name will
2062 contain namespace info, if there is any. */
2065 guess_structure_name (struct partial_die_info *struct_pdi,
2066 struct dwarf2_cu *cu)
2068 if ((cu->language == language_cplus
2069 || cu->language == language_java)
2070 && cu->has_namespace_info == 0
2071 && struct_pdi->has_children)
2073 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2074 what template types look like, because the demangler
2075 frequently doesn't give the same name as the debug info. We
2076 could fix this by only using the demangled name to get the
2077 prefix (but see comment in read_structure_type). */
2079 struct partial_die_info *child_pdi = struct_pdi->die_child;
2080 struct partial_die_info *real_pdi;
2082 /* If this DIE (this DIE's specification, if any) has a parent, then
2083 we should not do this. We'll prepend the parent's fully qualified
2084 name when we create the partial symbol. */
2086 real_pdi = struct_pdi;
2087 while (real_pdi->has_specification)
2088 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2090 if (real_pdi->die_parent != NULL)
2093 while (child_pdi != NULL)
2095 if (child_pdi->tag == DW_TAG_subprogram)
2097 char *actual_class_name
2098 = language_class_name_from_physname (cu->language_defn,
2100 if (actual_class_name != NULL)
2103 = obsavestring (actual_class_name,
2104 strlen (actual_class_name),
2105 &cu->comp_unit_obstack);
2106 xfree (actual_class_name);
2111 child_pdi = child_pdi->die_sibling;
2116 /* Read a partial die corresponding to an enumeration type. */
2119 add_partial_enumeration (struct partial_die_info *enum_pdi,
2120 struct dwarf2_cu *cu)
2122 struct objfile *objfile = cu->objfile;
2123 bfd *abfd = objfile->obfd;
2124 struct partial_die_info *pdi;
2126 if (enum_pdi->name != NULL)
2127 add_partial_symbol (enum_pdi, cu);
2129 pdi = enum_pdi->die_child;
2132 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2133 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2135 add_partial_symbol (pdi, cu);
2136 pdi = pdi->die_sibling;
2140 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2141 Return the corresponding abbrev, or NULL if the number is zero (indicating
2142 an empty DIE). In either case *BYTES_READ will be set to the length of
2143 the initial number. */
2145 static struct abbrev_info *
2146 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
2147 struct dwarf2_cu *cu)
2149 bfd *abfd = cu->objfile->obfd;
2150 unsigned int abbrev_number;
2151 struct abbrev_info *abbrev;
2153 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2155 if (abbrev_number == 0)
2158 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2161 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2162 bfd_get_filename (abfd));
2168 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2169 pointer to the end of a series of DIEs, terminated by an empty
2170 DIE. Any children of the skipped DIEs will also be skipped. */
2173 skip_children (gdb_byte *info_ptr, struct dwarf2_cu *cu)
2175 struct abbrev_info *abbrev;
2176 unsigned int bytes_read;
2180 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2182 return info_ptr + bytes_read;
2184 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
2188 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2189 should point just after the initial uleb128 of a DIE, and the
2190 abbrev corresponding to that skipped uleb128 should be passed in
2191 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2195 skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev,
2196 struct dwarf2_cu *cu)
2198 unsigned int bytes_read;
2199 struct attribute attr;
2200 bfd *abfd = cu->objfile->obfd;
2201 unsigned int form, i;
2203 for (i = 0; i < abbrev->num_attrs; i++)
2205 /* The only abbrev we care about is DW_AT_sibling. */
2206 if (abbrev->attrs[i].name == DW_AT_sibling)
2208 read_attribute (&attr, &abbrev->attrs[i],
2209 abfd, info_ptr, cu);
2210 if (attr.form == DW_FORM_ref_addr)
2211 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2213 return dwarf2_per_objfile->info_buffer
2214 + dwarf2_get_ref_die_offset (&attr, cu);
2217 /* If it isn't DW_AT_sibling, skip this attribute. */
2218 form = abbrev->attrs[i].form;
2223 case DW_FORM_ref_addr:
2224 info_ptr += cu->header.addr_size;
2243 case DW_FORM_string:
2244 read_string (abfd, info_ptr, &bytes_read);
2245 info_ptr += bytes_read;
2248 info_ptr += cu->header.offset_size;
2251 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2252 info_ptr += bytes_read;
2254 case DW_FORM_block1:
2255 info_ptr += 1 + read_1_byte (abfd, info_ptr);
2257 case DW_FORM_block2:
2258 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2260 case DW_FORM_block4:
2261 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2265 case DW_FORM_ref_udata:
2266 info_ptr = skip_leb128 (abfd, info_ptr);
2268 case DW_FORM_indirect:
2269 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2270 info_ptr += bytes_read;
2271 /* We need to continue parsing from here, so just go back to
2273 goto skip_attribute;
2276 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2277 dwarf_form_name (form),
2278 bfd_get_filename (abfd));
2282 if (abbrev->has_children)
2283 return skip_children (info_ptr, cu);
2288 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2289 the next DIE after ORIG_PDI. */
2292 locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr,
2293 bfd *abfd, struct dwarf2_cu *cu)
2295 /* Do we know the sibling already? */
2297 if (orig_pdi->sibling)
2298 return orig_pdi->sibling;
2300 /* Are there any children to deal with? */
2302 if (!orig_pdi->has_children)
2305 /* Skip the children the long way. */
2307 return skip_children (info_ptr, cu);
2310 /* Expand this partial symbol table into a full symbol table. */
2313 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2315 /* FIXME: This is barely more than a stub. */
2320 warning (_("bug: psymtab for %s is already read in."), pst->filename);
2326 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
2327 gdb_flush (gdb_stdout);
2330 /* Restore our global data. */
2331 dwarf2_per_objfile = objfile_data (pst->objfile,
2332 dwarf2_objfile_data_key);
2334 psymtab_to_symtab_1 (pst);
2336 /* Finish up the debug error message. */
2338 printf_filtered (_("done.\n"));
2343 /* Add PER_CU to the queue. */
2346 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
2348 struct dwarf2_queue_item *item;
2351 item = xmalloc (sizeof (*item));
2352 item->per_cu = per_cu;
2355 if (dwarf2_queue == NULL)
2356 dwarf2_queue = item;
2358 dwarf2_queue_tail->next = item;
2360 dwarf2_queue_tail = item;
2363 /* Process the queue. */
2366 process_queue (struct objfile *objfile)
2368 struct dwarf2_queue_item *item, *next_item;
2370 /* Initially, there is just one item on the queue. Load its DIEs,
2371 and the DIEs of any other compilation units it requires,
2374 for (item = dwarf2_queue; item != NULL; item = item->next)
2376 /* Read in this compilation unit. This may add new items to
2377 the end of the queue. */
2378 load_full_comp_unit (item->per_cu);
2380 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
2381 dwarf2_per_objfile->read_in_chain = item->per_cu;
2383 /* If this compilation unit has already had full symbols created,
2384 reset the TYPE fields in each DIE. */
2385 if (item->per_cu->psymtab->readin)
2386 reset_die_and_siblings_types (item->per_cu->cu->dies,
2390 /* Now everything left on the queue needs to be read in. Process
2391 them, one at a time, removing from the queue as we finish. */
2392 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
2394 if (!item->per_cu->psymtab->readin)
2395 process_full_comp_unit (item->per_cu);
2397 item->per_cu->queued = 0;
2398 next_item = item->next;
2402 dwarf2_queue_tail = NULL;
2405 /* Free all allocated queue entries. This function only releases anything if
2406 an error was thrown; if the queue was processed then it would have been
2407 freed as we went along. */
2410 dwarf2_release_queue (void *dummy)
2412 struct dwarf2_queue_item *item, *last;
2414 item = dwarf2_queue;
2417 /* Anything still marked queued is likely to be in an
2418 inconsistent state, so discard it. */
2419 if (item->per_cu->queued)
2421 if (item->per_cu->cu != NULL)
2422 free_one_cached_comp_unit (item->per_cu->cu);
2423 item->per_cu->queued = 0;
2431 dwarf2_queue = dwarf2_queue_tail = NULL;
2434 /* Read in full symbols for PST, and anything it depends on. */
2437 psymtab_to_symtab_1 (struct partial_symtab *pst)
2439 struct dwarf2_per_cu_data *per_cu;
2440 struct cleanup *back_to;
2443 for (i = 0; i < pst->number_of_dependencies; i++)
2444 if (!pst->dependencies[i]->readin)
2446 /* Inform about additional files that need to be read in. */
2449 /* FIXME: i18n: Need to make this a single string. */
2450 fputs_filtered (" ", gdb_stdout);
2452 fputs_filtered ("and ", gdb_stdout);
2454 printf_filtered ("%s...", pst->dependencies[i]->filename);
2455 wrap_here (""); /* Flush output */
2456 gdb_flush (gdb_stdout);
2458 psymtab_to_symtab_1 (pst->dependencies[i]);
2461 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
2465 /* It's an include file, no symbols to read for it.
2466 Everything is in the parent symtab. */
2471 back_to = make_cleanup (dwarf2_release_queue, NULL);
2473 queue_comp_unit (per_cu);
2475 process_queue (pst->objfile);
2477 /* Age the cache, releasing compilation units that have not
2478 been used recently. */
2479 age_cached_comp_units ();
2481 do_cleanups (back_to);
2484 /* Load the DIEs associated with PST and PER_CU into memory. */
2486 static struct dwarf2_cu *
2487 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2489 struct partial_symtab *pst = per_cu->psymtab;
2490 bfd *abfd = pst->objfile->obfd;
2491 struct dwarf2_cu *cu;
2492 unsigned long offset;
2494 struct cleanup *back_to, *free_cu_cleanup;
2495 struct attribute *attr;
2498 /* Set local variables from the partial symbol table info. */
2499 offset = per_cu->offset;
2501 info_ptr = dwarf2_per_objfile->info_buffer + offset;
2503 cu = xmalloc (sizeof (struct dwarf2_cu));
2504 memset (cu, 0, sizeof (struct dwarf2_cu));
2506 /* If an error occurs while loading, release our storage. */
2507 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
2509 cu->objfile = pst->objfile;
2511 /* read in the comp_unit header */
2512 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
2514 /* Read the abbrevs for this compilation unit */
2515 dwarf2_read_abbrevs (abfd, cu);
2516 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2518 cu->header.offset = offset;
2520 cu->per_cu = per_cu;
2523 /* We use this obstack for block values in dwarf_alloc_block. */
2524 obstack_init (&cu->comp_unit_obstack);
2526 cu->dies = read_comp_unit (info_ptr, abfd, cu);
2528 /* We try not to read any attributes in this function, because not
2529 all objfiles needed for references have been loaded yet, and symbol
2530 table processing isn't initialized. But we have to set the CU language,
2531 or we won't be able to build types correctly. */
2532 attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
2534 set_cu_language (DW_UNSND (attr), cu);
2536 set_cu_language (language_minimal, cu);
2538 do_cleanups (back_to);
2540 /* We've successfully allocated this compilation unit. Let our caller
2541 clean it up when finished with it. */
2542 discard_cleanups (free_cu_cleanup);
2547 /* Generate full symbol information for PST and CU, whose DIEs have
2548 already been loaded into memory. */
2551 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
2553 struct partial_symtab *pst = per_cu->psymtab;
2554 struct dwarf2_cu *cu = per_cu->cu;
2555 struct objfile *objfile = pst->objfile;
2556 bfd *abfd = objfile->obfd;
2557 CORE_ADDR lowpc, highpc;
2558 struct symtab *symtab;
2559 struct cleanup *back_to;
2560 struct attribute *attr;
2563 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2565 /* We're in the global namespace. */
2566 processing_current_prefix = "";
2569 back_to = make_cleanup (really_free_pendings, NULL);
2571 cu->list_in_scope = &file_symbols;
2573 /* Find the base address of the compilation unit for range lists and
2574 location lists. It will normally be specified by DW_AT_low_pc.
2575 In DWARF-3 draft 4, the base address could be overridden by
2576 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2577 compilation units with discontinuous ranges. */
2579 cu->header.base_known = 0;
2580 cu->header.base_address = 0;
2582 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
2585 cu->header.base_address = DW_ADDR (attr);
2586 cu->header.base_known = 1;
2590 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
2593 cu->header.base_address = DW_ADDR (attr);
2594 cu->header.base_known = 1;
2598 /* Do line number decoding in read_file_scope () */
2599 process_die (cu->dies, cu);
2601 /* Some compilers don't define a DW_AT_high_pc attribute for the
2602 compilation unit. If the DW_AT_high_pc is missing, synthesize
2603 it, by scanning the DIE's below the compilation unit. */
2604 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
2606 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2608 /* Set symtab language to language from DW_AT_language.
2609 If the compilation is from a C file generated by language preprocessors,
2610 do not set the language if it was already deduced by start_subfile. */
2612 && !(cu->language == language_c && symtab->language != language_c))
2614 symtab->language = cu->language;
2616 pst->symtab = symtab;
2619 do_cleanups (back_to);
2622 /* Process a die and its children. */
2625 process_die (struct die_info *die, struct dwarf2_cu *cu)
2629 case DW_TAG_padding:
2631 case DW_TAG_compile_unit:
2632 read_file_scope (die, cu);
2634 case DW_TAG_subprogram:
2635 read_subroutine_type (die, cu);
2636 read_func_scope (die, cu);
2638 case DW_TAG_inlined_subroutine:
2639 /* FIXME: These are ignored for now.
2640 They could be used to set breakpoints on all inlined instances
2641 of a function and make GDB `next' properly over inlined functions. */
2643 case DW_TAG_lexical_block:
2644 case DW_TAG_try_block:
2645 case DW_TAG_catch_block:
2646 read_lexical_block_scope (die, cu);
2648 case DW_TAG_class_type:
2649 case DW_TAG_structure_type:
2650 case DW_TAG_union_type:
2651 read_structure_type (die, cu);
2652 process_structure_scope (die, cu);
2654 case DW_TAG_enumeration_type:
2655 read_enumeration_type (die, cu);
2656 process_enumeration_scope (die, cu);
2659 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2660 a symbol or process any children. Therefore it doesn't do anything
2661 that won't be done on-demand by read_type_die. */
2662 case DW_TAG_subroutine_type:
2663 read_subroutine_type (die, cu);
2665 case DW_TAG_array_type:
2666 read_array_type (die, cu);
2668 case DW_TAG_pointer_type:
2669 read_tag_pointer_type (die, cu);
2671 case DW_TAG_ptr_to_member_type:
2672 read_tag_ptr_to_member_type (die, cu);
2674 case DW_TAG_reference_type:
2675 read_tag_reference_type (die, cu);
2677 case DW_TAG_string_type:
2678 read_tag_string_type (die, cu);
2682 case DW_TAG_base_type:
2683 read_base_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_subrange_type:
2689 read_subrange_type (die, cu);
2690 /* Add a typedef symbol for the type definition, if it has a
2692 new_symbol (die, die->type, cu);
2694 case DW_TAG_common_block:
2695 read_common_block (die, cu);
2697 case DW_TAG_common_inclusion:
2699 case DW_TAG_namespace:
2700 processing_has_namespace_info = 1;
2701 read_namespace (die, cu);
2703 case DW_TAG_imported_declaration:
2704 case DW_TAG_imported_module:
2705 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2706 information contained in these. DW_TAG_imported_declaration
2707 dies shouldn't have children; DW_TAG_imported_module dies
2708 shouldn't in the C++ case, but conceivably could in the
2709 Fortran case, so we'll have to replace this gdb_assert if
2710 Fortran compilers start generating that info. */
2711 processing_has_namespace_info = 1;
2712 gdb_assert (die->child == NULL);
2715 new_symbol (die, NULL, cu);
2721 initialize_cu_func_list (struct dwarf2_cu *cu)
2723 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2727 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2729 struct objfile *objfile = cu->objfile;
2730 struct comp_unit_head *cu_header = &cu->header;
2731 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2732 CORE_ADDR lowpc = ((CORE_ADDR) -1);
2733 CORE_ADDR highpc = ((CORE_ADDR) 0);
2734 struct attribute *attr;
2735 char *name = "<unknown>";
2736 char *comp_dir = NULL;
2737 struct die_info *child_die;
2738 bfd *abfd = objfile->obfd;
2739 struct line_header *line_header = 0;
2742 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2744 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2746 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2747 from finish_block. */
2748 if (lowpc == ((CORE_ADDR) -1))
2753 attr = dwarf2_attr (die, DW_AT_name, cu);
2756 name = DW_STRING (attr);
2758 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2761 comp_dir = DW_STRING (attr);
2764 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2765 directory, get rid of it. */
2766 char *cp = strchr (comp_dir, ':');
2768 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2773 attr = dwarf2_attr (die, DW_AT_language, cu);
2776 set_cu_language (DW_UNSND (attr), cu);
2779 attr = dwarf2_attr (die, DW_AT_producer, cu);
2781 cu->producer = DW_STRING (attr);
2783 /* We assume that we're processing GCC output. */
2784 processing_gcc_compilation = 2;
2786 /* FIXME:Do something here. */
2787 if (dip->at_producer != NULL)
2789 handle_producer (dip->at_producer);
2793 /* The compilation unit may be in a different language or objfile,
2794 zero out all remembered fundamental types. */
2795 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2797 start_symtab (name, comp_dir, lowpc);
2798 record_debugformat ("DWARF 2");
2800 initialize_cu_func_list (cu);
2802 /* Process all dies in compilation unit. */
2803 if (die->child != NULL)
2805 child_die = die->child;
2806 while (child_die && child_die->tag)
2808 process_die (child_die, cu);
2809 child_die = sibling_die (child_die);
2813 /* Decode line number information if present. */
2814 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2817 unsigned int line_offset = DW_UNSND (attr);
2818 line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2821 make_cleanup ((make_cleanup_ftype *) free_line_header,
2822 (void *) line_header);
2823 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2827 /* Decode macro information, if present. Dwarf 2 macro information
2828 refers to information in the line number info statement program
2829 header, so we can only read it if we've read the header
2831 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2832 if (attr && line_header)
2834 unsigned int macro_offset = DW_UNSND (attr);
2835 dwarf_decode_macros (line_header, macro_offset,
2836 comp_dir, abfd, cu);
2838 do_cleanups (back_to);
2842 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2843 struct dwarf2_cu *cu)
2845 struct function_range *thisfn;
2847 thisfn = (struct function_range *)
2848 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2849 thisfn->name = name;
2850 thisfn->lowpc = lowpc;
2851 thisfn->highpc = highpc;
2852 thisfn->seen_line = 0;
2853 thisfn->next = NULL;
2855 if (cu->last_fn == NULL)
2856 cu->first_fn = thisfn;
2858 cu->last_fn->next = thisfn;
2860 cu->last_fn = thisfn;
2864 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2866 struct objfile *objfile = cu->objfile;
2867 struct context_stack *new;
2870 struct die_info *child_die;
2871 struct attribute *attr;
2873 const char *previous_prefix = processing_current_prefix;
2874 struct cleanup *back_to = NULL;
2877 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2879 name = dwarf2_linkage_name (die, cu);
2881 /* Ignore functions with missing or empty names and functions with
2882 missing or invalid low and high pc attributes. */
2883 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2886 if (cu->language == language_cplus
2887 || cu->language == language_java)
2889 struct die_info *spec_die = die_specification (die, cu);
2891 /* NOTE: carlton/2004-01-23: We have to be careful in the
2892 presence of DW_AT_specification. For example, with GCC 3.4,
2897 // Definition of N::foo.
2901 then we'll have a tree of DIEs like this:
2903 1: DW_TAG_compile_unit
2904 2: DW_TAG_namespace // N
2905 3: DW_TAG_subprogram // declaration of N::foo
2906 4: DW_TAG_subprogram // definition of N::foo
2907 DW_AT_specification // refers to die #3
2909 Thus, when processing die #4, we have to pretend that we're
2910 in the context of its DW_AT_specification, namely the contex
2913 if (spec_die != NULL)
2915 char *specification_prefix = determine_prefix (spec_die, cu);
2916 processing_current_prefix = specification_prefix;
2917 back_to = make_cleanup (xfree, specification_prefix);
2924 /* Record the function range for dwarf_decode_lines. */
2925 add_to_cu_func_list (name, lowpc, highpc, cu);
2927 new = push_context (0, lowpc);
2928 new->name = new_symbol (die, die->type, cu);
2930 /* If there is a location expression for DW_AT_frame_base, record
2932 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2934 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2935 expression is being recorded directly in the function's symbol
2936 and not in a separate frame-base object. I guess this hack is
2937 to avoid adding some sort of frame-base adjunct/annex to the
2938 function's symbol :-(. The problem with doing this is that it
2939 results in a function symbol with a location expression that
2940 has nothing to do with the location of the function, ouch! The
2941 relationship should be: a function's symbol has-a frame base; a
2942 frame-base has-a location expression. */
2943 dwarf2_symbol_mark_computed (attr, new->name, cu);
2945 cu->list_in_scope = &local_symbols;
2947 if (die->child != NULL)
2949 child_die = die->child;
2950 while (child_die && child_die->tag)
2952 process_die (child_die, cu);
2953 child_die = sibling_die (child_die);
2957 new = pop_context ();
2958 /* Make a block for the local symbols within. */
2959 finish_block (new->name, &local_symbols, new->old_blocks,
2960 lowpc, highpc, objfile);
2962 /* In C++, we can have functions nested inside functions (e.g., when
2963 a function declares a class that has methods). This means that
2964 when we finish processing a function scope, we may need to go
2965 back to building a containing block's symbol lists. */
2966 local_symbols = new->locals;
2967 param_symbols = new->params;
2969 /* If we've finished processing a top-level function, subsequent
2970 symbols go in the file symbol list. */
2971 if (outermost_context_p ())
2972 cu->list_in_scope = &file_symbols;
2974 processing_current_prefix = previous_prefix;
2975 if (back_to != NULL)
2976 do_cleanups (back_to);
2979 /* Process all the DIES contained within a lexical block scope. Start
2980 a new scope, process the dies, and then close the scope. */
2983 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2985 struct objfile *objfile = cu->objfile;
2986 struct context_stack *new;
2987 CORE_ADDR lowpc, highpc;
2988 struct die_info *child_die;
2991 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2993 /* Ignore blocks with missing or invalid low and high pc attributes. */
2994 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2995 as multiple lexical blocks? Handling children in a sane way would
2996 be nasty. Might be easier to properly extend generic blocks to
2998 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
3003 push_context (0, lowpc);
3004 if (die->child != NULL)
3006 child_die = die->child;
3007 while (child_die && child_die->tag)
3009 process_die (child_die, cu);
3010 child_die = sibling_die (child_die);
3013 new = pop_context ();
3015 if (local_symbols != NULL)
3017 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3020 local_symbols = new->locals;
3023 /* Get low and high pc attributes from a die. Return 1 if the attributes
3024 are present and valid, otherwise, return 0. Return -1 if the range is
3025 discontinuous, i.e. derived from DW_AT_ranges information. */
3027 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
3028 CORE_ADDR *highpc, struct dwarf2_cu *cu)
3030 struct objfile *objfile = cu->objfile;
3031 struct comp_unit_head *cu_header = &cu->header;
3032 struct attribute *attr;
3033 bfd *obfd = objfile->obfd;
3038 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
3041 high = DW_ADDR (attr);
3042 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3044 low = DW_ADDR (attr);
3046 /* Found high w/o low attribute. */
3049 /* Found consecutive range of addresses. */
3054 attr = dwarf2_attr (die, DW_AT_ranges, cu);
3057 unsigned int addr_size = cu_header->addr_size;
3058 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3059 /* Value of the DW_AT_ranges attribute is the offset in the
3060 .debug_ranges section. */
3061 unsigned int offset = DW_UNSND (attr);
3062 /* Base address selection entry. */
3070 found_base = cu_header->base_known;
3071 base = cu_header->base_address;
3073 if (offset >= dwarf2_per_objfile->ranges_size)
3075 complaint (&symfile_complaints,
3076 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3080 buffer = dwarf2_per_objfile->ranges_buffer + offset;
3082 /* Read in the largest possible address. */
3083 marker = read_address (obfd, buffer, cu, &dummy);
3084 if ((marker & mask) == mask)
3086 /* If we found the largest possible address, then
3087 read the base address. */
3088 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3089 buffer += 2 * addr_size;
3090 offset += 2 * addr_size;
3098 CORE_ADDR range_beginning, range_end;
3100 range_beginning = read_address (obfd, buffer, cu, &dummy);
3101 buffer += addr_size;
3102 range_end = read_address (obfd, buffer, cu, &dummy);
3103 buffer += addr_size;
3104 offset += 2 * addr_size;
3106 /* An end of list marker is a pair of zero addresses. */
3107 if (range_beginning == 0 && range_end == 0)
3108 /* Found the end of list entry. */
3111 /* Each base address selection entry is a pair of 2 values.
3112 The first is the largest possible address, the second is
3113 the base address. Check for a base address here. */
3114 if ((range_beginning & mask) == mask)
3116 /* If we found the largest possible address, then
3117 read the base address. */
3118 base = read_address (obfd, buffer + addr_size, cu, &dummy);
3125 /* We have no valid base address for the ranges
3127 complaint (&symfile_complaints,
3128 _("Invalid .debug_ranges data (no base address)"));
3132 range_beginning += base;
3135 /* FIXME: This is recording everything as a low-high
3136 segment of consecutive addresses. We should have a
3137 data structure for discontiguous block ranges
3141 low = range_beginning;
3147 if (range_beginning < low)
3148 low = range_beginning;
3149 if (range_end > high)
3155 /* If the first entry is an end-of-list marker, the range
3156 describes an empty scope, i.e. no instructions. */
3166 /* When using the GNU linker, .gnu.linkonce. sections are used to
3167 eliminate duplicate copies of functions and vtables and such.
3168 The linker will arbitrarily choose one and discard the others.
3169 The AT_*_pc values for such functions refer to local labels in
3170 these sections. If the section from that file was discarded, the
3171 labels are not in the output, so the relocs get a value of 0.
3172 If this is a discarded function, mark the pc bounds as invalid,
3173 so that GDB will ignore it. */
3174 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
3182 /* Get the low and high pc's represented by the scope DIE, and store
3183 them in *LOWPC and *HIGHPC. If the correct values can't be
3184 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3187 get_scope_pc_bounds (struct die_info *die,
3188 CORE_ADDR *lowpc, CORE_ADDR *highpc,
3189 struct dwarf2_cu *cu)
3191 CORE_ADDR best_low = (CORE_ADDR) -1;
3192 CORE_ADDR best_high = (CORE_ADDR) 0;
3193 CORE_ADDR current_low, current_high;
3195 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
3197 best_low = current_low;
3198 best_high = current_high;
3202 struct die_info *child = die->child;
3204 while (child && child->tag)
3206 switch (child->tag) {
3207 case DW_TAG_subprogram:
3208 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
3210 best_low = min (best_low, current_low);
3211 best_high = max (best_high, current_high);
3214 case DW_TAG_namespace:
3215 /* FIXME: carlton/2004-01-16: Should we do this for
3216 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3217 that current GCC's always emit the DIEs corresponding
3218 to definitions of methods of classes as children of a
3219 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3220 the DIEs giving the declarations, which could be
3221 anywhere). But I don't see any reason why the
3222 standards says that they have to be there. */
3223 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
3225 if (current_low != ((CORE_ADDR) -1))
3227 best_low = min (best_low, current_low);
3228 best_high = max (best_high, current_high);
3236 child = sibling_die (child);
3241 *highpc = best_high;
3244 /* Add an aggregate field to the field list. */
3247 dwarf2_add_field (struct field_info *fip, struct die_info *die,
3248 struct dwarf2_cu *cu)
3250 struct objfile *objfile = cu->objfile;
3251 struct nextfield *new_field;
3252 struct attribute *attr;
3254 char *fieldname = "";
3256 /* Allocate a new field list entry and link it in. */
3257 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3258 make_cleanup (xfree, new_field);
3259 memset (new_field, 0, sizeof (struct nextfield));
3261 if (die->tag == DW_TAG_inheritance)
3263 new_field->next = fip->baseclasses;
3264 fip->baseclasses = new_field;
3268 new_field->next = fip->fields;
3269 fip->fields = new_field;
3273 /* Handle accessibility and virtuality of field.
3274 The default accessibility for members is public, the default
3275 accessibility for inheritance is private. */
3276 if (die->tag != DW_TAG_inheritance)
3277 new_field->accessibility = DW_ACCESS_public;
3279 new_field->accessibility = DW_ACCESS_private;
3280 new_field->virtuality = DW_VIRTUALITY_none;
3282 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3284 new_field->accessibility = DW_UNSND (attr);
3285 if (new_field->accessibility != DW_ACCESS_public)
3286 fip->non_public_fields = 1;
3287 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
3289 new_field->virtuality = DW_UNSND (attr);
3291 fp = &new_field->field;
3293 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
3295 /* Data member other than a C++ static data member. */
3297 /* Get type of field. */
3298 fp->type = die_type (die, cu);
3300 FIELD_STATIC_KIND (*fp) = 0;
3302 /* Get bit size of field (zero if none). */
3303 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
3306 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
3310 FIELD_BITSIZE (*fp) = 0;
3313 /* Get bit offset of field. */
3314 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3317 FIELD_BITPOS (*fp) =
3318 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
3321 FIELD_BITPOS (*fp) = 0;
3322 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
3325 if (BITS_BIG_ENDIAN)
3327 /* For big endian bits, the DW_AT_bit_offset gives the
3328 additional bit offset from the MSB of the containing
3329 anonymous object to the MSB of the field. We don't
3330 have to do anything special since we don't need to
3331 know the size of the anonymous object. */
3332 FIELD_BITPOS (*fp) += DW_UNSND (attr);
3336 /* For little endian bits, compute the bit offset to the
3337 MSB of the anonymous object, subtract off the number of
3338 bits from the MSB of the field to the MSB of the
3339 object, and then subtract off the number of bits of
3340 the field itself. The result is the bit offset of
3341 the LSB of the field. */
3343 int bit_offset = DW_UNSND (attr);
3345 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3348 /* The size of the anonymous object containing
3349 the bit field is explicit, so use the
3350 indicated size (in bytes). */
3351 anonymous_size = DW_UNSND (attr);
3355 /* The size of the anonymous object containing
3356 the bit field must be inferred from the type
3357 attribute of the data member containing the
3359 anonymous_size = TYPE_LENGTH (fp->type);
3361 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
3362 - bit_offset - FIELD_BITSIZE (*fp);
3366 /* Get name of field. */
3367 attr = dwarf2_attr (die, DW_AT_name, cu);
3368 if (attr && DW_STRING (attr))
3369 fieldname = DW_STRING (attr);
3371 /* The name is already allocated along with this objfile, so we don't
3372 need to duplicate it for the type. */
3373 fp->name = fieldname;
3375 /* Change accessibility for artificial fields (e.g. virtual table
3376 pointer or virtual base class pointer) to private. */
3377 if (dwarf2_attr (die, DW_AT_artificial, cu))
3379 new_field->accessibility = DW_ACCESS_private;
3380 fip->non_public_fields = 1;
3383 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
3385 /* C++ static member. */
3387 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3388 is a declaration, but all versions of G++ as of this writing
3389 (so through at least 3.2.1) incorrectly generate
3390 DW_TAG_variable tags. */
3394 /* Get name of field. */
3395 attr = dwarf2_attr (die, DW_AT_name, cu);
3396 if (attr && DW_STRING (attr))
3397 fieldname = DW_STRING (attr);
3401 /* Get physical name. */
3402 physname = dwarf2_linkage_name (die, cu);
3404 /* The name is already allocated along with this objfile, so we don't
3405 need to duplicate it for the type. */
3406 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
3407 FIELD_TYPE (*fp) = die_type (die, cu);
3408 FIELD_NAME (*fp) = fieldname;
3410 else if (die->tag == DW_TAG_inheritance)
3412 /* C++ base class field. */
3413 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
3415 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
3417 FIELD_BITSIZE (*fp) = 0;
3418 FIELD_STATIC_KIND (*fp) = 0;
3419 FIELD_TYPE (*fp) = die_type (die, cu);
3420 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
3421 fip->nbaseclasses++;
3425 /* Create the vector of fields, and attach it to the type. */
3428 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3429 struct dwarf2_cu *cu)
3431 int nfields = fip->nfields;
3433 /* Record the field count, allocate space for the array of fields,
3434 and create blank accessibility bitfields if necessary. */
3435 TYPE_NFIELDS (type) = nfields;
3436 TYPE_FIELDS (type) = (struct field *)
3437 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3438 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3440 if (fip->non_public_fields)
3442 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3444 TYPE_FIELD_PRIVATE_BITS (type) =
3445 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3446 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3448 TYPE_FIELD_PROTECTED_BITS (type) =
3449 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3450 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3452 TYPE_FIELD_IGNORE_BITS (type) =
3453 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3454 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3457 /* If the type has baseclasses, allocate and clear a bit vector for
3458 TYPE_FIELD_VIRTUAL_BITS. */
3459 if (fip->nbaseclasses)
3461 int num_bytes = B_BYTES (fip->nbaseclasses);
3462 unsigned char *pointer;
3464 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3465 pointer = TYPE_ALLOC (type, num_bytes);
3466 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
3467 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3468 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3471 /* Copy the saved-up fields into the field vector. Start from the head
3472 of the list, adding to the tail of the field array, so that they end
3473 up in the same order in the array in which they were added to the list. */
3474 while (nfields-- > 0)
3476 struct nextfield *fieldp;
3480 fieldp = fip->fields;
3481 fip->fields = fieldp->next;
3485 fieldp = fip->baseclasses;
3486 fip->baseclasses = fieldp->next;
3489 TYPE_FIELD (type, nfields) = fieldp->field;
3490 switch (fieldp->accessibility)
3492 case DW_ACCESS_private:
3493 SET_TYPE_FIELD_PRIVATE (type, nfields);
3496 case DW_ACCESS_protected:
3497 SET_TYPE_FIELD_PROTECTED (type, nfields);
3500 case DW_ACCESS_public:
3504 /* Unknown accessibility. Complain and treat it as public. */
3506 complaint (&symfile_complaints, _("unsupported accessibility %d"),
3507 fieldp->accessibility);
3511 if (nfields < fip->nbaseclasses)
3513 switch (fieldp->virtuality)
3515 case DW_VIRTUALITY_virtual:
3516 case DW_VIRTUALITY_pure_virtual:
3517 SET_TYPE_FIELD_VIRTUAL (type, nfields);
3524 /* Add a member function to the proper fieldlist. */
3527 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3528 struct type *type, struct dwarf2_cu *cu)
3530 struct objfile *objfile = cu->objfile;
3531 struct attribute *attr;
3532 struct fnfieldlist *flp;
3534 struct fn_field *fnp;
3537 struct nextfnfield *new_fnfield;
3539 /* Get name of member function. */
3540 attr = dwarf2_attr (die, DW_AT_name, cu);
3541 if (attr && DW_STRING (attr))
3542 fieldname = DW_STRING (attr);
3546 /* Get the mangled name. */
3547 physname = dwarf2_linkage_name (die, cu);
3549 /* Look up member function name in fieldlist. */
3550 for (i = 0; i < fip->nfnfields; i++)
3552 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3556 /* Create new list element if necessary. */
3557 if (i < fip->nfnfields)
3558 flp = &fip->fnfieldlists[i];
3561 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3563 fip->fnfieldlists = (struct fnfieldlist *)
3564 xrealloc (fip->fnfieldlists,
3565 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3566 * sizeof (struct fnfieldlist));
3567 if (fip->nfnfields == 0)
3568 make_cleanup (free_current_contents, &fip->fnfieldlists);
3570 flp = &fip->fnfieldlists[fip->nfnfields];
3571 flp->name = fieldname;
3577 /* Create a new member function field and chain it to the field list
3579 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3580 make_cleanup (xfree, new_fnfield);
3581 memset (new_fnfield, 0, sizeof (struct nextfnfield));
3582 new_fnfield->next = flp->head;
3583 flp->head = new_fnfield;
3586 /* Fill in the member function field info. */
3587 fnp = &new_fnfield->fnfield;
3588 /* The name is already allocated along with this objfile, so we don't
3589 need to duplicate it for the type. */
3590 fnp->physname = physname ? physname : "";
3591 fnp->type = alloc_type (objfile);
3592 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3594 int nparams = TYPE_NFIELDS (die->type);
3596 /* TYPE is the domain of this method, and DIE->TYPE is the type
3597 of the method itself (TYPE_CODE_METHOD). */
3598 smash_to_method_type (fnp->type, type,
3599 TYPE_TARGET_TYPE (die->type),
3600 TYPE_FIELDS (die->type),
3601 TYPE_NFIELDS (die->type),
3602 TYPE_VARARGS (die->type));
3604 /* Handle static member functions.
3605 Dwarf2 has no clean way to discern C++ static and non-static
3606 member functions. G++ helps GDB by marking the first
3607 parameter for non-static member functions (which is the
3608 this pointer) as artificial. We obtain this information
3609 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3610 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3611 fnp->voffset = VOFFSET_STATIC;
3614 complaint (&symfile_complaints, _("member function type missing for '%s'"),
3617 /* Get fcontext from DW_AT_containing_type if present. */
3618 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3619 fnp->fcontext = die_containing_type (die, cu);
3621 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3622 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3624 /* Get accessibility. */
3625 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3628 switch (DW_UNSND (attr))
3630 case DW_ACCESS_private:
3631 fnp->is_private = 1;
3633 case DW_ACCESS_protected:
3634 fnp->is_protected = 1;
3639 /* Check for artificial methods. */
3640 attr = dwarf2_attr (die, DW_AT_artificial, cu);
3641 if (attr && DW_UNSND (attr) != 0)
3642 fnp->is_artificial = 1;
3644 /* Get index in virtual function table if it is a virtual member
3645 function. For GCC, this is an offset in the appropriate
3646 virtual table, as specified by DW_AT_containing_type. For
3647 everyone else, it is an expression to be evaluated relative
3648 to the object address. */
3650 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3651 if (attr && fnp->fcontext)
3653 /* Support the .debug_loc offsets */
3654 if (attr_form_is_block (attr))
3656 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3658 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3660 dwarf2_complex_location_expr_complaint ();
3664 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3670 /* We only support trivial expressions here. This hack will work
3671 for v3 classes, which always start with the vtable pointer. */
3672 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0
3673 && DW_BLOCK (attr)->data[0] == DW_OP_deref)
3675 struct dwarf_block blk;
3676 blk.size = DW_BLOCK (attr)->size - 1;
3677 blk.data = DW_BLOCK (attr)->data + 1;
3678 fnp->voffset = decode_locdesc (&blk, cu);
3679 if ((fnp->voffset % cu->header.addr_size) != 0)
3680 dwarf2_complex_location_expr_complaint ();
3682 fnp->voffset /= cu->header.addr_size;
3684 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (die->type, 0));
3687 dwarf2_complex_location_expr_complaint ();
3691 /* Create the vector of member function fields, and attach it to the type. */
3694 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3695 struct dwarf2_cu *cu)
3697 struct fnfieldlist *flp;
3698 int total_length = 0;
3701 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3702 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3703 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3705 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3707 struct nextfnfield *nfp = flp->head;
3708 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3711 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3712 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3713 fn_flp->fn_fields = (struct fn_field *)
3714 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3715 for (k = flp->length; (k--, nfp); nfp = nfp->next)
3716 fn_flp->fn_fields[k] = nfp->fnfield;
3718 total_length += flp->length;
3721 TYPE_NFN_FIELDS (type) = fip->nfnfields;
3722 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3726 /* Returns non-zero if NAME is the name of a vtable member in CU's
3727 language, zero otherwise. */
3729 is_vtable_name (const char *name, struct dwarf2_cu *cu)
3731 static const char vptr[] = "_vptr";
3732 static const char vtable[] = "vtable";
3734 /* Look for the C++ and Java forms of the vtable. */
3735 if ((cu->language == language_java
3736 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
3737 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
3738 && is_cplus_marker (name[sizeof (vptr) - 1])))
3745 /* Called when we find the DIE that starts a structure or union scope
3746 (definition) to process all dies that define the members of the
3749 NOTE: we need to call struct_type regardless of whether or not the
3750 DIE has an at_name attribute, since it might be an anonymous
3751 structure or union. This gets the type entered into our set of
3754 However, if the structure is incomplete (an opaque struct/union)
3755 then suppress creating a symbol table entry for it since gdb only
3756 wants to find the one with the complete definition. Note that if
3757 it is complete, we just call new_symbol, which does it's own
3758 checking about whether the struct/union is anonymous or not (and
3759 suppresses creating a symbol table entry itself). */
3762 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3764 struct objfile *objfile = cu->objfile;
3766 struct attribute *attr;
3767 const char *previous_prefix = processing_current_prefix;
3768 struct cleanup *back_to = NULL;
3773 type = alloc_type (objfile);
3775 INIT_CPLUS_SPECIFIC (type);
3776 attr = dwarf2_attr (die, DW_AT_name, cu);
3777 if (attr && DW_STRING (attr))
3779 if (cu->language == language_cplus
3780 || cu->language == language_java)
3782 char *new_prefix = determine_class_name (die, cu);
3783 TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3784 strlen (new_prefix),
3785 &objfile->objfile_obstack);
3786 back_to = make_cleanup (xfree, new_prefix);
3787 processing_current_prefix = new_prefix;
3791 /* The name is already allocated along with this objfile, so
3792 we don't need to duplicate it for the type. */
3793 TYPE_TAG_NAME (type) = DW_STRING (attr);
3797 if (die->tag == DW_TAG_structure_type)
3799 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3801 else if (die->tag == DW_TAG_union_type)
3803 TYPE_CODE (type) = TYPE_CODE_UNION;
3807 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3809 TYPE_CODE (type) = TYPE_CODE_CLASS;
3812 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3815 TYPE_LENGTH (type) = DW_UNSND (attr);
3819 TYPE_LENGTH (type) = 0;
3822 if (die_is_declaration (die, cu))
3823 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3825 /* We need to add the type field to the die immediately so we don't
3826 infinitely recurse when dealing with pointers to the structure
3827 type within the structure itself. */
3828 set_die_type (die, type, cu);
3830 if (die->child != NULL && ! die_is_declaration (die, cu))
3832 struct field_info fi;
3833 struct die_info *child_die;
3834 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3836 memset (&fi, 0, sizeof (struct field_info));
3838 child_die = die->child;
3840 while (child_die && child_die->tag)
3842 if (child_die->tag == DW_TAG_member
3843 || child_die->tag == DW_TAG_variable)
3845 /* NOTE: carlton/2002-11-05: A C++ static data member
3846 should be a DW_TAG_member that is a declaration, but
3847 all versions of G++ as of this writing (so through at
3848 least 3.2.1) incorrectly generate DW_TAG_variable
3849 tags for them instead. */
3850 dwarf2_add_field (&fi, child_die, cu);
3852 else if (child_die->tag == DW_TAG_subprogram)
3854 /* C++ member function. */
3855 read_type_die (child_die, cu);
3856 dwarf2_add_member_fn (&fi, child_die, type, cu);
3858 else if (child_die->tag == DW_TAG_inheritance)
3860 /* C++ base class field. */
3861 dwarf2_add_field (&fi, child_die, cu);
3863 child_die = sibling_die (child_die);
3866 /* Attach fields and member functions to the type. */
3868 dwarf2_attach_fields_to_type (&fi, type, cu);
3871 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3873 /* Get the type which refers to the base class (possibly this
3874 class itself) which contains the vtable pointer for the current
3875 class from the DW_AT_containing_type attribute. This use of
3876 DW_AT_containing_type is a GNU extension. */
3878 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3880 struct type *t = die_containing_type (die, cu);
3882 TYPE_VPTR_BASETYPE (type) = t;
3887 /* Our own class provides vtbl ptr. */
3888 for (i = TYPE_NFIELDS (t) - 1;
3889 i >= TYPE_N_BASECLASSES (t);
3892 char *fieldname = TYPE_FIELD_NAME (t, i);
3894 if (is_vtable_name (fieldname, cu))
3896 TYPE_VPTR_FIELDNO (type) = i;
3901 /* Complain if virtual function table field not found. */
3902 if (i < TYPE_N_BASECLASSES (t))
3903 complaint (&symfile_complaints,
3904 _("virtual function table pointer not found when defining class '%s'"),
3905 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3910 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3913 else if (cu->producer
3914 && strncmp (cu->producer,
3915 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3917 /* The IBM XLC compiler does not provide direct indication
3918 of the containing type, but the vtable pointer is
3919 always named __vfp. */
3923 for (i = TYPE_NFIELDS (type) - 1;
3924 i >= TYPE_N_BASECLASSES (type);
3927 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
3929 TYPE_VPTR_FIELDNO (type) = i;
3930 TYPE_VPTR_BASETYPE (type) = type;
3935 else if (cu->producer
3936 && strncmp (cu->producer,
3937 "ARM/Thumb C/C++ Compiler, RVCT", 30) == 0)
3939 /* The ARM compiler does not provide direct indication
3940 of the containing type, but the vtable pointer is
3941 always named __vptr. */
3945 for (i = TYPE_NFIELDS (type) - 1;
3946 i >= TYPE_N_BASECLASSES (type);
3949 if (strcmp (TYPE_FIELD_NAME (type, i), "__vptr") == 0)
3951 TYPE_VPTR_FIELDNO (type) = i;
3952 TYPE_VPTR_BASETYPE (type) = type;
3957 else if (cu->producer
3958 && strncmp (cu->producer,
3959 "ARM C++ Compiler, ADS", 21) == 0)
3961 /* The ARM compiler does not provide direct indication
3962 of the containing type, but the vtable pointer is
3963 always named __VPTR. Of course, we don't support this
3964 C++ ABI, so this isn't too useful. */
3968 for (i = TYPE_NFIELDS (type) - 1;
3969 i >= TYPE_N_BASECLASSES (type);
3972 if (strcmp (TYPE_FIELD_NAME (type, i), "__VPTR") == 0)
3974 TYPE_VPTR_FIELDNO (type) = i;
3975 TYPE_VPTR_BASETYPE (type) = type;
3982 do_cleanups (back_to);
3985 processing_current_prefix = previous_prefix;
3986 if (back_to != NULL)
3987 do_cleanups (back_to);
3991 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3993 struct objfile *objfile = cu->objfile;
3994 const char *previous_prefix = processing_current_prefix;
3995 struct die_info *child_die = die->child;
3997 if (TYPE_TAG_NAME (die->type) != NULL)
3998 processing_current_prefix = TYPE_TAG_NAME (die->type);
4000 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4001 snapshots) has been known to create a die giving a declaration
4002 for a class that has, as a child, a die giving a definition for a
4003 nested class. So we have to process our children even if the
4004 current die is a declaration. Normally, of course, a declaration
4005 won't have any children at all. */
4007 while (child_die != NULL && child_die->tag)
4009 if (child_die->tag == DW_TAG_member
4010 || child_die->tag == DW_TAG_variable
4011 || child_die->tag == DW_TAG_inheritance)
4016 process_die (child_die, cu);
4018 child_die = sibling_die (child_die);
4021 if (die->child != NULL && ! die_is_declaration (die, cu))
4022 new_symbol (die, die->type, cu);
4024 processing_current_prefix = previous_prefix;
4027 /* Given a DW_AT_enumeration_type die, set its type. We do not
4028 complete the type's fields yet, or create any symbols. */
4031 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
4033 struct objfile *objfile = cu->objfile;
4035 struct attribute *attr;
4040 type = alloc_type (objfile);
4042 TYPE_CODE (type) = TYPE_CODE_ENUM;
4043 attr = dwarf2_attr (die, DW_AT_name, cu);
4044 if (attr && DW_STRING (attr))
4046 char *name = DW_STRING (attr);
4048 if (processing_has_namespace_info)
4050 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack,
4051 processing_current_prefix,
4056 /* The name is already allocated along with this objfile, so
4057 we don't need to duplicate it for the type. */
4058 TYPE_TAG_NAME (type) = name;
4062 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4065 TYPE_LENGTH (type) = DW_UNSND (attr);
4069 TYPE_LENGTH (type) = 0;
4072 set_die_type (die, type, cu);
4075 /* Determine the name of the type represented by DIE, which should be
4076 a named C++ or Java compound type. Return the name in question; the caller
4077 is responsible for xfree()'ing it. */
4080 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
4082 struct cleanup *back_to = NULL;
4083 struct die_info *spec_die = die_specification (die, cu);
4084 char *new_prefix = NULL;
4086 /* If this is the definition of a class that is declared by another
4087 die, then processing_current_prefix may not be accurate; see
4088 read_func_scope for a similar example. */
4089 if (spec_die != NULL)
4091 char *specification_prefix = determine_prefix (spec_die, cu);
4092 processing_current_prefix = specification_prefix;
4093 back_to = make_cleanup (xfree, specification_prefix);
4096 /* If we don't have namespace debug info, guess the name by trying
4097 to demangle the names of members, just like we did in
4098 guess_structure_name. */
4099 if (!processing_has_namespace_info)
4101 struct die_info *child;
4103 for (child = die->child;
4104 child != NULL && child->tag != 0;
4105 child = sibling_die (child))
4107 if (child->tag == DW_TAG_subprogram)
4110 = language_class_name_from_physname (cu->language_defn,
4114 if (new_prefix != NULL)
4120 if (new_prefix == NULL)
4122 const char *name = dwarf2_name (die, cu);
4123 new_prefix = typename_concat (NULL, processing_current_prefix,
4124 name ? name : "<<anonymous>>",
4128 if (back_to != NULL)
4129 do_cleanups (back_to);
4134 /* Given a pointer to a die which begins an enumeration, process all
4135 the dies that define the members of the enumeration, and create the
4136 symbol for the enumeration type.
4138 NOTE: We reverse the order of the element list. */
4141 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4143 struct objfile *objfile = cu->objfile;
4144 struct die_info *child_die;
4145 struct field *fields;
4146 struct attribute *attr;
4149 int unsigned_enum = 1;
4153 if (die->child != NULL)
4155 child_die = die->child;
4156 while (child_die && child_die->tag)
4158 if (child_die->tag != DW_TAG_enumerator)
4160 process_die (child_die, cu);
4164 attr = dwarf2_attr (child_die, DW_AT_name, cu);
4167 sym = new_symbol (child_die, die->type, cu);
4168 if (SYMBOL_VALUE (sym) < 0)
4171 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4173 fields = (struct field *)
4175 (num_fields + DW_FIELD_ALLOC_CHUNK)
4176 * sizeof (struct field));
4179 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4180 FIELD_TYPE (fields[num_fields]) = NULL;
4181 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4182 FIELD_BITSIZE (fields[num_fields]) = 0;
4183 FIELD_STATIC_KIND (fields[num_fields]) = 0;
4189 child_die = sibling_die (child_die);
4194 TYPE_NFIELDS (die->type) = num_fields;
4195 TYPE_FIELDS (die->type) = (struct field *)
4196 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4197 memcpy (TYPE_FIELDS (die->type), fields,
4198 sizeof (struct field) * num_fields);
4202 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4205 new_symbol (die, die->type, cu);
4208 /* Extract all information from a DW_TAG_array_type DIE and put it in
4209 the DIE's type field. For now, this only handles one dimensional
4213 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4215 struct objfile *objfile = cu->objfile;
4216 struct die_info *child_die;
4217 struct type *type = NULL;
4218 struct type *element_type, *range_type, *index_type;
4219 struct type **range_types = NULL;
4220 struct attribute *attr;
4222 struct cleanup *back_to;
4224 /* Return if we've already decoded this type. */
4230 element_type = die_type (die, cu);
4232 /* Irix 6.2 native cc creates array types without children for
4233 arrays with unspecified length. */
4234 if (die->child == NULL)
4236 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4237 range_type = create_range_type (NULL, index_type, 0, -1);
4238 set_die_type (die, create_array_type (NULL, element_type, range_type),
4243 back_to = make_cleanup (null_cleanup, NULL);
4244 child_die = die->child;
4245 while (child_die && child_die->tag)
4247 if (child_die->tag == DW_TAG_subrange_type)
4249 read_subrange_type (child_die, cu);
4251 if (child_die->type != NULL)
4253 /* The range type was succesfully read. Save it for
4254 the array type creation. */
4255 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4257 range_types = (struct type **)
4258 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4259 * sizeof (struct type *));
4261 make_cleanup (free_current_contents, &range_types);
4263 range_types[ndim++] = child_die->type;
4266 child_die = sibling_die (child_die);
4269 /* Dwarf2 dimensions are output from left to right, create the
4270 necessary array types in backwards order. */
4272 type = element_type;
4274 if (read_array_order (die, cu) == DW_ORD_col_major)
4278 type = create_array_type (NULL, type, range_types[i++]);
4283 type = create_array_type (NULL, type, range_types[ndim]);
4286 /* Understand Dwarf2 support for vector types (like they occur on
4287 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4288 array type. This is not part of the Dwarf2/3 standard yet, but a
4289 custom vendor extension. The main difference between a regular
4290 array and the vector variant is that vectors are passed by value
4292 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4294 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
4296 do_cleanups (back_to);
4298 /* Install the type in the die. */
4299 set_die_type (die, type, cu);
4302 static enum dwarf_array_dim_ordering
4303 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4305 struct attribute *attr;
4307 attr = dwarf2_attr (die, DW_AT_ordering, cu);
4309 if (attr) return DW_SND (attr);
4312 GNU F77 is a special case, as at 08/2004 array type info is the
4313 opposite order to the dwarf2 specification, but data is still
4314 laid out as per normal fortran.
4316 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4320 if (cu->language == language_fortran &&
4321 cu->producer && strstr (cu->producer, "GNU F77"))
4323 return DW_ORD_row_major;
4326 switch (cu->language_defn->la_array_ordering)
4328 case array_column_major:
4329 return DW_ORD_col_major;
4330 case array_row_major:
4332 return DW_ORD_row_major;
4337 /* First cut: install each common block member as a global variable. */
4340 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4342 struct die_info *child_die;
4343 struct attribute *attr;
4345 CORE_ADDR base = (CORE_ADDR) 0;
4347 attr = dwarf2_attr (die, DW_AT_location, cu);
4350 /* Support the .debug_loc offsets */
4351 if (attr_form_is_block (attr))
4353 base = decode_locdesc (DW_BLOCK (attr), cu);
4355 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
4357 dwarf2_complex_location_expr_complaint ();
4361 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4362 "common block member");
4365 if (die->child != NULL)
4367 child_die = die->child;
4368 while (child_die && child_die->tag)
4370 sym = new_symbol (child_die, NULL, cu);
4371 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4374 SYMBOL_VALUE_ADDRESS (sym) =
4375 base + decode_locdesc (DW_BLOCK (attr), cu);
4376 add_symbol_to_list (sym, &global_symbols);
4378 child_die = sibling_die (child_die);
4383 /* Read a C++ namespace. */
4386 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4388 struct objfile *objfile = cu->objfile;
4389 const char *previous_prefix = processing_current_prefix;
4392 struct die_info *current_die;
4393 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4395 name = namespace_name (die, &is_anonymous, cu);
4397 /* Now build the name of the current namespace. */
4399 if (previous_prefix[0] == '\0')
4401 processing_current_prefix = name;
4405 char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4406 make_cleanup (xfree, temp_name);
4407 processing_current_prefix = temp_name;
4410 /* Add a symbol associated to this if we haven't seen the namespace
4411 before. Also, add a using directive if it's an anonymous
4414 if (dwarf2_extension (die, cu) == NULL)
4418 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4419 this cast will hopefully become unnecessary. */
4420 type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4421 (char *) processing_current_prefix,
4423 TYPE_TAG_NAME (type) = TYPE_NAME (type);
4425 new_symbol (die, type, cu);
4426 set_die_type (die, type, cu);
4429 cp_add_using_directive (processing_current_prefix,
4430 strlen (previous_prefix),
4431 strlen (processing_current_prefix));
4434 if (die->child != NULL)
4436 struct die_info *child_die = die->child;
4438 while (child_die && child_die->tag)
4440 process_die (child_die, cu);
4441 child_die = sibling_die (child_die);
4445 processing_current_prefix = previous_prefix;
4446 do_cleanups (back_to);
4449 /* Return the name of the namespace represented by DIE. Set
4450 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4454 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4456 struct die_info *current_die;
4457 const char *name = NULL;
4459 /* Loop through the extensions until we find a name. */
4461 for (current_die = die;
4462 current_die != NULL;
4463 current_die = dwarf2_extension (die, cu))
4465 name = dwarf2_name (current_die, cu);
4470 /* Is it an anonymous namespace? */
4472 *is_anonymous = (name == NULL);
4474 name = "(anonymous namespace)";
4479 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4480 the user defined type vector. */
4483 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4485 struct comp_unit_head *cu_header = &cu->header;
4487 struct attribute *attr_byte_size;
4488 struct attribute *attr_address_class;
4489 int byte_size, addr_class;
4496 type = lookup_pointer_type (die_type (die, cu));
4498 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4500 byte_size = DW_UNSND (attr_byte_size);
4502 byte_size = cu_header->addr_size;
4504 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4505 if (attr_address_class)
4506 addr_class = DW_UNSND (attr_address_class);
4508 addr_class = DW_ADDR_none;
4510 /* If the pointer size or address class is different than the
4511 default, create a type variant marked as such and set the
4512 length accordingly. */
4513 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4515 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4519 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
4520 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4521 type = make_type_with_address_space (type, type_flags);
4523 else if (TYPE_LENGTH (type) != byte_size)
4525 complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4528 /* Should we also complain about unhandled address classes? */
4532 TYPE_LENGTH (type) = byte_size;
4533 set_die_type (die, type, cu);
4536 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4537 the user defined type vector. */
4540 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4542 struct objfile *objfile = cu->objfile;
4544 struct type *to_type;
4545 struct type *domain;
4552 type = alloc_type (objfile);
4553 to_type = die_type (die, cu);
4554 domain = die_containing_type (die, cu);
4555 smash_to_member_type (type, domain, to_type);
4557 set_die_type (die, type, cu);
4560 /* Extract all information from a DW_TAG_reference_type DIE and add to
4561 the user defined type vector. */
4564 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4566 struct comp_unit_head *cu_header = &cu->header;
4568 struct attribute *attr;
4575 type = lookup_reference_type (die_type (die, cu));
4576 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4579 TYPE_LENGTH (type) = DW_UNSND (attr);
4583 TYPE_LENGTH (type) = cu_header->addr_size;
4585 set_die_type (die, type, cu);
4589 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4591 struct type *base_type;
4598 base_type = die_type (die, cu);
4599 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4604 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4606 struct type *base_type;
4613 base_type = die_type (die, cu);
4614 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4618 /* Extract all information from a DW_TAG_string_type DIE and add to
4619 the user defined type vector. It isn't really a user defined type,
4620 but it behaves like one, with other DIE's using an AT_user_def_type
4621 attribute to reference it. */
4624 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4626 struct objfile *objfile = cu->objfile;
4627 struct type *type, *range_type, *index_type, *char_type;
4628 struct attribute *attr;
4629 unsigned int length;
4636 attr = dwarf2_attr (die, DW_AT_string_length, cu);
4639 length = DW_UNSND (attr);
4643 /* check for the DW_AT_byte_size attribute */
4644 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4647 length = DW_UNSND (attr);
4654 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4655 range_type = create_range_type (NULL, index_type, 1, length);
4656 if (cu->language == language_fortran)
4658 /* Need to create a unique string type for bounds
4660 type = create_string_type (0, range_type);
4664 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4665 type = create_string_type (char_type, range_type);
4667 set_die_type (die, type, cu);
4670 /* Handle DIES due to C code like:
4674 int (*funcp)(int a, long l);
4678 ('funcp' generates a DW_TAG_subroutine_type DIE)
4682 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4684 struct type *type; /* Type that this function returns */
4685 struct type *ftype; /* Function that returns above type */
4686 struct attribute *attr;
4687 struct die_info *spec_die;
4689 /* Decode the type that this subroutine returns */
4695 /* This works around a bug in armcc. It marks "this" as artificial
4696 in the declaration but not in the definition. It's also more
4697 efficient. Should we be doing this for all types? */
4698 spec_die = die_specification (die, cu);
4701 if (spec_die->type == NULL)
4702 read_type_die (spec_die, cu);
4703 die->type = spec_die->type;
4704 set_die_type (die, die->type, cu);
4708 type = die_type (die, cu);
4709 ftype = make_function_type (type, (struct type **) 0);
4711 /* All functions in C++ and Java have prototypes. */
4712 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4713 if ((attr && (DW_UNSND (attr) != 0))
4714 || cu->language == language_cplus
4715 || cu->language == language_java)
4716 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4718 if (die->child != NULL)
4720 struct die_info *child_die;
4724 /* Count the number of parameters.
4725 FIXME: GDB currently ignores vararg functions, but knows about
4726 vararg member functions. */
4727 child_die = die->child;
4728 while (child_die && child_die->tag)
4730 if (child_die->tag == DW_TAG_formal_parameter)
4732 else if (child_die->tag == DW_TAG_unspecified_parameters)
4733 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4734 child_die = sibling_die (child_die);
4737 /* Allocate storage for parameters and fill them in. */
4738 TYPE_NFIELDS (ftype) = nparams;
4739 TYPE_FIELDS (ftype) = (struct field *)
4740 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4742 child_die = die->child;
4743 while (child_die && child_die->tag)
4745 if (child_die->tag == DW_TAG_formal_parameter)
4747 /* Dwarf2 has no clean way to discern C++ static and non-static
4748 member functions. G++ helps GDB by marking the first
4749 parameter for non-static member functions (which is the
4750 this pointer) as artificial. We pass this information
4751 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4752 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4754 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4756 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4757 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4760 child_die = sibling_die (child_die);
4764 set_die_type (die, ftype, cu);
4768 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4770 struct objfile *objfile = cu->objfile;
4771 struct attribute *attr;
4776 attr = dwarf2_attr (die, DW_AT_name, cu);
4777 if (attr && DW_STRING (attr))
4779 name = DW_STRING (attr);
4781 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4782 TYPE_FLAG_TARGET_STUB, name, objfile),
4784 TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4788 /* Find a representation of a given base type and install
4789 it in the TYPE field of the die. */
4792 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4794 struct objfile *objfile = cu->objfile;
4796 struct attribute *attr;
4797 int encoding = 0, size = 0;
4799 /* If we've already decoded this die, this is a no-op. */
4805 attr = dwarf2_attr (die, DW_AT_encoding, cu);
4808 encoding = DW_UNSND (attr);
4810 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4813 size = DW_UNSND (attr);
4815 attr = dwarf2_attr (die, DW_AT_name, cu);
4816 if (attr && DW_STRING (attr))
4818 enum type_code code = TYPE_CODE_INT;
4823 case DW_ATE_address:
4824 /* Turn DW_ATE_address into a void * pointer. */
4825 code = TYPE_CODE_PTR;
4826 type_flags |= TYPE_FLAG_UNSIGNED;
4828 case DW_ATE_boolean:
4829 code = TYPE_CODE_BOOL;
4830 type_flags |= TYPE_FLAG_UNSIGNED;
4832 case DW_ATE_complex_float:
4833 code = TYPE_CODE_COMPLEX;
4836 code = TYPE_CODE_FLT;
4839 case DW_ATE_signed_char:
4841 case DW_ATE_unsigned:
4842 case DW_ATE_unsigned_char:
4843 type_flags |= TYPE_FLAG_UNSIGNED;
4846 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
4847 dwarf_type_encoding_name (encoding));
4850 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4851 if (encoding == DW_ATE_address)
4852 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4854 else if (encoding == DW_ATE_complex_float)
4857 TYPE_TARGET_TYPE (type)
4858 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4859 else if (size == 16)
4860 TYPE_TARGET_TYPE (type)
4861 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4863 TYPE_TARGET_TYPE (type)
4864 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4869 type = dwarf_base_type (encoding, size, cu);
4871 set_die_type (die, type, cu);
4874 /* Read the given DW_AT_subrange DIE. */
4877 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4879 struct type *base_type;
4880 struct type *range_type;
4881 struct attribute *attr;
4885 /* If we have already decoded this die, then nothing more to do. */
4889 base_type = die_type (die, cu);
4890 if (base_type == NULL)
4892 complaint (&symfile_complaints,
4893 _("DW_AT_type missing from DW_TAG_subrange_type"));
4897 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4898 base_type = alloc_type (NULL);
4900 if (cu->language == language_fortran)
4902 /* FORTRAN implies a lower bound of 1, if not given. */
4906 /* FIXME: For variable sized arrays either of these could be
4907 a variable rather than a constant value. We'll allow it,
4908 but we don't know how to handle it. */
4909 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4911 low = dwarf2_get_attr_constant_value (attr, 0);
4913 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4916 if (attr->form == DW_FORM_block1)
4918 /* GCC encodes arrays with unspecified or dynamic length
4919 with a DW_FORM_block1 attribute.
4920 FIXME: GDB does not yet know how to handle dynamic
4921 arrays properly, treat them as arrays with unspecified
4924 FIXME: jimb/2003-09-22: GDB does not really know
4925 how to handle arrays of unspecified length
4926 either; we just represent them as zero-length
4927 arrays. Choose an appropriate upper bound given
4928 the lower bound we've computed above. */
4932 high = dwarf2_get_attr_constant_value (attr, 1);
4935 range_type = create_range_type (NULL, base_type, low, high);
4937 attr = dwarf2_attr (die, DW_AT_name, cu);
4938 if (attr && DW_STRING (attr))
4939 TYPE_NAME (range_type) = DW_STRING (attr);
4941 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4943 TYPE_LENGTH (range_type) = DW_UNSND (attr);
4945 set_die_type (die, range_type, cu);
4949 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
4952 struct attribute *attr;
4957 /* For now, we only support the C meaning of an unspecified type: void. */
4959 attr = dwarf2_attr (die, DW_AT_name, cu);
4960 type = init_type (TYPE_CODE_VOID, 0, 0, attr ? DW_STRING (attr) : "",
4963 set_die_type (die, type, cu);
4966 /* Read a whole compilation unit into a linked list of dies. */
4968 static struct die_info *
4969 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4971 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4974 /* Read a single die and all its descendents. Set the die's sibling
4975 field to NULL; set other fields in the die correctly, and set all
4976 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4977 location of the info_ptr after reading all of those dies. PARENT
4978 is the parent of the die in question. */
4980 static struct die_info *
4981 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
4982 struct dwarf2_cu *cu,
4983 gdb_byte **new_info_ptr,
4984 struct die_info *parent)
4986 struct die_info *die;
4990 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4991 store_in_ref_table (die->offset, die, cu);
4995 die->child = read_die_and_siblings (cur_ptr, abfd, cu,
5001 *new_info_ptr = cur_ptr;
5004 die->sibling = NULL;
5005 die->parent = parent;
5009 /* Read a die, all of its descendents, and all of its siblings; set
5010 all of the fields of all of the dies correctly. Arguments are as
5011 in read_die_and_children. */
5013 static struct die_info *
5014 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
5015 struct dwarf2_cu *cu,
5016 gdb_byte **new_info_ptr,
5017 struct die_info *parent)
5019 struct die_info *first_die, *last_sibling;
5023 first_die = last_sibling = NULL;
5027 struct die_info *die
5028 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
5036 last_sibling->sibling = die;
5041 *new_info_ptr = cur_ptr;
5051 /* Free a linked list of dies. */
5054 free_die_list (struct die_info *dies)
5056 struct die_info *die, *next;
5061 if (die->child != NULL)
5062 free_die_list (die->child);
5063 next = die->sibling;
5070 /* Read the contents of the section at OFFSET and of size SIZE from the
5071 object file specified by OBJFILE into the objfile_obstack and return it. */
5074 dwarf2_read_section (struct objfile *objfile, asection *sectp)
5076 bfd *abfd = objfile->obfd;
5077 gdb_byte *buf, *retbuf;
5078 bfd_size_type size = bfd_get_section_size (sectp);
5083 buf = obstack_alloc (&objfile->objfile_obstack, size);
5084 retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
5088 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
5089 || bfd_bread (buf, size, abfd) != size)
5090 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5091 bfd_get_filename (abfd));
5096 /* In DWARF version 2, the description of the debugging information is
5097 stored in a separate .debug_abbrev section. Before we read any
5098 dies from a section we read in all abbreviations and install them
5099 in a hash table. This function also sets flags in CU describing
5100 the data found in the abbrev table. */
5103 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
5105 struct comp_unit_head *cu_header = &cu->header;
5106 gdb_byte *abbrev_ptr;
5107 struct abbrev_info *cur_abbrev;
5108 unsigned int abbrev_number, bytes_read, abbrev_name;
5109 unsigned int abbrev_form, hash_number;
5110 struct attr_abbrev *cur_attrs;
5111 unsigned int allocated_attrs;
5113 /* Initialize dwarf2 abbrevs */
5114 obstack_init (&cu->abbrev_obstack);
5115 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
5117 * sizeof (struct abbrev_info *)));
5118 memset (cu->dwarf2_abbrevs, 0,
5119 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
5121 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
5122 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5123 abbrev_ptr += bytes_read;
5125 allocated_attrs = ATTR_ALLOC_CHUNK;
5126 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
5128 /* loop until we reach an abbrev number of 0 */
5129 while (abbrev_number)
5131 cur_abbrev = dwarf_alloc_abbrev (cu);
5133 /* read in abbrev header */
5134 cur_abbrev->number = abbrev_number;
5135 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5136 abbrev_ptr += bytes_read;
5137 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5140 if (cur_abbrev->tag == DW_TAG_namespace)
5141 cu->has_namespace_info = 1;
5143 /* now read in declarations */
5144 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5145 abbrev_ptr += bytes_read;
5146 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5147 abbrev_ptr += bytes_read;
5150 if (cur_abbrev->num_attrs == allocated_attrs)
5152 allocated_attrs += ATTR_ALLOC_CHUNK;
5154 = xrealloc (cur_attrs, (allocated_attrs
5155 * sizeof (struct attr_abbrev)));
5158 /* Record whether this compilation unit might have
5159 inter-compilation-unit references. If we don't know what form
5160 this attribute will have, then it might potentially be a
5161 DW_FORM_ref_addr, so we conservatively expect inter-CU
5164 if (abbrev_form == DW_FORM_ref_addr
5165 || abbrev_form == DW_FORM_indirect)
5166 cu->has_form_ref_addr = 1;
5168 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5169 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5170 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5171 abbrev_ptr += bytes_read;
5172 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5173 abbrev_ptr += bytes_read;
5176 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5177 (cur_abbrev->num_attrs
5178 * sizeof (struct attr_abbrev)));
5179 memcpy (cur_abbrev->attrs, cur_attrs,
5180 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5182 hash_number = abbrev_number % ABBREV_HASH_SIZE;
5183 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5184 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5186 /* Get next abbreviation.
5187 Under Irix6 the abbreviations for a compilation unit are not
5188 always properly terminated with an abbrev number of 0.
5189 Exit loop if we encounter an abbreviation which we have
5190 already read (which means we are about to read the abbreviations
5191 for the next compile unit) or if the end of the abbreviation
5192 table is reached. */
5193 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5194 >= dwarf2_per_objfile->abbrev_size)
5196 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5197 abbrev_ptr += bytes_read;
5198 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5205 /* Release the memory used by the abbrev table for a compilation unit. */
5208 dwarf2_free_abbrev_table (void *ptr_to_cu)
5210 struct dwarf2_cu *cu = ptr_to_cu;
5212 obstack_free (&cu->abbrev_obstack, NULL);
5213 cu->dwarf2_abbrevs = NULL;
5216 /* Lookup an abbrev_info structure in the abbrev hash table. */
5218 static struct abbrev_info *
5219 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5221 unsigned int hash_number;
5222 struct abbrev_info *abbrev;
5224 hash_number = number % ABBREV_HASH_SIZE;
5225 abbrev = cu->dwarf2_abbrevs[hash_number];
5229 if (abbrev->number == number)
5232 abbrev = abbrev->next;
5237 /* Returns nonzero if TAG represents a type that we might generate a partial
5241 is_type_tag_for_partial (int tag)
5246 /* Some types that would be reasonable to generate partial symbols for,
5247 that we don't at present. */
5248 case DW_TAG_array_type:
5249 case DW_TAG_file_type:
5250 case DW_TAG_ptr_to_member_type:
5251 case DW_TAG_set_type:
5252 case DW_TAG_string_type:
5253 case DW_TAG_subroutine_type:
5255 case DW_TAG_base_type:
5256 case DW_TAG_class_type:
5257 case DW_TAG_enumeration_type:
5258 case DW_TAG_structure_type:
5259 case DW_TAG_subrange_type:
5260 case DW_TAG_typedef:
5261 case DW_TAG_union_type:
5268 /* Load all DIEs that are interesting for partial symbols into memory. */
5270 static struct partial_die_info *
5271 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5272 struct dwarf2_cu *cu)
5274 struct partial_die_info *part_die;
5275 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5276 struct abbrev_info *abbrev;
5277 unsigned int bytes_read;
5278 unsigned int load_all = 0;
5280 int nesting_level = 1;
5285 if (cu->per_cu && cu->per_cu->load_all_dies)
5289 = htab_create_alloc_ex (cu->header.length / 12,
5293 &cu->comp_unit_obstack,
5294 hashtab_obstack_allocate,
5295 dummy_obstack_deallocate);
5297 part_die = obstack_alloc (&cu->comp_unit_obstack,
5298 sizeof (struct partial_die_info));
5302 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5304 /* A NULL abbrev means the end of a series of children. */
5307 if (--nesting_level == 0)
5309 /* PART_DIE was probably the last thing allocated on the
5310 comp_unit_obstack, so we could call obstack_free
5311 here. We don't do that because the waste is small,
5312 and will be cleaned up when we're done with this
5313 compilation unit. This way, we're also more robust
5314 against other users of the comp_unit_obstack. */
5317 info_ptr += bytes_read;
5318 last_die = parent_die;
5319 parent_die = parent_die->die_parent;
5323 /* Check whether this DIE is interesting enough to save. Normally
5324 we would not be interested in members here, but there may be
5325 later variables referencing them via DW_AT_specification (for
5328 && !is_type_tag_for_partial (abbrev->tag)
5329 && abbrev->tag != DW_TAG_enumerator
5330 && abbrev->tag != DW_TAG_subprogram
5331 && abbrev->tag != DW_TAG_variable
5332 && abbrev->tag != DW_TAG_namespace
5333 && abbrev->tag != DW_TAG_member)
5335 /* Otherwise we skip to the next sibling, if any. */
5336 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5340 info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5341 abfd, info_ptr, cu);
5343 /* This two-pass algorithm for processing partial symbols has a
5344 high cost in cache pressure. Thus, handle some simple cases
5345 here which cover the majority of C partial symbols. DIEs
5346 which neither have specification tags in them, nor could have
5347 specification tags elsewhere pointing at them, can simply be
5348 processed and discarded.
5350 This segment is also optional; scan_partial_symbols and
5351 add_partial_symbol will handle these DIEs if we chain
5352 them in normally. When compilers which do not emit large
5353 quantities of duplicate debug information are more common,
5354 this code can probably be removed. */
5356 /* Any complete simple types at the top level (pretty much all
5357 of them, for a language without namespaces), can be processed
5359 if (parent_die == NULL
5360 && part_die->has_specification == 0
5361 && part_die->is_declaration == 0
5362 && (part_die->tag == DW_TAG_typedef
5363 || part_die->tag == DW_TAG_base_type
5364 || part_die->tag == DW_TAG_subrange_type))
5366 if (building_psymtab && part_die->name != NULL)
5367 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5368 VAR_DOMAIN, LOC_TYPEDEF,
5369 &cu->objfile->static_psymbols,
5370 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5371 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5375 /* If we're at the second level, and we're an enumerator, and
5376 our parent has no specification (meaning possibly lives in a
5377 namespace elsewhere), then we can add the partial symbol now
5378 instead of queueing it. */
5379 if (part_die->tag == DW_TAG_enumerator
5380 && parent_die != NULL
5381 && parent_die->die_parent == NULL
5382 && parent_die->tag == DW_TAG_enumeration_type
5383 && parent_die->has_specification == 0)
5385 if (part_die->name == NULL)
5386 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5387 else if (building_psymtab)
5388 add_psymbol_to_list (part_die->name, strlen (part_die->name),
5389 VAR_DOMAIN, LOC_CONST,
5390 (cu->language == language_cplus
5391 || cu->language == language_java)
5392 ? &cu->objfile->global_psymbols
5393 : &cu->objfile->static_psymbols,
5394 0, (CORE_ADDR) 0, cu->language, cu->objfile);
5396 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5400 /* We'll save this DIE so link it in. */
5401 part_die->die_parent = parent_die;
5402 part_die->die_sibling = NULL;
5403 part_die->die_child = NULL;
5405 if (last_die && last_die == parent_die)
5406 last_die->die_child = part_die;
5408 last_die->die_sibling = part_die;
5410 last_die = part_die;
5412 if (first_die == NULL)
5413 first_die = part_die;
5415 /* Maybe add the DIE to the hash table. Not all DIEs that we
5416 find interesting need to be in the hash table, because we
5417 also have the parent/sibling/child chains; only those that we
5418 might refer to by offset later during partial symbol reading.
5420 For now this means things that might have be the target of a
5421 DW_AT_specification, DW_AT_abstract_origin, or
5422 DW_AT_extension. DW_AT_extension will refer only to
5423 namespaces; DW_AT_abstract_origin refers to functions (and
5424 many things under the function DIE, but we do not recurse
5425 into function DIEs during partial symbol reading) and
5426 possibly variables as well; DW_AT_specification refers to
5427 declarations. Declarations ought to have the DW_AT_declaration
5428 flag. It happens that GCC forgets to put it in sometimes, but
5429 only for functions, not for types.
5431 Adding more things than necessary to the hash table is harmless
5432 except for the performance cost. Adding too few will result in
5433 wasted time in find_partial_die, when we reread the compilation
5434 unit with load_all_dies set. */
5437 || abbrev->tag == DW_TAG_subprogram
5438 || abbrev->tag == DW_TAG_variable
5439 || abbrev->tag == DW_TAG_namespace
5440 || part_die->is_declaration)
5444 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5445 part_die->offset, INSERT);
5449 part_die = obstack_alloc (&cu->comp_unit_obstack,
5450 sizeof (struct partial_die_info));
5452 /* For some DIEs we want to follow their children (if any). For C
5453 we have no reason to follow the children of structures; for other
5454 languages we have to, both so that we can get at method physnames
5455 to infer fully qualified class names, and for DW_AT_specification. */
5456 if (last_die->has_children
5458 || last_die->tag == DW_TAG_namespace
5459 || last_die->tag == DW_TAG_enumeration_type
5460 || (cu->language != language_c
5461 && (last_die->tag == DW_TAG_class_type
5462 || last_die->tag == DW_TAG_structure_type
5463 || last_die->tag == DW_TAG_union_type))))
5466 parent_die = last_die;
5470 /* Otherwise we skip to the next sibling, if any. */
5471 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5473 /* Back to the top, do it again. */
5477 /* Read a minimal amount of information into the minimal die structure. */
5480 read_partial_die (struct partial_die_info *part_die,
5481 struct abbrev_info *abbrev,
5482 unsigned int abbrev_len, bfd *abfd,
5483 gdb_byte *info_ptr, struct dwarf2_cu *cu)
5485 unsigned int bytes_read, i;
5486 struct attribute attr;
5487 int has_low_pc_attr = 0;
5488 int has_high_pc_attr = 0;
5490 memset (part_die, 0, sizeof (struct partial_die_info));
5492 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5494 info_ptr += abbrev_len;
5499 part_die->tag = abbrev->tag;
5500 part_die->has_children = abbrev->has_children;
5502 for (i = 0; i < abbrev->num_attrs; ++i)
5504 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5506 /* Store the data if it is of an attribute we want to keep in a
5507 partial symbol table. */
5512 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5513 if (part_die->name == NULL)
5514 part_die->name = DW_STRING (&attr);
5516 case DW_AT_comp_dir:
5517 if (part_die->dirname == NULL)
5518 part_die->dirname = DW_STRING (&attr);
5520 case DW_AT_MIPS_linkage_name:
5521 part_die->name = DW_STRING (&attr);
5524 has_low_pc_attr = 1;
5525 part_die->lowpc = DW_ADDR (&attr);
5528 has_high_pc_attr = 1;
5529 part_die->highpc = DW_ADDR (&attr);
5531 case DW_AT_location:
5532 /* Support the .debug_loc offsets */
5533 if (attr_form_is_block (&attr))
5535 part_die->locdesc = DW_BLOCK (&attr);
5537 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
5539 dwarf2_complex_location_expr_complaint ();
5543 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5544 "partial symbol information");
5547 case DW_AT_language:
5548 part_die->language = DW_UNSND (&attr);
5550 case DW_AT_external:
5551 part_die->is_external = DW_UNSND (&attr);
5553 case DW_AT_declaration:
5554 part_die->is_declaration = DW_UNSND (&attr);
5557 part_die->has_type = 1;
5559 case DW_AT_abstract_origin:
5560 case DW_AT_specification:
5561 case DW_AT_extension:
5562 part_die->has_specification = 1;
5563 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5566 /* Ignore absolute siblings, they might point outside of
5567 the current compile unit. */
5568 if (attr.form == DW_FORM_ref_addr)
5569 complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5571 part_die->sibling = dwarf2_per_objfile->info_buffer
5572 + dwarf2_get_ref_die_offset (&attr, cu);
5574 case DW_AT_stmt_list:
5575 part_die->has_stmt_list = 1;
5576 part_die->line_offset = DW_UNSND (&attr);
5583 /* When using the GNU linker, .gnu.linkonce. sections are used to
5584 eliminate duplicate copies of functions and vtables and such.
5585 The linker will arbitrarily choose one and discard the others.
5586 The AT_*_pc values for such functions refer to local labels in
5587 these sections. If the section from that file was discarded, the
5588 labels are not in the output, so the relocs get a value of 0.
5589 If this is a discarded function, mark the pc bounds as invalid,
5590 so that GDB will ignore it. */
5591 if (has_low_pc_attr && has_high_pc_attr
5592 && part_die->lowpc < part_die->highpc
5593 && (part_die->lowpc != 0
5594 || (bfd_get_file_flags (abfd) & HAS_RELOC)))
5595 part_die->has_pc_info = 1;
5599 /* Find a cached partial DIE at OFFSET in CU. */
5601 static struct partial_die_info *
5602 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5604 struct partial_die_info *lookup_die = NULL;
5605 struct partial_die_info part_die;
5607 part_die.offset = offset;
5608 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5613 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5615 static struct partial_die_info *
5616 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5618 struct dwarf2_per_cu_data *per_cu = NULL;
5619 struct partial_die_info *pd = NULL;
5621 if (offset >= cu->header.offset
5622 && offset < cu->header.offset + cu->header.length)
5624 pd = find_partial_die_in_comp_unit (offset, cu);
5629 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5631 if (per_cu->cu == NULL)
5633 load_comp_unit (per_cu, cu->objfile);
5634 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5635 dwarf2_per_objfile->read_in_chain = per_cu;
5638 per_cu->cu->last_used = 0;
5639 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5641 if (pd == NULL && per_cu->load_all_dies == 0)
5643 struct cleanup *back_to;
5644 struct partial_die_info comp_unit_die;
5645 struct abbrev_info *abbrev;
5646 unsigned int bytes_read;
5649 per_cu->load_all_dies = 1;
5651 /* Re-read the DIEs. */
5652 back_to = make_cleanup (null_cleanup, 0);
5653 if (per_cu->cu->dwarf2_abbrevs == NULL)
5655 dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
5656 back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
5658 info_ptr = per_cu->cu->header.first_die_ptr;
5659 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
5660 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
5661 per_cu->cu->objfile->obfd, info_ptr,
5663 if (comp_unit_die.has_children)
5664 load_partial_dies (per_cu->cu->objfile->obfd, info_ptr, 0, per_cu->cu);
5665 do_cleanups (back_to);
5667 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5671 internal_error (__FILE__, __LINE__,
5672 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5673 offset, bfd_get_filename (cu->objfile->obfd));
5677 /* Adjust PART_DIE before generating a symbol for it. This function
5678 may set the is_external flag or change the DIE's name. */
5681 fixup_partial_die (struct partial_die_info *part_die,
5682 struct dwarf2_cu *cu)
5684 /* If we found a reference attribute and the DIE has no name, try
5685 to find a name in the referred to DIE. */
5687 if (part_die->name == NULL && part_die->has_specification)
5689 struct partial_die_info *spec_die;
5691 spec_die = find_partial_die (part_die->spec_offset, cu);
5693 fixup_partial_die (spec_die, cu);
5697 part_die->name = spec_die->name;
5699 /* Copy DW_AT_external attribute if it is set. */
5700 if (spec_die->is_external)
5701 part_die->is_external = spec_die->is_external;
5705 /* Set default names for some unnamed DIEs. */
5706 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5707 || part_die->tag == DW_TAG_class_type))
5708 part_die->name = "(anonymous class)";
5710 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5711 part_die->name = "(anonymous namespace)";
5713 if (part_die->tag == DW_TAG_structure_type
5714 || part_die->tag == DW_TAG_class_type
5715 || part_die->tag == DW_TAG_union_type)
5716 guess_structure_name (part_die, cu);
5719 /* Read the die from the .debug_info section buffer. Set DIEP to
5720 point to a newly allocated die with its information, except for its
5721 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5722 whether the die has children or not. */
5725 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5726 struct dwarf2_cu *cu, int *has_children)
5728 unsigned int abbrev_number, bytes_read, i, offset;
5729 struct abbrev_info *abbrev;
5730 struct die_info *die;
5732 offset = info_ptr - dwarf2_per_objfile->info_buffer;
5733 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5734 info_ptr += bytes_read;
5737 die = dwarf_alloc_die ();
5739 die->abbrev = abbrev_number;
5746 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5749 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5751 bfd_get_filename (abfd));
5753 die = dwarf_alloc_die ();
5754 die->offset = offset;
5755 die->tag = abbrev->tag;
5756 die->abbrev = abbrev_number;
5759 die->num_attrs = abbrev->num_attrs;
5760 die->attrs = (struct attribute *)
5761 xmalloc (die->num_attrs * sizeof (struct attribute));
5763 for (i = 0; i < abbrev->num_attrs; ++i)
5765 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5766 abfd, info_ptr, cu);
5768 /* If this attribute is an absolute reference to a different
5769 compilation unit, make sure that compilation unit is loaded
5771 if (die->attrs[i].form == DW_FORM_ref_addr
5772 && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5773 || (DW_ADDR (&die->attrs[i])
5774 >= cu->header.offset + cu->header.length)))
5776 struct dwarf2_per_cu_data *per_cu;
5777 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5780 /* Mark the dependence relation so that we don't flush PER_CU
5782 dwarf2_add_dependence (cu, per_cu);
5784 /* If it's already on the queue, we have nothing to do. */
5788 /* If the compilation unit is already loaded, just mark it as
5790 if (per_cu->cu != NULL)
5792 per_cu->cu->last_used = 0;
5796 /* Add it to the queue. */
5797 queue_comp_unit (per_cu);
5802 *has_children = abbrev->has_children;
5806 /* Read an attribute value described by an attribute form. */
5809 read_attribute_value (struct attribute *attr, unsigned form,
5810 bfd *abfd, gdb_byte *info_ptr,
5811 struct dwarf2_cu *cu)
5813 struct comp_unit_head *cu_header = &cu->header;
5814 unsigned int bytes_read;
5815 struct dwarf_block *blk;
5821 case DW_FORM_ref_addr:
5822 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5823 info_ptr += bytes_read;
5825 case DW_FORM_block2:
5826 blk = dwarf_alloc_block (cu);
5827 blk->size = read_2_bytes (abfd, info_ptr);
5829 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5830 info_ptr += blk->size;
5831 DW_BLOCK (attr) = blk;
5833 case DW_FORM_block4:
5834 blk = dwarf_alloc_block (cu);
5835 blk->size = read_4_bytes (abfd, info_ptr);
5837 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5838 info_ptr += blk->size;
5839 DW_BLOCK (attr) = blk;
5842 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5846 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5850 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5853 case DW_FORM_string:
5854 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5855 info_ptr += bytes_read;
5858 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5860 info_ptr += bytes_read;
5863 blk = dwarf_alloc_block (cu);
5864 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5865 info_ptr += bytes_read;
5866 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5867 info_ptr += blk->size;
5868 DW_BLOCK (attr) = blk;
5870 case DW_FORM_block1:
5871 blk = dwarf_alloc_block (cu);
5872 blk->size = read_1_byte (abfd, info_ptr);
5874 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5875 info_ptr += blk->size;
5876 DW_BLOCK (attr) = blk;
5879 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5883 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5887 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5888 info_ptr += bytes_read;
5891 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5892 info_ptr += bytes_read;
5895 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
5899 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
5903 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
5907 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
5910 case DW_FORM_ref_udata:
5911 DW_ADDR (attr) = (cu->header.offset
5912 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
5913 info_ptr += bytes_read;
5915 case DW_FORM_indirect:
5916 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5917 info_ptr += bytes_read;
5918 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5921 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5922 dwarf_form_name (form),
5923 bfd_get_filename (abfd));
5928 /* Read an attribute described by an abbreviated attribute. */
5931 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5932 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
5934 attr->name = abbrev->name;
5935 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5938 /* read dwarf information from a buffer */
5941 read_1_byte (bfd *abfd, gdb_byte *buf)
5943 return bfd_get_8 (abfd, buf);
5947 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
5949 return bfd_get_signed_8 (abfd, buf);
5953 read_2_bytes (bfd *abfd, gdb_byte *buf)
5955 return bfd_get_16 (abfd, buf);
5959 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
5961 return bfd_get_signed_16 (abfd, buf);
5965 read_4_bytes (bfd *abfd, gdb_byte *buf)
5967 return bfd_get_32 (abfd, buf);
5971 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
5973 return bfd_get_signed_32 (abfd, buf);
5976 static unsigned long
5977 read_8_bytes (bfd *abfd, gdb_byte *buf)
5979 return bfd_get_64 (abfd, buf);
5983 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
5984 unsigned int *bytes_read)
5986 struct comp_unit_head *cu_header = &cu->header;
5987 CORE_ADDR retval = 0;
5989 if (cu_header->signed_addr_p)
5991 switch (cu_header->addr_size)
5994 retval = bfd_get_signed_16 (abfd, buf);
5997 retval = bfd_get_signed_32 (abfd, buf);
6000 retval = bfd_get_signed_64 (abfd, buf);
6003 internal_error (__FILE__, __LINE__,
6004 _("read_address: bad switch, signed [in module %s]"),
6005 bfd_get_filename (abfd));
6010 switch (cu_header->addr_size)
6013 retval = bfd_get_16 (abfd, buf);
6016 retval = bfd_get_32 (abfd, buf);
6019 retval = bfd_get_64 (abfd, buf);
6022 internal_error (__FILE__, __LINE__,
6023 _("read_address: bad switch, unsigned [in module %s]"),
6024 bfd_get_filename (abfd));
6028 *bytes_read = cu_header->addr_size;
6032 /* Read the initial length from a section. The (draft) DWARF 3
6033 specification allows the initial length to take up either 4 bytes
6034 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6035 bytes describe the length and all offsets will be 8 bytes in length
6038 An older, non-standard 64-bit format is also handled by this
6039 function. The older format in question stores the initial length
6040 as an 8-byte quantity without an escape value. Lengths greater
6041 than 2^32 aren't very common which means that the initial 4 bytes
6042 is almost always zero. Since a length value of zero doesn't make
6043 sense for the 32-bit format, this initial zero can be considered to
6044 be an escape value which indicates the presence of the older 64-bit
6045 format. As written, the code can't detect (old format) lengths
6046 greater than 4GB. If it becomes necessary to handle lengths
6047 somewhat larger than 4GB, we could allow other small values (such
6048 as the non-sensical values of 1, 2, and 3) to also be used as
6049 escape values indicating the presence of the old format.
6051 The value returned via bytes_read should be used to increment the
6052 relevant pointer after calling read_initial_length().
6054 As a side effect, this function sets the fields initial_length_size
6055 and offset_size in cu_header to the values appropriate for the
6056 length field. (The format of the initial length field determines
6057 the width of file offsets to be fetched later with read_offset().)
6059 [ Note: read_initial_length() and read_offset() are based on the
6060 document entitled "DWARF Debugging Information Format", revision
6061 3, draft 8, dated November 19, 2001. This document was obtained
6064 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6066 This document is only a draft and is subject to change. (So beware.)
6068 Details regarding the older, non-standard 64-bit format were
6069 determined empirically by examining 64-bit ELF files produced by
6070 the SGI toolchain on an IRIX 6.5 machine.
6072 - Kevin, July 16, 2002
6076 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
6077 unsigned int *bytes_read)
6079 LONGEST length = bfd_get_32 (abfd, buf);
6081 if (length == 0xffffffff)
6083 length = bfd_get_64 (abfd, buf + 4);
6086 else if (length == 0)
6088 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6089 length = bfd_get_64 (abfd, buf);
6099 gdb_assert (cu_header->initial_length_size == 0
6100 || cu_header->initial_length_size == 4
6101 || cu_header->initial_length_size == 8
6102 || cu_header->initial_length_size == 12);
6104 if (cu_header->initial_length_size != 0
6105 && cu_header->initial_length_size != *bytes_read)
6106 complaint (&symfile_complaints,
6107 _("intermixed 32-bit and 64-bit DWARF sections"));
6109 cu_header->initial_length_size = *bytes_read;
6110 cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
6116 /* Read an offset from the data stream. The size of the offset is
6117 given by cu_header->offset_size. */
6120 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
6121 unsigned int *bytes_read)
6125 switch (cu_header->offset_size)
6128 retval = bfd_get_32 (abfd, buf);
6132 retval = bfd_get_64 (abfd, buf);
6136 internal_error (__FILE__, __LINE__,
6137 _("read_offset: bad switch [in module %s]"),
6138 bfd_get_filename (abfd));
6145 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
6147 /* If the size of a host char is 8 bits, we can return a pointer
6148 to the buffer, otherwise we have to copy the data to a buffer
6149 allocated on the temporary obstack. */
6150 gdb_assert (HOST_CHAR_BIT == 8);
6155 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6157 /* If the size of a host char is 8 bits, we can return a pointer
6158 to the string, otherwise we have to copy the string to a buffer
6159 allocated on the temporary obstack. */
6160 gdb_assert (HOST_CHAR_BIT == 8);
6163 *bytes_read_ptr = 1;
6166 *bytes_read_ptr = strlen ((char *) buf) + 1;
6167 return (char *) buf;
6171 read_indirect_string (bfd *abfd, gdb_byte *buf,
6172 const struct comp_unit_head *cu_header,
6173 unsigned int *bytes_read_ptr)
6175 LONGEST str_offset = read_offset (abfd, buf, cu_header,
6178 if (dwarf2_per_objfile->str_buffer == NULL)
6180 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6181 bfd_get_filename (abfd));
6184 if (str_offset >= dwarf2_per_objfile->str_size)
6186 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6187 bfd_get_filename (abfd));
6190 gdb_assert (HOST_CHAR_BIT == 8);
6191 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6193 return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6196 static unsigned long
6197 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6199 unsigned long result;
6200 unsigned int num_read;
6210 byte = bfd_get_8 (abfd, buf);
6213 result |= ((unsigned long)(byte & 127) << shift);
6214 if ((byte & 128) == 0)
6220 *bytes_read_ptr = num_read;
6225 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6228 int i, shift, num_read;
6237 byte = bfd_get_8 (abfd, buf);
6240 result |= ((long)(byte & 127) << shift);
6242 if ((byte & 128) == 0)
6247 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6248 result |= -(((long)1) << shift);
6249 *bytes_read_ptr = num_read;
6253 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6256 skip_leb128 (bfd *abfd, gdb_byte *buf)
6262 byte = bfd_get_8 (abfd, buf);
6264 if ((byte & 128) == 0)
6270 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6276 cu->language = language_c;
6278 case DW_LANG_C_plus_plus:
6279 cu->language = language_cplus;
6281 case DW_LANG_Fortran77:
6282 case DW_LANG_Fortran90:
6283 case DW_LANG_Fortran95:
6284 cu->language = language_fortran;
6286 case DW_LANG_Mips_Assembler:
6287 cu->language = language_asm;
6290 cu->language = language_java;
6294 cu->language = language_ada;
6296 case DW_LANG_Cobol74:
6297 case DW_LANG_Cobol85:
6298 case DW_LANG_Pascal83:
6299 case DW_LANG_Modula2:
6301 cu->language = language_minimal;
6304 cu->language_defn = language_def (cu->language);
6307 /* Return the named attribute or NULL if not there. */
6309 static struct attribute *
6310 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6313 struct attribute *spec = NULL;
6315 for (i = 0; i < die->num_attrs; ++i)
6317 if (die->attrs[i].name == name)
6318 return &die->attrs[i];
6319 if (die->attrs[i].name == DW_AT_specification
6320 || die->attrs[i].name == DW_AT_abstract_origin)
6321 spec = &die->attrs[i];
6325 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6330 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6331 and holds a non-zero value. This function should only be used for
6332 DW_FORM_flag attributes. */
6335 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6337 struct attribute *attr = dwarf2_attr (die, name, cu);
6339 return (attr && DW_UNSND (attr));
6343 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6345 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6346 which value is non-zero. However, we have to be careful with
6347 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6348 (via dwarf2_flag_true_p) follows this attribute. So we may
6349 end up accidently finding a declaration attribute that belongs
6350 to a different DIE referenced by the specification attribute,
6351 even though the given DIE does not have a declaration attribute. */
6352 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6353 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6356 /* Return the die giving the specification for DIE, if there is
6359 static struct die_info *
6360 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6362 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6364 if (spec_attr == NULL)
6367 return follow_die_ref (die, spec_attr, cu);
6370 /* Free the line_header structure *LH, and any arrays and strings it
6373 free_line_header (struct line_header *lh)
6375 if (lh->standard_opcode_lengths)
6376 xfree (lh->standard_opcode_lengths);
6378 /* Remember that all the lh->file_names[i].name pointers are
6379 pointers into debug_line_buffer, and don't need to be freed. */
6381 xfree (lh->file_names);
6383 /* Similarly for the include directory names. */
6384 if (lh->include_dirs)
6385 xfree (lh->include_dirs);
6391 /* Add an entry to LH's include directory table. */
6393 add_include_dir (struct line_header *lh, char *include_dir)
6395 /* Grow the array if necessary. */
6396 if (lh->include_dirs_size == 0)
6398 lh->include_dirs_size = 1; /* for testing */
6399 lh->include_dirs = xmalloc (lh->include_dirs_size
6400 * sizeof (*lh->include_dirs));
6402 else if (lh->num_include_dirs >= lh->include_dirs_size)
6404 lh->include_dirs_size *= 2;
6405 lh->include_dirs = xrealloc (lh->include_dirs,
6406 (lh->include_dirs_size
6407 * sizeof (*lh->include_dirs)));
6410 lh->include_dirs[lh->num_include_dirs++] = include_dir;
6414 /* Add an entry to LH's file name table. */
6416 add_file_name (struct line_header *lh,
6418 unsigned int dir_index,
6419 unsigned int mod_time,
6420 unsigned int length)
6422 struct file_entry *fe;
6424 /* Grow the array if necessary. */
6425 if (lh->file_names_size == 0)
6427 lh->file_names_size = 1; /* for testing */
6428 lh->file_names = xmalloc (lh->file_names_size
6429 * sizeof (*lh->file_names));
6431 else if (lh->num_file_names >= lh->file_names_size)
6433 lh->file_names_size *= 2;
6434 lh->file_names = xrealloc (lh->file_names,
6435 (lh->file_names_size
6436 * sizeof (*lh->file_names)));
6439 fe = &lh->file_names[lh->num_file_names++];
6441 fe->dir_index = dir_index;
6442 fe->mod_time = mod_time;
6443 fe->length = length;
6448 /* Read the statement program header starting at OFFSET in
6449 .debug_line, according to the endianness of ABFD. Return a pointer
6450 to a struct line_header, allocated using xmalloc.
6452 NOTE: the strings in the include directory and file name tables of
6453 the returned object point into debug_line_buffer, and must not be
6455 static struct line_header *
6456 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6457 struct dwarf2_cu *cu)
6459 struct cleanup *back_to;
6460 struct line_header *lh;
6462 unsigned int bytes_read;
6464 char *cur_dir, *cur_file;
6466 if (dwarf2_per_objfile->line_buffer == NULL)
6468 complaint (&symfile_complaints, _("missing .debug_line section"));
6472 /* Make sure that at least there's room for the total_length field.
6473 That could be 12 bytes long, but we're just going to fudge that. */
6474 if (offset + 4 >= dwarf2_per_objfile->line_size)
6476 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6480 lh = xmalloc (sizeof (*lh));
6481 memset (lh, 0, sizeof (*lh));
6482 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6485 line_ptr = dwarf2_per_objfile->line_buffer + offset;
6487 /* Read in the header. */
6489 read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6490 line_ptr += bytes_read;
6491 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6492 + dwarf2_per_objfile->line_size))
6494 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6497 lh->statement_program_end = line_ptr + lh->total_length;
6498 lh->version = read_2_bytes (abfd, line_ptr);
6500 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6501 line_ptr += bytes_read;
6502 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6504 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6506 lh->line_base = read_1_signed_byte (abfd, line_ptr);
6508 lh->line_range = read_1_byte (abfd, line_ptr);
6510 lh->opcode_base = read_1_byte (abfd, line_ptr);
6512 lh->standard_opcode_lengths
6513 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6515 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
6516 for (i = 1; i < lh->opcode_base; ++i)
6518 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6522 /* Read directory table. */
6523 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6525 line_ptr += bytes_read;
6526 add_include_dir (lh, cur_dir);
6528 line_ptr += bytes_read;
6530 /* Read file name table. */
6531 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6533 unsigned int dir_index, mod_time, length;
6535 line_ptr += bytes_read;
6536 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6537 line_ptr += bytes_read;
6538 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6539 line_ptr += bytes_read;
6540 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6541 line_ptr += bytes_read;
6543 add_file_name (lh, cur_file, dir_index, mod_time, length);
6545 line_ptr += bytes_read;
6546 lh->statement_program_start = line_ptr;
6548 if (line_ptr > (dwarf2_per_objfile->line_buffer
6549 + dwarf2_per_objfile->line_size))
6550 complaint (&symfile_complaints,
6551 _("line number info header doesn't fit in `.debug_line' section"));
6553 discard_cleanups (back_to);
6557 /* This function exists to work around a bug in certain compilers
6558 (particularly GCC 2.95), in which the first line number marker of a
6559 function does not show up until after the prologue, right before
6560 the second line number marker. This function shifts ADDRESS down
6561 to the beginning of the function if necessary, and is called on
6562 addresses passed to record_line. */
6565 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6567 struct function_range *fn;
6569 /* Find the function_range containing address. */
6574 cu->cached_fn = cu->first_fn;
6578 if (fn->lowpc <= address && fn->highpc > address)
6584 while (fn && fn != cu->cached_fn)
6585 if (fn->lowpc <= address && fn->highpc > address)
6595 if (address != fn->lowpc)
6596 complaint (&symfile_complaints,
6597 _("misplaced first line number at 0x%lx for '%s'"),
6598 (unsigned long) address, fn->name);
6603 /* Decode the Line Number Program (LNP) for the given line_header
6604 structure and CU. The actual information extracted and the type
6605 of structures created from the LNP depends on the value of PST.
6607 1. If PST is NULL, then this procedure uses the data from the program
6608 to create all necessary symbol tables, and their linetables.
6609 The compilation directory of the file is passed in COMP_DIR,
6610 and must not be NULL.
6612 2. If PST is not NULL, this procedure reads the program to determine
6613 the list of files included by the unit represented by PST, and
6614 builds all the associated partial symbol tables. In this case,
6615 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6616 is not used to compute the full name of the symtab, and therefore
6617 omitting it when building the partial symtab does not introduce
6618 the potential for inconsistency - a partial symtab and its associated
6619 symbtab having a different fullname -). */
6622 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6623 struct dwarf2_cu *cu, struct partial_symtab *pst)
6627 unsigned int bytes_read;
6628 unsigned char op_code, extended_op, adj_opcode;
6630 struct objfile *objfile = cu->objfile;
6631 const int decode_for_pst_p = (pst != NULL);
6633 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6635 line_ptr = lh->statement_program_start;
6636 line_end = lh->statement_program_end;
6638 /* Read the statement sequences until there's nothing left. */
6639 while (line_ptr < line_end)
6641 /* state machine registers */
6642 CORE_ADDR address = 0;
6643 unsigned int file = 1;
6644 unsigned int line = 1;
6645 unsigned int column = 0;
6646 int is_stmt = lh->default_is_stmt;
6647 int basic_block = 0;
6648 int end_sequence = 0;
6650 if (!decode_for_pst_p && lh->num_file_names >= file)
6652 /* Start a subfile for the current file of the state machine. */
6653 /* lh->include_dirs and lh->file_names are 0-based, but the
6654 directory and file name numbers in the statement program
6656 struct file_entry *fe = &lh->file_names[file - 1];
6660 dir = lh->include_dirs[fe->dir_index - 1];
6661 else if (!IS_ABSOLUTE_PATH (fe->name))
6666 dwarf2_start_subfile (fe->name, dir);
6669 /* Decode the table. */
6670 while (!end_sequence)
6672 op_code = read_1_byte (abfd, line_ptr);
6675 if (op_code >= lh->opcode_base)
6677 /* Special operand. */
6678 adj_opcode = op_code - lh->opcode_base;
6679 address += (adj_opcode / lh->line_range)
6680 * lh->minimum_instruction_length;
6681 line += lh->line_base + (adj_opcode % lh->line_range);
6682 lh->file_names[file - 1].included_p = 1;
6683 if (!decode_for_pst_p)
6685 /* Append row to matrix using current values. */
6686 record_line (current_subfile, line,
6687 check_cu_functions (address, cu));
6691 else switch (op_code)
6693 case DW_LNS_extended_op:
6694 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6695 line_ptr += bytes_read;
6696 extended_op = read_1_byte (abfd, line_ptr);
6698 switch (extended_op)
6700 case DW_LNE_end_sequence:
6702 lh->file_names[file - 1].included_p = 1;
6703 if (!decode_for_pst_p)
6704 record_line (current_subfile, 0, address);
6706 case DW_LNE_set_address:
6707 address = read_address (abfd, line_ptr, cu, &bytes_read);
6708 line_ptr += bytes_read;
6709 address += baseaddr;
6711 case DW_LNE_define_file:
6714 unsigned int dir_index, mod_time, length;
6716 cur_file = read_string (abfd, line_ptr, &bytes_read);
6717 line_ptr += bytes_read;
6719 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6720 line_ptr += bytes_read;
6722 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6723 line_ptr += bytes_read;
6725 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6726 line_ptr += bytes_read;
6727 add_file_name (lh, cur_file, dir_index, mod_time, length);
6731 complaint (&symfile_complaints,
6732 _("mangled .debug_line section"));
6737 lh->file_names[file - 1].included_p = 1;
6738 if (!decode_for_pst_p)
6739 record_line (current_subfile, line,
6740 check_cu_functions (address, cu));
6743 case DW_LNS_advance_pc:
6744 address += lh->minimum_instruction_length
6745 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6746 line_ptr += bytes_read;
6748 case DW_LNS_advance_line:
6749 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6750 line_ptr += bytes_read;
6752 case DW_LNS_set_file:
6754 /* The arrays lh->include_dirs and lh->file_names are
6755 0-based, but the directory and file name numbers in
6756 the statement program are 1-based. */
6757 struct file_entry *fe;
6760 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6761 line_ptr += bytes_read;
6762 fe = &lh->file_names[file - 1];
6764 dir = lh->include_dirs[fe->dir_index - 1];
6765 else if (!IS_ABSOLUTE_PATH (fe->name))
6769 if (!decode_for_pst_p)
6770 dwarf2_start_subfile (fe->name, dir);
6773 case DW_LNS_set_column:
6774 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6775 line_ptr += bytes_read;
6777 case DW_LNS_negate_stmt:
6778 is_stmt = (!is_stmt);
6780 case DW_LNS_set_basic_block:
6783 /* Add to the address register of the state machine the
6784 address increment value corresponding to special opcode
6785 255. I.e., this value is scaled by the minimum
6786 instruction length since special opcode 255 would have
6787 scaled the the increment. */
6788 case DW_LNS_const_add_pc:
6789 address += (lh->minimum_instruction_length
6790 * ((255 - lh->opcode_base) / lh->line_range));
6792 case DW_LNS_fixed_advance_pc:
6793 address += read_2_bytes (abfd, line_ptr);
6798 /* Unknown standard opcode, ignore it. */
6801 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6803 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6804 line_ptr += bytes_read;
6811 if (decode_for_pst_p)
6815 /* Now that we're done scanning the Line Header Program, we can
6816 create the psymtab of each included file. */
6817 for (file_index = 0; file_index < lh->num_file_names; file_index++)
6818 if (lh->file_names[file_index].included_p == 1)
6820 const struct file_entry fe = lh->file_names [file_index];
6821 char *include_name = fe.name;
6822 char *dir_name = NULL;
6823 char *pst_filename = pst->filename;
6826 dir_name = lh->include_dirs[fe.dir_index - 1];
6828 if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
6830 include_name = concat (dir_name, SLASH_STRING,
6831 include_name, (char *)NULL);
6832 make_cleanup (xfree, include_name);
6835 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
6837 pst_filename = concat (pst->dirname, SLASH_STRING,
6838 pst_filename, (char *)NULL);
6839 make_cleanup (xfree, pst_filename);
6842 if (strcmp (include_name, pst_filename) != 0)
6843 dwarf2_create_include_psymtab (include_name, pst, objfile);
6848 /* Start a subfile for DWARF. FILENAME is the name of the file and
6849 DIRNAME the name of the source directory which contains FILENAME
6850 or NULL if not known.
6851 This routine tries to keep line numbers from identical absolute and
6852 relative file names in a common subfile.
6854 Using the `list' example from the GDB testsuite, which resides in
6855 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6856 of /srcdir/list0.c yields the following debugging information for list0.c:
6858 DW_AT_name: /srcdir/list0.c
6859 DW_AT_comp_dir: /compdir
6860 files.files[0].name: list0.h
6861 files.files[0].dir: /srcdir
6862 files.files[1].name: list0.c
6863 files.files[1].dir: /srcdir
6865 The line number information for list0.c has to end up in a single
6866 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6869 dwarf2_start_subfile (char *filename, char *dirname)
6871 /* If the filename is absolute and no directory is known then
6872 split into a directory and relative path. */
6873 if (dirname == NULL && IS_ABSOLUTE_PATH (filename))
6875 char *new_name = (char *) lbasename (filename);
6876 dirname = alloca (new_name - filename);
6877 memcpy (dirname, filename, new_name - filename - 1);
6878 dirname[new_name - filename - 1] = '\0';
6879 filename = new_name;
6882 /* If the filename isn't absolute, try to match an existing subfile
6883 with the full pathname. */
6885 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6887 struct subfile *subfile;
6890 if (dirname[strlen (dirname) - 1] == '/')
6891 fullname = concat (dirname, filename, (char *)NULL);
6893 fullname = concat (dirname, "/", filename, (char *)NULL);
6895 for (subfile = subfiles; subfile; subfile = subfile->next)
6897 if (FILENAME_CMP (subfile->name, fullname) == 0)
6899 current_subfile = subfile;
6907 start_subfile (filename, dirname);
6911 var_decode_location (struct attribute *attr, struct symbol *sym,
6912 struct dwarf2_cu *cu)
6914 struct objfile *objfile = cu->objfile;
6915 struct comp_unit_head *cu_header = &cu->header;
6917 /* NOTE drow/2003-01-30: There used to be a comment and some special
6918 code here to turn a symbol with DW_AT_external and a
6919 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6920 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6921 with some versions of binutils) where shared libraries could have
6922 relocations against symbols in their debug information - the
6923 minimal symbol would have the right address, but the debug info
6924 would not. It's no longer necessary, because we will explicitly
6925 apply relocations when we read in the debug information now. */
6927 /* A DW_AT_location attribute with no contents indicates that a
6928 variable has been optimized away. */
6929 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6931 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6935 /* Handle one degenerate form of location expression specially, to
6936 preserve GDB's previous behavior when section offsets are
6937 specified. If this is just a DW_OP_addr then mark this symbol
6940 if (attr_form_is_block (attr)
6941 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6942 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6946 SYMBOL_VALUE_ADDRESS (sym) =
6947 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6948 fixup_symbol_section (sym, objfile);
6949 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6950 SYMBOL_SECTION (sym));
6951 SYMBOL_CLASS (sym) = LOC_STATIC;
6955 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6956 expression evaluator, and use LOC_COMPUTED only when necessary
6957 (i.e. when the value of a register or memory location is
6958 referenced, or a thread-local block, etc.). Then again, it might
6959 not be worthwhile. I'm assuming that it isn't unless performance
6960 or memory numbers show me otherwise. */
6962 dwarf2_symbol_mark_computed (attr, sym, cu);
6963 SYMBOL_CLASS (sym) = LOC_COMPUTED;
6966 /* Given a pointer to a DWARF information entry, figure out if we need
6967 to make a symbol table entry for it, and if so, create a new entry
6968 and return a pointer to it.
6969 If TYPE is NULL, determine symbol type from the die, otherwise
6970 used the passed type. */
6972 static struct symbol *
6973 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6975 struct objfile *objfile = cu->objfile;
6976 struct symbol *sym = NULL;
6978 struct attribute *attr = NULL;
6979 struct attribute *attr2 = NULL;
6982 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6984 if (die->tag != DW_TAG_namespace)
6985 name = dwarf2_linkage_name (die, cu);
6987 name = TYPE_NAME (type);
6991 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6992 sizeof (struct symbol));
6993 OBJSTAT (objfile, n_syms++);
6994 memset (sym, 0, sizeof (struct symbol));
6996 /* Cache this symbol's name and the name's demangled form (if any). */
6997 SYMBOL_LANGUAGE (sym) = cu->language;
6998 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
7000 /* Default assumptions.
7001 Use the passed type or decode it from the die. */
7002 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7003 SYMBOL_CLASS (sym) = LOC_STATIC;
7005 SYMBOL_TYPE (sym) = type;
7007 SYMBOL_TYPE (sym) = die_type (die, cu);
7008 attr = dwarf2_attr (die, DW_AT_decl_line, cu);
7011 SYMBOL_LINE (sym) = DW_UNSND (attr);
7016 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
7019 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
7021 SYMBOL_CLASS (sym) = LOC_LABEL;
7023 case DW_TAG_subprogram:
7024 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7026 SYMBOL_CLASS (sym) = LOC_BLOCK;
7027 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7028 if (attr2 && (DW_UNSND (attr2) != 0))
7030 add_symbol_to_list (sym, &global_symbols);
7034 add_symbol_to_list (sym, cu->list_in_scope);
7037 case DW_TAG_variable:
7038 /* Compilation with minimal debug info may result in variables
7039 with missing type entries. Change the misleading `void' type
7040 to something sensible. */
7041 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
7042 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
7043 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
7044 "<variable, no debug info>",
7046 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7049 dwarf2_const_value (attr, sym, cu);
7050 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7051 if (attr2 && (DW_UNSND (attr2) != 0))
7052 add_symbol_to_list (sym, &global_symbols);
7054 add_symbol_to_list (sym, cu->list_in_scope);
7057 attr = dwarf2_attr (die, DW_AT_location, cu);
7060 var_decode_location (attr, sym, cu);
7061 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7062 if (attr2 && (DW_UNSND (attr2) != 0))
7063 add_symbol_to_list (sym, &global_symbols);
7065 add_symbol_to_list (sym, cu->list_in_scope);
7069 /* We do not know the address of this symbol.
7070 If it is an external symbol and we have type information
7071 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7072 The address of the variable will then be determined from
7073 the minimal symbol table whenever the variable is
7075 attr2 = dwarf2_attr (die, DW_AT_external, cu);
7076 if (attr2 && (DW_UNSND (attr2) != 0)
7077 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
7079 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
7080 add_symbol_to_list (sym, &global_symbols);
7084 case DW_TAG_formal_parameter:
7085 SYMBOL_IS_ARGUMENT (sym) = 1;
7086 attr = dwarf2_attr (die, DW_AT_location, cu);
7089 var_decode_location (attr, sym, cu);
7090 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7091 if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
7092 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
7095 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7096 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7099 dwarf2_const_value (attr, sym, cu);
7101 add_symbol_to_list (sym, cu->list_in_scope);
7103 case DW_TAG_unspecified_parameters:
7104 /* From varargs functions; gdb doesn't seem to have any
7105 interest in this information, so just ignore it for now.
7108 case DW_TAG_class_type:
7109 case DW_TAG_structure_type:
7110 case DW_TAG_union_type:
7111 case DW_TAG_enumeration_type:
7112 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7113 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7115 /* Make sure that the symbol includes appropriate enclosing
7116 classes/namespaces in its name. These are calculated in
7117 read_structure_type, and the correct name is saved in
7120 if (cu->language == language_cplus
7121 || cu->language == language_java)
7123 struct type *type = SYMBOL_TYPE (sym);
7125 if (TYPE_TAG_NAME (type) != NULL)
7127 /* FIXME: carlton/2003-11-10: Should this use
7128 SYMBOL_SET_NAMES instead? (The same problem also
7129 arises further down in this function.) */
7130 /* The type's name is already allocated along with
7131 this objfile, so we don't need to duplicate it
7133 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
7138 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7139 really ever be static objects: otherwise, if you try
7140 to, say, break of a class's method and you're in a file
7141 which doesn't mention that class, it won't work unless
7142 the check for all static symbols in lookup_symbol_aux
7143 saves you. See the OtherFileClass tests in
7144 gdb.c++/namespace.exp. */
7146 struct pending **list_to_add;
7148 list_to_add = (cu->list_in_scope == &file_symbols
7149 && (cu->language == language_cplus
7150 || cu->language == language_java)
7151 ? &global_symbols : cu->list_in_scope);
7153 add_symbol_to_list (sym, list_to_add);
7155 /* The semantics of C++ state that "struct foo { ... }" also
7156 defines a typedef for "foo". A Java class declaration also
7157 defines a typedef for the class. Synthesize a typedef symbol
7158 so that "ptype foo" works as expected. */
7159 if (cu->language == language_cplus
7160 || cu->language == language_java)
7162 struct symbol *typedef_sym = (struct symbol *)
7163 obstack_alloc (&objfile->objfile_obstack,
7164 sizeof (struct symbol));
7165 *typedef_sym = *sym;
7166 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
7167 /* The symbol's name is already allocated along with
7168 this objfile, so we don't need to duplicate it for
7170 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
7171 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
7172 add_symbol_to_list (typedef_sym, list_to_add);
7176 case DW_TAG_typedef:
7177 if (processing_has_namespace_info
7178 && processing_current_prefix[0] != '\0')
7180 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7181 processing_current_prefix,
7184 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7185 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7186 add_symbol_to_list (sym, cu->list_in_scope);
7188 case DW_TAG_base_type:
7189 case DW_TAG_subrange_type:
7190 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7191 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7192 add_symbol_to_list (sym, cu->list_in_scope);
7194 case DW_TAG_enumerator:
7195 if (processing_has_namespace_info
7196 && processing_current_prefix[0] != '\0')
7198 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7199 processing_current_prefix,
7202 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7205 dwarf2_const_value (attr, sym, cu);
7208 /* NOTE: carlton/2003-11-10: See comment above in the
7209 DW_TAG_class_type, etc. block. */
7211 struct pending **list_to_add;
7213 list_to_add = (cu->list_in_scope == &file_symbols
7214 && (cu->language == language_cplus
7215 || cu->language == language_java)
7216 ? &global_symbols : cu->list_in_scope);
7218 add_symbol_to_list (sym, list_to_add);
7221 case DW_TAG_namespace:
7222 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7223 add_symbol_to_list (sym, &global_symbols);
7226 /* Not a tag we recognize. Hopefully we aren't processing
7227 trash data, but since we must specifically ignore things
7228 we don't recognize, there is nothing else we should do at
7230 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7231 dwarf_tag_name (die->tag));
7238 /* Copy constant value from an attribute to a symbol. */
7241 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7242 struct dwarf2_cu *cu)
7244 struct objfile *objfile = cu->objfile;
7245 struct comp_unit_head *cu_header = &cu->header;
7246 struct dwarf_block *blk;
7251 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7252 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7253 cu_header->addr_size,
7254 TYPE_LENGTH (SYMBOL_TYPE
7256 SYMBOL_VALUE_BYTES (sym) =
7257 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7258 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7259 it's body - store_unsigned_integer. */
7260 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7262 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7264 case DW_FORM_block1:
7265 case DW_FORM_block2:
7266 case DW_FORM_block4:
7268 blk = DW_BLOCK (attr);
7269 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7270 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7272 TYPE_LENGTH (SYMBOL_TYPE
7274 SYMBOL_VALUE_BYTES (sym) =
7275 obstack_alloc (&objfile->objfile_obstack, blk->size);
7276 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7277 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7280 /* The DW_AT_const_value attributes are supposed to carry the
7281 symbol's value "represented as it would be on the target
7282 architecture." By the time we get here, it's already been
7283 converted to host endianness, so we just need to sign- or
7284 zero-extend it as appropriate. */
7286 dwarf2_const_value_data (attr, sym, 8);
7289 dwarf2_const_value_data (attr, sym, 16);
7292 dwarf2_const_value_data (attr, sym, 32);
7295 dwarf2_const_value_data (attr, sym, 64);
7299 SYMBOL_VALUE (sym) = DW_SND (attr);
7300 SYMBOL_CLASS (sym) = LOC_CONST;
7304 SYMBOL_VALUE (sym) = DW_UNSND (attr);
7305 SYMBOL_CLASS (sym) = LOC_CONST;
7309 complaint (&symfile_complaints,
7310 _("unsupported const value attribute form: '%s'"),
7311 dwarf_form_name (attr->form));
7312 SYMBOL_VALUE (sym) = 0;
7313 SYMBOL_CLASS (sym) = LOC_CONST;
7319 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7320 or zero-extend it as appropriate for the symbol's type. */
7322 dwarf2_const_value_data (struct attribute *attr,
7326 LONGEST l = DW_UNSND (attr);
7328 if (bits < sizeof (l) * 8)
7330 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7331 l &= ((LONGEST) 1 << bits) - 1;
7333 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7336 SYMBOL_VALUE (sym) = l;
7337 SYMBOL_CLASS (sym) = LOC_CONST;
7341 /* Return the type of the die in question using its DW_AT_type attribute. */
7343 static struct type *
7344 die_type (struct die_info *die, struct dwarf2_cu *cu)
7347 struct attribute *type_attr;
7348 struct die_info *type_die;
7350 type_attr = dwarf2_attr (die, DW_AT_type, cu);
7353 /* A missing DW_AT_type represents a void type. */
7354 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
7357 type_die = follow_die_ref (die, type_attr, cu);
7359 type = tag_type_to_type (type_die, cu);
7362 dump_die (type_die);
7363 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7369 /* Return the containing type of the die in question using its
7370 DW_AT_containing_type attribute. */
7372 static struct type *
7373 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7375 struct type *type = NULL;
7376 struct attribute *type_attr;
7377 struct die_info *type_die = NULL;
7379 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7382 type_die = follow_die_ref (die, type_attr, cu);
7383 type = tag_type_to_type (type_die, cu);
7388 dump_die (type_die);
7389 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7395 static struct type *
7396 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7404 read_type_die (die, cu);
7408 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7416 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7418 char *prefix = determine_prefix (die, cu);
7419 const char *old_prefix = processing_current_prefix;
7420 struct cleanup *back_to = make_cleanup (xfree, prefix);
7421 processing_current_prefix = prefix;
7425 case DW_TAG_class_type:
7426 case DW_TAG_structure_type:
7427 case DW_TAG_union_type:
7428 read_structure_type (die, cu);
7430 case DW_TAG_enumeration_type:
7431 read_enumeration_type (die, cu);
7433 case DW_TAG_subprogram:
7434 case DW_TAG_subroutine_type:
7435 read_subroutine_type (die, cu);
7437 case DW_TAG_array_type:
7438 read_array_type (die, cu);
7440 case DW_TAG_pointer_type:
7441 read_tag_pointer_type (die, cu);
7443 case DW_TAG_ptr_to_member_type:
7444 read_tag_ptr_to_member_type (die, cu);
7446 case DW_TAG_reference_type:
7447 read_tag_reference_type (die, cu);
7449 case DW_TAG_const_type:
7450 read_tag_const_type (die, cu);
7452 case DW_TAG_volatile_type:
7453 read_tag_volatile_type (die, cu);
7455 case DW_TAG_string_type:
7456 read_tag_string_type (die, cu);
7458 case DW_TAG_typedef:
7459 read_typedef (die, cu);
7461 case DW_TAG_subrange_type:
7462 read_subrange_type (die, cu);
7464 case DW_TAG_base_type:
7465 read_base_type (die, cu);
7467 case DW_TAG_unspecified_type:
7468 read_unspecified_type (die, cu);
7471 complaint (&symfile_complaints, _("unexepected tag in read_type_die: '%s'"),
7472 dwarf_tag_name (die->tag));
7476 processing_current_prefix = old_prefix;
7477 do_cleanups (back_to);
7480 /* Return the name of the namespace/class that DIE is defined within,
7481 or "" if we can't tell. The caller should xfree the result. */
7483 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7484 therein) for an example of how to use this function to deal with
7485 DW_AT_specification. */
7488 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7490 struct die_info *parent;
7492 if (cu->language != language_cplus
7493 && cu->language != language_java)
7496 parent = die->parent;
7500 return xstrdup ("");
7504 switch (parent->tag) {
7505 case DW_TAG_namespace:
7507 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7508 before doing this check? */
7509 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7511 return xstrdup (TYPE_TAG_NAME (parent->type));
7516 char *parent_prefix = determine_prefix (parent, cu);
7517 char *retval = typename_concat (NULL, parent_prefix,
7518 namespace_name (parent, &dummy,
7521 xfree (parent_prefix);
7526 case DW_TAG_class_type:
7527 case DW_TAG_structure_type:
7529 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7531 return xstrdup (TYPE_TAG_NAME (parent->type));
7535 const char *old_prefix = processing_current_prefix;
7536 char *new_prefix = determine_prefix (parent, cu);
7539 processing_current_prefix = new_prefix;
7540 retval = determine_class_name (parent, cu);
7541 processing_current_prefix = old_prefix;
7548 return determine_prefix (parent, cu);
7553 /* Return a newly-allocated string formed by concatenating PREFIX and
7554 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7555 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7556 perform an obconcat, otherwise allocate storage for the result. The CU argument
7557 is used to determine the language and hence, the appropriate separator. */
7559 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7562 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7563 struct dwarf2_cu *cu)
7567 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7569 else if (cu->language == language_java)
7576 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7581 strcpy (retval, prefix);
7582 strcat (retval, sep);
7585 strcat (retval, suffix);
7591 /* We have an obstack. */
7592 return obconcat (obs, prefix, sep, suffix);
7596 static struct type *
7597 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
7599 struct objfile *objfile = cu->objfile;
7601 /* FIXME - this should not produce a new (struct type *)
7602 every time. It should cache base types. */
7606 case DW_ATE_address:
7607 type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
7609 case DW_ATE_boolean:
7610 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
7612 case DW_ATE_complex_float:
7615 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
7619 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
7625 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
7629 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
7636 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7639 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
7643 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7647 case DW_ATE_signed_char:
7648 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
7650 case DW_ATE_unsigned:
7654 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7657 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
7661 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
7665 case DW_ATE_unsigned_char:
7666 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
7669 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
7676 copy_die (struct die_info *old_die)
7678 struct die_info *new_die;
7681 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7682 memset (new_die, 0, sizeof (struct die_info));
7684 new_die->tag = old_die->tag;
7685 new_die->has_children = old_die->has_children;
7686 new_die->abbrev = old_die->abbrev;
7687 new_die->offset = old_die->offset;
7688 new_die->type = NULL;
7690 num_attrs = old_die->num_attrs;
7691 new_die->num_attrs = num_attrs;
7692 new_die->attrs = (struct attribute *)
7693 xmalloc (num_attrs * sizeof (struct attribute));
7695 for (i = 0; i < old_die->num_attrs; ++i)
7697 new_die->attrs[i].name = old_die->attrs[i].name;
7698 new_die->attrs[i].form = old_die->attrs[i].form;
7699 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7702 new_die->next = NULL;
7707 /* Return sibling of die, NULL if no sibling. */
7709 static struct die_info *
7710 sibling_die (struct die_info *die)
7712 return die->sibling;
7715 /* Get linkage name of a die, return NULL if not found. */
7718 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7720 struct attribute *attr;
7722 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7723 if (attr && DW_STRING (attr))
7724 return DW_STRING (attr);
7725 attr = dwarf2_attr (die, DW_AT_name, cu);
7726 if (attr && DW_STRING (attr))
7727 return DW_STRING (attr);
7731 /* Get name of a die, return NULL if not found. */
7734 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7736 struct attribute *attr;
7738 attr = dwarf2_attr (die, DW_AT_name, cu);
7739 if (attr && DW_STRING (attr))
7740 return DW_STRING (attr);
7744 /* Return the die that this die in an extension of, or NULL if there
7747 static struct die_info *
7748 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7750 struct attribute *attr;
7752 attr = dwarf2_attr (die, DW_AT_extension, cu);
7756 return follow_die_ref (die, attr, cu);
7759 /* Convert a DIE tag into its string name. */
7762 dwarf_tag_name (unsigned tag)
7766 case DW_TAG_padding:
7767 return "DW_TAG_padding";
7768 case DW_TAG_array_type:
7769 return "DW_TAG_array_type";
7770 case DW_TAG_class_type:
7771 return "DW_TAG_class_type";
7772 case DW_TAG_entry_point:
7773 return "DW_TAG_entry_point";
7774 case DW_TAG_enumeration_type:
7775 return "DW_TAG_enumeration_type";
7776 case DW_TAG_formal_parameter:
7777 return "DW_TAG_formal_parameter";
7778 case DW_TAG_imported_declaration:
7779 return "DW_TAG_imported_declaration";
7781 return "DW_TAG_label";
7782 case DW_TAG_lexical_block:
7783 return "DW_TAG_lexical_block";
7785 return "DW_TAG_member";
7786 case DW_TAG_pointer_type:
7787 return "DW_TAG_pointer_type";
7788 case DW_TAG_reference_type:
7789 return "DW_TAG_reference_type";
7790 case DW_TAG_compile_unit:
7791 return "DW_TAG_compile_unit";
7792 case DW_TAG_string_type:
7793 return "DW_TAG_string_type";
7794 case DW_TAG_structure_type:
7795 return "DW_TAG_structure_type";
7796 case DW_TAG_subroutine_type:
7797 return "DW_TAG_subroutine_type";
7798 case DW_TAG_typedef:
7799 return "DW_TAG_typedef";
7800 case DW_TAG_union_type:
7801 return "DW_TAG_union_type";
7802 case DW_TAG_unspecified_parameters:
7803 return "DW_TAG_unspecified_parameters";
7804 case DW_TAG_variant:
7805 return "DW_TAG_variant";
7806 case DW_TAG_common_block:
7807 return "DW_TAG_common_block";
7808 case DW_TAG_common_inclusion:
7809 return "DW_TAG_common_inclusion";
7810 case DW_TAG_inheritance:
7811 return "DW_TAG_inheritance";
7812 case DW_TAG_inlined_subroutine:
7813 return "DW_TAG_inlined_subroutine";
7815 return "DW_TAG_module";
7816 case DW_TAG_ptr_to_member_type:
7817 return "DW_TAG_ptr_to_member_type";
7818 case DW_TAG_set_type:
7819 return "DW_TAG_set_type";
7820 case DW_TAG_subrange_type:
7821 return "DW_TAG_subrange_type";
7822 case DW_TAG_with_stmt:
7823 return "DW_TAG_with_stmt";
7824 case DW_TAG_access_declaration:
7825 return "DW_TAG_access_declaration";
7826 case DW_TAG_base_type:
7827 return "DW_TAG_base_type";
7828 case DW_TAG_catch_block:
7829 return "DW_TAG_catch_block";
7830 case DW_TAG_const_type:
7831 return "DW_TAG_const_type";
7832 case DW_TAG_constant:
7833 return "DW_TAG_constant";
7834 case DW_TAG_enumerator:
7835 return "DW_TAG_enumerator";
7836 case DW_TAG_file_type:
7837 return "DW_TAG_file_type";
7839 return "DW_TAG_friend";
7840 case DW_TAG_namelist:
7841 return "DW_TAG_namelist";
7842 case DW_TAG_namelist_item:
7843 return "DW_TAG_namelist_item";
7844 case DW_TAG_packed_type:
7845 return "DW_TAG_packed_type";
7846 case DW_TAG_subprogram:
7847 return "DW_TAG_subprogram";
7848 case DW_TAG_template_type_param:
7849 return "DW_TAG_template_type_param";
7850 case DW_TAG_template_value_param:
7851 return "DW_TAG_template_value_param";
7852 case DW_TAG_thrown_type:
7853 return "DW_TAG_thrown_type";
7854 case DW_TAG_try_block:
7855 return "DW_TAG_try_block";
7856 case DW_TAG_variant_part:
7857 return "DW_TAG_variant_part";
7858 case DW_TAG_variable:
7859 return "DW_TAG_variable";
7860 case DW_TAG_volatile_type:
7861 return "DW_TAG_volatile_type";
7862 case DW_TAG_dwarf_procedure:
7863 return "DW_TAG_dwarf_procedure";
7864 case DW_TAG_restrict_type:
7865 return "DW_TAG_restrict_type";
7866 case DW_TAG_interface_type:
7867 return "DW_TAG_interface_type";
7868 case DW_TAG_namespace:
7869 return "DW_TAG_namespace";
7870 case DW_TAG_imported_module:
7871 return "DW_TAG_imported_module";
7872 case DW_TAG_unspecified_type:
7873 return "DW_TAG_unspecified_type";
7874 case DW_TAG_partial_unit:
7875 return "DW_TAG_partial_unit";
7876 case DW_TAG_imported_unit:
7877 return "DW_TAG_imported_unit";
7878 case DW_TAG_MIPS_loop:
7879 return "DW_TAG_MIPS_loop";
7880 case DW_TAG_format_label:
7881 return "DW_TAG_format_label";
7882 case DW_TAG_function_template:
7883 return "DW_TAG_function_template";
7884 case DW_TAG_class_template:
7885 return "DW_TAG_class_template";
7887 return "DW_TAG_<unknown>";
7891 /* Convert a DWARF attribute code into its string name. */
7894 dwarf_attr_name (unsigned attr)
7899 return "DW_AT_sibling";
7900 case DW_AT_location:
7901 return "DW_AT_location";
7903 return "DW_AT_name";
7904 case DW_AT_ordering:
7905 return "DW_AT_ordering";
7906 case DW_AT_subscr_data:
7907 return "DW_AT_subscr_data";
7908 case DW_AT_byte_size:
7909 return "DW_AT_byte_size";
7910 case DW_AT_bit_offset:
7911 return "DW_AT_bit_offset";
7912 case DW_AT_bit_size:
7913 return "DW_AT_bit_size";
7914 case DW_AT_element_list:
7915 return "DW_AT_element_list";
7916 case DW_AT_stmt_list:
7917 return "DW_AT_stmt_list";
7919 return "DW_AT_low_pc";
7921 return "DW_AT_high_pc";
7922 case DW_AT_language:
7923 return "DW_AT_language";
7925 return "DW_AT_member";
7927 return "DW_AT_discr";
7928 case DW_AT_discr_value:
7929 return "DW_AT_discr_value";
7930 case DW_AT_visibility:
7931 return "DW_AT_visibility";
7933 return "DW_AT_import";
7934 case DW_AT_string_length:
7935 return "DW_AT_string_length";
7936 case DW_AT_common_reference:
7937 return "DW_AT_common_reference";
7938 case DW_AT_comp_dir:
7939 return "DW_AT_comp_dir";
7940 case DW_AT_const_value:
7941 return "DW_AT_const_value";
7942 case DW_AT_containing_type:
7943 return "DW_AT_containing_type";
7944 case DW_AT_default_value:
7945 return "DW_AT_default_value";
7947 return "DW_AT_inline";
7948 case DW_AT_is_optional:
7949 return "DW_AT_is_optional";
7950 case DW_AT_lower_bound:
7951 return "DW_AT_lower_bound";
7952 case DW_AT_producer:
7953 return "DW_AT_producer";
7954 case DW_AT_prototyped:
7955 return "DW_AT_prototyped";
7956 case DW_AT_return_addr:
7957 return "DW_AT_return_addr";
7958 case DW_AT_start_scope:
7959 return "DW_AT_start_scope";
7960 case DW_AT_stride_size:
7961 return "DW_AT_stride_size";
7962 case DW_AT_upper_bound:
7963 return "DW_AT_upper_bound";
7964 case DW_AT_abstract_origin:
7965 return "DW_AT_abstract_origin";
7966 case DW_AT_accessibility:
7967 return "DW_AT_accessibility";
7968 case DW_AT_address_class:
7969 return "DW_AT_address_class";
7970 case DW_AT_artificial:
7971 return "DW_AT_artificial";
7972 case DW_AT_base_types:
7973 return "DW_AT_base_types";
7974 case DW_AT_calling_convention:
7975 return "DW_AT_calling_convention";
7977 return "DW_AT_count";
7978 case DW_AT_data_member_location:
7979 return "DW_AT_data_member_location";
7980 case DW_AT_decl_column:
7981 return "DW_AT_decl_column";
7982 case DW_AT_decl_file:
7983 return "DW_AT_decl_file";
7984 case DW_AT_decl_line:
7985 return "DW_AT_decl_line";
7986 case DW_AT_declaration:
7987 return "DW_AT_declaration";
7988 case DW_AT_discr_list:
7989 return "DW_AT_discr_list";
7990 case DW_AT_encoding:
7991 return "DW_AT_encoding";
7992 case DW_AT_external:
7993 return "DW_AT_external";
7994 case DW_AT_frame_base:
7995 return "DW_AT_frame_base";
7997 return "DW_AT_friend";
7998 case DW_AT_identifier_case:
7999 return "DW_AT_identifier_case";
8000 case DW_AT_macro_info:
8001 return "DW_AT_macro_info";
8002 case DW_AT_namelist_items:
8003 return "DW_AT_namelist_items";
8004 case DW_AT_priority:
8005 return "DW_AT_priority";
8007 return "DW_AT_segment";
8008 case DW_AT_specification:
8009 return "DW_AT_specification";
8010 case DW_AT_static_link:
8011 return "DW_AT_static_link";
8013 return "DW_AT_type";
8014 case DW_AT_use_location:
8015 return "DW_AT_use_location";
8016 case DW_AT_variable_parameter:
8017 return "DW_AT_variable_parameter";
8018 case DW_AT_virtuality:
8019 return "DW_AT_virtuality";
8020 case DW_AT_vtable_elem_location:
8021 return "DW_AT_vtable_elem_location";
8022 case DW_AT_allocated:
8023 return "DW_AT_allocated";
8024 case DW_AT_associated:
8025 return "DW_AT_associated";
8026 case DW_AT_data_location:
8027 return "DW_AT_data_location";
8029 return "DW_AT_stride";
8030 case DW_AT_entry_pc:
8031 return "DW_AT_entry_pc";
8032 case DW_AT_use_UTF8:
8033 return "DW_AT_use_UTF8";
8034 case DW_AT_extension:
8035 return "DW_AT_extension";
8037 return "DW_AT_ranges";
8038 case DW_AT_trampoline:
8039 return "DW_AT_trampoline";
8040 case DW_AT_call_column:
8041 return "DW_AT_call_column";
8042 case DW_AT_call_file:
8043 return "DW_AT_call_file";
8044 case DW_AT_call_line:
8045 return "DW_AT_call_line";
8047 case DW_AT_MIPS_fde:
8048 return "DW_AT_MIPS_fde";
8049 case DW_AT_MIPS_loop_begin:
8050 return "DW_AT_MIPS_loop_begin";
8051 case DW_AT_MIPS_tail_loop_begin:
8052 return "DW_AT_MIPS_tail_loop_begin";
8053 case DW_AT_MIPS_epilog_begin:
8054 return "DW_AT_MIPS_epilog_begin";
8055 case DW_AT_MIPS_loop_unroll_factor:
8056 return "DW_AT_MIPS_loop_unroll_factor";
8057 case DW_AT_MIPS_software_pipeline_depth:
8058 return "DW_AT_MIPS_software_pipeline_depth";
8060 case DW_AT_MIPS_linkage_name:
8061 return "DW_AT_MIPS_linkage_name";
8063 case DW_AT_sf_names:
8064 return "DW_AT_sf_names";
8065 case DW_AT_src_info:
8066 return "DW_AT_src_info";
8067 case DW_AT_mac_info:
8068 return "DW_AT_mac_info";
8069 case DW_AT_src_coords:
8070 return "DW_AT_src_coords";
8071 case DW_AT_body_begin:
8072 return "DW_AT_body_begin";
8073 case DW_AT_body_end:
8074 return "DW_AT_body_end";
8075 case DW_AT_GNU_vector:
8076 return "DW_AT_GNU_vector";
8078 return "DW_AT_<unknown>";
8082 /* Convert a DWARF value form code into its string name. */
8085 dwarf_form_name (unsigned form)
8090 return "DW_FORM_addr";
8091 case DW_FORM_block2:
8092 return "DW_FORM_block2";
8093 case DW_FORM_block4:
8094 return "DW_FORM_block4";
8096 return "DW_FORM_data2";
8098 return "DW_FORM_data4";
8100 return "DW_FORM_data8";
8101 case DW_FORM_string:
8102 return "DW_FORM_string";
8104 return "DW_FORM_block";
8105 case DW_FORM_block1:
8106 return "DW_FORM_block1";
8108 return "DW_FORM_data1";
8110 return "DW_FORM_flag";
8112 return "DW_FORM_sdata";
8114 return "DW_FORM_strp";
8116 return "DW_FORM_udata";
8117 case DW_FORM_ref_addr:
8118 return "DW_FORM_ref_addr";
8120 return "DW_FORM_ref1";
8122 return "DW_FORM_ref2";
8124 return "DW_FORM_ref4";
8126 return "DW_FORM_ref8";
8127 case DW_FORM_ref_udata:
8128 return "DW_FORM_ref_udata";
8129 case DW_FORM_indirect:
8130 return "DW_FORM_indirect";
8132 return "DW_FORM_<unknown>";
8136 /* Convert a DWARF stack opcode into its string name. */
8139 dwarf_stack_op_name (unsigned op)
8144 return "DW_OP_addr";
8146 return "DW_OP_deref";
8148 return "DW_OP_const1u";
8150 return "DW_OP_const1s";
8152 return "DW_OP_const2u";
8154 return "DW_OP_const2s";
8156 return "DW_OP_const4u";
8158 return "DW_OP_const4s";
8160 return "DW_OP_const8u";
8162 return "DW_OP_const8s";
8164 return "DW_OP_constu";
8166 return "DW_OP_consts";
8170 return "DW_OP_drop";
8172 return "DW_OP_over";
8174 return "DW_OP_pick";
8176 return "DW_OP_swap";
8180 return "DW_OP_xderef";
8188 return "DW_OP_minus";
8200 return "DW_OP_plus";
8201 case DW_OP_plus_uconst:
8202 return "DW_OP_plus_uconst";
8208 return "DW_OP_shra";
8226 return "DW_OP_skip";
8228 return "DW_OP_lit0";
8230 return "DW_OP_lit1";
8232 return "DW_OP_lit2";
8234 return "DW_OP_lit3";
8236 return "DW_OP_lit4";
8238 return "DW_OP_lit5";
8240 return "DW_OP_lit6";
8242 return "DW_OP_lit7";
8244 return "DW_OP_lit8";
8246 return "DW_OP_lit9";
8248 return "DW_OP_lit10";
8250 return "DW_OP_lit11";
8252 return "DW_OP_lit12";
8254 return "DW_OP_lit13";
8256 return "DW_OP_lit14";
8258 return "DW_OP_lit15";
8260 return "DW_OP_lit16";
8262 return "DW_OP_lit17";
8264 return "DW_OP_lit18";
8266 return "DW_OP_lit19";
8268 return "DW_OP_lit20";
8270 return "DW_OP_lit21";
8272 return "DW_OP_lit22";
8274 return "DW_OP_lit23";
8276 return "DW_OP_lit24";
8278 return "DW_OP_lit25";
8280 return "DW_OP_lit26";
8282 return "DW_OP_lit27";
8284 return "DW_OP_lit28";
8286 return "DW_OP_lit29";
8288 return "DW_OP_lit30";
8290 return "DW_OP_lit31";
8292 return "DW_OP_reg0";
8294 return "DW_OP_reg1";
8296 return "DW_OP_reg2";
8298 return "DW_OP_reg3";
8300 return "DW_OP_reg4";
8302 return "DW_OP_reg5";
8304 return "DW_OP_reg6";
8306 return "DW_OP_reg7";
8308 return "DW_OP_reg8";
8310 return "DW_OP_reg9";
8312 return "DW_OP_reg10";
8314 return "DW_OP_reg11";
8316 return "DW_OP_reg12";
8318 return "DW_OP_reg13";
8320 return "DW_OP_reg14";
8322 return "DW_OP_reg15";
8324 return "DW_OP_reg16";
8326 return "DW_OP_reg17";
8328 return "DW_OP_reg18";
8330 return "DW_OP_reg19";
8332 return "DW_OP_reg20";
8334 return "DW_OP_reg21";
8336 return "DW_OP_reg22";
8338 return "DW_OP_reg23";
8340 return "DW_OP_reg24";
8342 return "DW_OP_reg25";
8344 return "DW_OP_reg26";
8346 return "DW_OP_reg27";
8348 return "DW_OP_reg28";
8350 return "DW_OP_reg29";
8352 return "DW_OP_reg30";
8354 return "DW_OP_reg31";
8356 return "DW_OP_breg0";
8358 return "DW_OP_breg1";
8360 return "DW_OP_breg2";
8362 return "DW_OP_breg3";
8364 return "DW_OP_breg4";
8366 return "DW_OP_breg5";
8368 return "DW_OP_breg6";
8370 return "DW_OP_breg7";
8372 return "DW_OP_breg8";
8374 return "DW_OP_breg9";
8376 return "DW_OP_breg10";
8378 return "DW_OP_breg11";
8380 return "DW_OP_breg12";
8382 return "DW_OP_breg13";
8384 return "DW_OP_breg14";
8386 return "DW_OP_breg15";
8388 return "DW_OP_breg16";
8390 return "DW_OP_breg17";
8392 return "DW_OP_breg18";
8394 return "DW_OP_breg19";
8396 return "DW_OP_breg20";
8398 return "DW_OP_breg21";
8400 return "DW_OP_breg22";
8402 return "DW_OP_breg23";
8404 return "DW_OP_breg24";
8406 return "DW_OP_breg25";
8408 return "DW_OP_breg26";
8410 return "DW_OP_breg27";
8412 return "DW_OP_breg28";
8414 return "DW_OP_breg29";
8416 return "DW_OP_breg30";
8418 return "DW_OP_breg31";
8420 return "DW_OP_regx";
8422 return "DW_OP_fbreg";
8424 return "DW_OP_bregx";
8426 return "DW_OP_piece";
8427 case DW_OP_deref_size:
8428 return "DW_OP_deref_size";
8429 case DW_OP_xderef_size:
8430 return "DW_OP_xderef_size";
8433 /* DWARF 3 extensions. */
8434 case DW_OP_push_object_address:
8435 return "DW_OP_push_object_address";
8437 return "DW_OP_call2";
8439 return "DW_OP_call4";
8440 case DW_OP_call_ref:
8441 return "DW_OP_call_ref";
8442 /* GNU extensions. */
8443 case DW_OP_GNU_push_tls_address:
8444 return "DW_OP_GNU_push_tls_address";
8446 return "OP_<unknown>";
8451 dwarf_bool_name (unsigned mybool)
8459 /* Convert a DWARF type code into its string name. */
8462 dwarf_type_encoding_name (unsigned enc)
8466 case DW_ATE_address:
8467 return "DW_ATE_address";
8468 case DW_ATE_boolean:
8469 return "DW_ATE_boolean";
8470 case DW_ATE_complex_float:
8471 return "DW_ATE_complex_float";
8473 return "DW_ATE_float";
8475 return "DW_ATE_signed";
8476 case DW_ATE_signed_char:
8477 return "DW_ATE_signed_char";
8478 case DW_ATE_unsigned:
8479 return "DW_ATE_unsigned";
8480 case DW_ATE_unsigned_char:
8481 return "DW_ATE_unsigned_char";
8482 case DW_ATE_imaginary_float:
8483 return "DW_ATE_imaginary_float";
8485 return "DW_ATE_<unknown>";
8489 /* Convert a DWARF call frame info operation to its string name. */
8493 dwarf_cfi_name (unsigned cfi_opc)
8497 case DW_CFA_advance_loc:
8498 return "DW_CFA_advance_loc";
8500 return "DW_CFA_offset";
8501 case DW_CFA_restore:
8502 return "DW_CFA_restore";
8504 return "DW_CFA_nop";
8505 case DW_CFA_set_loc:
8506 return "DW_CFA_set_loc";
8507 case DW_CFA_advance_loc1:
8508 return "DW_CFA_advance_loc1";
8509 case DW_CFA_advance_loc2:
8510 return "DW_CFA_advance_loc2";
8511 case DW_CFA_advance_loc4:
8512 return "DW_CFA_advance_loc4";
8513 case DW_CFA_offset_extended:
8514 return "DW_CFA_offset_extended";
8515 case DW_CFA_restore_extended:
8516 return "DW_CFA_restore_extended";
8517 case DW_CFA_undefined:
8518 return "DW_CFA_undefined";
8519 case DW_CFA_same_value:
8520 return "DW_CFA_same_value";
8521 case DW_CFA_register:
8522 return "DW_CFA_register";
8523 case DW_CFA_remember_state:
8524 return "DW_CFA_remember_state";
8525 case DW_CFA_restore_state:
8526 return "DW_CFA_restore_state";
8527 case DW_CFA_def_cfa:
8528 return "DW_CFA_def_cfa";
8529 case DW_CFA_def_cfa_register:
8530 return "DW_CFA_def_cfa_register";
8531 case DW_CFA_def_cfa_offset:
8532 return "DW_CFA_def_cfa_offset";
8535 case DW_CFA_def_cfa_expression:
8536 return "DW_CFA_def_cfa_expression";
8537 case DW_CFA_expression:
8538 return "DW_CFA_expression";
8539 case DW_CFA_offset_extended_sf:
8540 return "DW_CFA_offset_extended_sf";
8541 case DW_CFA_def_cfa_sf:
8542 return "DW_CFA_def_cfa_sf";
8543 case DW_CFA_def_cfa_offset_sf:
8544 return "DW_CFA_def_cfa_offset_sf";
8546 /* SGI/MIPS specific */
8547 case DW_CFA_MIPS_advance_loc8:
8548 return "DW_CFA_MIPS_advance_loc8";
8550 /* GNU extensions */
8551 case DW_CFA_GNU_window_save:
8552 return "DW_CFA_GNU_window_save";
8553 case DW_CFA_GNU_args_size:
8554 return "DW_CFA_GNU_args_size";
8555 case DW_CFA_GNU_negative_offset_extended:
8556 return "DW_CFA_GNU_negative_offset_extended";
8559 return "DW_CFA_<unknown>";
8565 dump_die (struct die_info *die)
8569 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8570 dwarf_tag_name (die->tag), die->abbrev, die->offset);
8571 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8572 dwarf_bool_name (die->child != NULL));
8574 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8575 for (i = 0; i < die->num_attrs; ++i)
8577 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8578 dwarf_attr_name (die->attrs[i].name),
8579 dwarf_form_name (die->attrs[i].form));
8580 switch (die->attrs[i].form)
8582 case DW_FORM_ref_addr:
8584 fprintf_unfiltered (gdb_stderr, "address: ");
8585 deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
8587 case DW_FORM_block2:
8588 case DW_FORM_block4:
8590 case DW_FORM_block1:
8591 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8596 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8597 (long) (DW_ADDR (&die->attrs[i])));
8605 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8607 case DW_FORM_string:
8609 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8610 DW_STRING (&die->attrs[i])
8611 ? DW_STRING (&die->attrs[i]) : "");
8614 if (DW_UNSND (&die->attrs[i]))
8615 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8617 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8619 case DW_FORM_indirect:
8620 /* the reader will have reduced the indirect form to
8621 the "base form" so this form should not occur */
8622 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8625 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8626 die->attrs[i].form);
8628 fprintf_unfiltered (gdb_stderr, "\n");
8633 dump_die_list (struct die_info *die)
8638 if (die->child != NULL)
8639 dump_die_list (die->child);
8640 if (die->sibling != NULL)
8641 dump_die_list (die->sibling);
8646 store_in_ref_table (unsigned int offset, struct die_info *die,
8647 struct dwarf2_cu *cu)
8650 struct die_info *old;
8652 h = (offset % REF_HASH_SIZE);
8653 old = cu->die_ref_table[h];
8654 die->next_ref = old;
8655 cu->die_ref_table[h] = die;
8659 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
8661 unsigned int result = 0;
8665 case DW_FORM_ref_addr:
8670 case DW_FORM_ref_udata:
8671 result = DW_ADDR (attr);
8674 complaint (&symfile_complaints,
8675 _("unsupported die ref attribute form: '%s'"),
8676 dwarf_form_name (attr->form));
8681 /* Return the constant value held by the given attribute. Return -1
8682 if the value held by the attribute is not constant. */
8685 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
8687 if (attr->form == DW_FORM_sdata)
8688 return DW_SND (attr);
8689 else if (attr->form == DW_FORM_udata
8690 || attr->form == DW_FORM_data1
8691 || attr->form == DW_FORM_data2
8692 || attr->form == DW_FORM_data4
8693 || attr->form == DW_FORM_data8)
8694 return DW_UNSND (attr);
8697 complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
8698 dwarf_form_name (attr->form));
8699 return default_value;
8703 static struct die_info *
8704 follow_die_ref (struct die_info *src_die, struct attribute *attr,
8705 struct dwarf2_cu *cu)
8707 struct die_info *die;
8708 unsigned int offset;
8710 struct die_info temp_die;
8711 struct dwarf2_cu *target_cu;
8713 offset = dwarf2_get_ref_die_offset (attr, cu);
8715 if (DW_ADDR (attr) < cu->header.offset
8716 || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
8718 struct dwarf2_per_cu_data *per_cu;
8719 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
8721 target_cu = per_cu->cu;
8726 h = (offset % REF_HASH_SIZE);
8727 die = target_cu->die_ref_table[h];
8730 if (die->offset == offset)
8732 die = die->next_ref;
8735 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8736 "at 0x%lx [in module %s]"),
8737 (long) src_die->offset, (long) offset, cu->objfile->name);
8742 static struct type *
8743 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
8744 struct dwarf2_cu *cu)
8746 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
8748 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8749 typeid, objfile->name);
8752 /* Look for this particular type in the fundamental type vector. If
8753 one is not found, create and install one appropriate for the
8754 current language and the current target machine. */
8756 if (cu->ftypes[typeid] == NULL)
8758 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8761 return (cu->ftypes[typeid]);
8764 /* Decode simple location descriptions.
8765 Given a pointer to a dwarf block that defines a location, compute
8766 the location and return the value.
8768 NOTE drow/2003-11-18: This function is called in two situations
8769 now: for the address of static or global variables (partial symbols
8770 only) and for offsets into structures which are expected to be
8771 (more or less) constant. The partial symbol case should go away,
8772 and only the constant case should remain. That will let this
8773 function complain more accurately. A few special modes are allowed
8774 without complaint for global variables (for instance, global
8775 register values and thread-local values).
8777 A location description containing no operations indicates that the
8778 object is optimized out. The return value is 0 for that case.
8779 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8780 callers will only want a very basic result and this can become a
8783 Note that stack[0] is unused except as a default error return.
8784 Note that stack overflow is not yet handled. */
8787 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8789 struct objfile *objfile = cu->objfile;
8790 struct comp_unit_head *cu_header = &cu->header;
8792 int size = blk->size;
8793 gdb_byte *data = blk->data;
8794 CORE_ADDR stack[64];
8796 unsigned int bytes_read, unsnd;
8840 stack[++stacki] = op - DW_OP_lit0;
8875 stack[++stacki] = op - DW_OP_reg0;
8877 dwarf2_complex_location_expr_complaint ();
8881 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8883 stack[++stacki] = unsnd;
8885 dwarf2_complex_location_expr_complaint ();
8889 stack[++stacki] = read_address (objfile->obfd, &data[i],
8895 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8900 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8905 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8910 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8915 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8920 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8925 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8931 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8936 stack[stacki + 1] = stack[stacki];
8941 stack[stacki - 1] += stack[stacki];
8945 case DW_OP_plus_uconst:
8946 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8951 stack[stacki - 1] -= stack[stacki];
8956 /* If we're not the last op, then we definitely can't encode
8957 this using GDB's address_class enum. This is valid for partial
8958 global symbols, although the variable's address will be bogus
8961 dwarf2_complex_location_expr_complaint ();
8964 case DW_OP_GNU_push_tls_address:
8965 /* The top of the stack has the offset from the beginning
8966 of the thread control block at which the variable is located. */
8967 /* Nothing should follow this operator, so the top of stack would
8969 /* This is valid for partial global symbols, but the variable's
8970 address will be bogus in the psymtab. */
8972 dwarf2_complex_location_expr_complaint ();
8976 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
8977 dwarf_stack_op_name (op));
8978 return (stack[stacki]);
8981 return (stack[stacki]);
8984 /* memory allocation interface */
8986 static struct dwarf_block *
8987 dwarf_alloc_block (struct dwarf2_cu *cu)
8989 struct dwarf_block *blk;
8991 blk = (struct dwarf_block *)
8992 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8996 static struct abbrev_info *
8997 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8999 struct abbrev_info *abbrev;
9001 abbrev = (struct abbrev_info *)
9002 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
9003 memset (abbrev, 0, sizeof (struct abbrev_info));
9007 static struct die_info *
9008 dwarf_alloc_die (void)
9010 struct die_info *die;
9012 die = (struct die_info *) xmalloc (sizeof (struct die_info));
9013 memset (die, 0, sizeof (struct die_info));
9018 /* Macro support. */
9021 /* Return the full name of file number I in *LH's file name table.
9022 Use COMP_DIR as the name of the current directory of the
9023 compilation. The result is allocated using xmalloc; the caller is
9024 responsible for freeing it. */
9026 file_full_name (int file, struct line_header *lh, const char *comp_dir)
9028 /* Is the file number a valid index into the line header's file name
9029 table? Remember that file numbers start with one, not zero. */
9030 if (1 <= file && file <= lh->num_file_names)
9032 struct file_entry *fe = &lh->file_names[file - 1];
9034 if (IS_ABSOLUTE_PATH (fe->name))
9035 return xstrdup (fe->name);
9043 dir = lh->include_dirs[fe->dir_index - 1];
9049 dir_len = strlen (dir);
9050 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
9051 strcpy (full_name, dir);
9052 full_name[dir_len] = '/';
9053 strcpy (full_name + dir_len + 1, fe->name);
9057 return xstrdup (fe->name);
9062 /* The compiler produced a bogus file number. We can at least
9063 record the macro definitions made in the file, even if we
9064 won't be able to find the file by name. */
9066 sprintf (fake_name, "<bad macro file number %d>", file);
9068 complaint (&symfile_complaints,
9069 _("bad file number in macro information (%d)"),
9072 return xstrdup (fake_name);
9077 static struct macro_source_file *
9078 macro_start_file (int file, int line,
9079 struct macro_source_file *current_file,
9080 const char *comp_dir,
9081 struct line_header *lh, struct objfile *objfile)
9083 /* The full name of this source file. */
9084 char *full_name = file_full_name (file, lh, comp_dir);
9086 /* We don't create a macro table for this compilation unit
9087 at all until we actually get a filename. */
9088 if (! pending_macros)
9089 pending_macros = new_macro_table (&objfile->objfile_obstack,
9090 objfile->macro_cache);
9093 /* If we have no current file, then this must be the start_file
9094 directive for the compilation unit's main source file. */
9095 current_file = macro_set_main (pending_macros, full_name);
9097 current_file = macro_include (current_file, line, full_name);
9101 return current_file;
9105 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9106 followed by a null byte. */
9108 copy_string (const char *buf, int len)
9110 char *s = xmalloc (len + 1);
9111 memcpy (s, buf, len);
9119 consume_improper_spaces (const char *p, const char *body)
9123 complaint (&symfile_complaints,
9124 _("macro definition contains spaces in formal argument list:\n`%s'"),
9136 parse_macro_definition (struct macro_source_file *file, int line,
9141 /* The body string takes one of two forms. For object-like macro
9142 definitions, it should be:
9144 <macro name> " " <definition>
9146 For function-like macro definitions, it should be:
9148 <macro name> "() " <definition>
9150 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9152 Spaces may appear only where explicitly indicated, and in the
9155 The Dwarf 2 spec says that an object-like macro's name is always
9156 followed by a space, but versions of GCC around March 2002 omit
9157 the space when the macro's definition is the empty string.
9159 The Dwarf 2 spec says that there should be no spaces between the
9160 formal arguments in a function-like macro's formal argument list,
9161 but versions of GCC around March 2002 include spaces after the
9165 /* Find the extent of the macro name. The macro name is terminated
9166 by either a space or null character (for an object-like macro) or
9167 an opening paren (for a function-like macro). */
9168 for (p = body; *p; p++)
9169 if (*p == ' ' || *p == '(')
9172 if (*p == ' ' || *p == '\0')
9174 /* It's an object-like macro. */
9175 int name_len = p - body;
9176 char *name = copy_string (body, name_len);
9177 const char *replacement;
9180 replacement = body + name_len + 1;
9183 dwarf2_macro_malformed_definition_complaint (body);
9184 replacement = body + name_len;
9187 macro_define_object (file, line, name, replacement);
9193 /* It's a function-like macro. */
9194 char *name = copy_string (body, p - body);
9197 char **argv = xmalloc (argv_size * sizeof (*argv));
9201 p = consume_improper_spaces (p, body);
9203 /* Parse the formal argument list. */
9204 while (*p && *p != ')')
9206 /* Find the extent of the current argument name. */
9207 const char *arg_start = p;
9209 while (*p && *p != ',' && *p != ')' && *p != ' ')
9212 if (! *p || p == arg_start)
9213 dwarf2_macro_malformed_definition_complaint (body);
9216 /* Make sure argv has room for the new argument. */
9217 if (argc >= argv_size)
9220 argv = xrealloc (argv, argv_size * sizeof (*argv));
9223 argv[argc++] = copy_string (arg_start, p - arg_start);
9226 p = consume_improper_spaces (p, body);
9228 /* Consume the comma, if present. */
9233 p = consume_improper_spaces (p, body);
9242 /* Perfectly formed definition, no complaints. */
9243 macro_define_function (file, line, name,
9244 argc, (const char **) argv,
9246 else if (*p == '\0')
9248 /* Complain, but do define it. */
9249 dwarf2_macro_malformed_definition_complaint (body);
9250 macro_define_function (file, line, name,
9251 argc, (const char **) argv,
9255 /* Just complain. */
9256 dwarf2_macro_malformed_definition_complaint (body);
9259 /* Just complain. */
9260 dwarf2_macro_malformed_definition_complaint (body);
9266 for (i = 0; i < argc; i++)
9272 dwarf2_macro_malformed_definition_complaint (body);
9277 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9278 char *comp_dir, bfd *abfd,
9279 struct dwarf2_cu *cu)
9281 gdb_byte *mac_ptr, *mac_end;
9282 struct macro_source_file *current_file = 0;
9284 if (dwarf2_per_objfile->macinfo_buffer == NULL)
9286 complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9290 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9291 mac_end = dwarf2_per_objfile->macinfo_buffer
9292 + dwarf2_per_objfile->macinfo_size;
9296 enum dwarf_macinfo_record_type macinfo_type;
9298 /* Do we at least have room for a macinfo type byte? */
9299 if (mac_ptr >= mac_end)
9301 dwarf2_macros_too_long_complaint ();
9305 macinfo_type = read_1_byte (abfd, mac_ptr);
9308 switch (macinfo_type)
9310 /* A zero macinfo type indicates the end of the macro
9315 case DW_MACINFO_define:
9316 case DW_MACINFO_undef:
9318 unsigned int bytes_read;
9322 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9323 mac_ptr += bytes_read;
9324 body = read_string (abfd, mac_ptr, &bytes_read);
9325 mac_ptr += bytes_read;
9328 complaint (&symfile_complaints,
9329 _("debug info gives macro %s outside of any file: %s"),
9331 DW_MACINFO_define ? "definition" : macinfo_type ==
9332 DW_MACINFO_undef ? "undefinition" :
9333 "something-or-other", body);
9336 if (macinfo_type == DW_MACINFO_define)
9337 parse_macro_definition (current_file, line, body);
9338 else if (macinfo_type == DW_MACINFO_undef)
9339 macro_undef (current_file, line, body);
9344 case DW_MACINFO_start_file:
9346 unsigned int bytes_read;
9349 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9350 mac_ptr += bytes_read;
9351 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9352 mac_ptr += bytes_read;
9354 current_file = macro_start_file (file, line,
9355 current_file, comp_dir,
9360 case DW_MACINFO_end_file:
9362 complaint (&symfile_complaints,
9363 _("macro debug info has an unmatched `close_file' directive"));
9366 current_file = current_file->included_by;
9369 enum dwarf_macinfo_record_type next_type;
9371 /* GCC circa March 2002 doesn't produce the zero
9372 type byte marking the end of the compilation
9373 unit. Complain if it's not there, but exit no
9376 /* Do we at least have room for a macinfo type byte? */
9377 if (mac_ptr >= mac_end)
9379 dwarf2_macros_too_long_complaint ();
9383 /* We don't increment mac_ptr here, so this is just
9385 next_type = read_1_byte (abfd, mac_ptr);
9387 complaint (&symfile_complaints,
9388 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9395 case DW_MACINFO_vendor_ext:
9397 unsigned int bytes_read;
9401 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9402 mac_ptr += bytes_read;
9403 string = read_string (abfd, mac_ptr, &bytes_read);
9404 mac_ptr += bytes_read;
9406 /* We don't recognize any vendor extensions. */
9413 /* Check if the attribute's form is a DW_FORM_block*
9414 if so return true else false. */
9416 attr_form_is_block (struct attribute *attr)
9418 return (attr == NULL ? 0 :
9419 attr->form == DW_FORM_block1
9420 || attr->form == DW_FORM_block2
9421 || attr->form == DW_FORM_block4
9422 || attr->form == DW_FORM_block);
9426 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9427 struct dwarf2_cu *cu)
9429 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
9431 struct dwarf2_loclist_baton *baton;
9433 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9434 sizeof (struct dwarf2_loclist_baton));
9435 baton->objfile = cu->objfile;
9437 /* We don't know how long the location list is, but make sure we
9438 don't run off the edge of the section. */
9439 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9440 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9441 baton->base_address = cu->header.base_address;
9442 if (cu->header.base_known == 0)
9443 complaint (&symfile_complaints,
9444 _("Location list used without specifying the CU base address."));
9446 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9447 SYMBOL_LOCATION_BATON (sym) = baton;
9451 struct dwarf2_locexpr_baton *baton;
9453 baton = obstack_alloc (&cu->objfile->objfile_obstack,
9454 sizeof (struct dwarf2_locexpr_baton));
9455 baton->objfile = cu->objfile;
9457 if (attr_form_is_block (attr))
9459 /* Note that we're just copying the block's data pointer
9460 here, not the actual data. We're still pointing into the
9461 info_buffer for SYM's objfile; right now we never release
9462 that buffer, but when we do clean up properly this may
9464 baton->size = DW_BLOCK (attr)->size;
9465 baton->data = DW_BLOCK (attr)->data;
9469 dwarf2_invalid_attrib_class_complaint ("location description",
9470 SYMBOL_NATURAL_NAME (sym));
9475 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9476 SYMBOL_LOCATION_BATON (sym) = baton;
9480 /* Locate the compilation unit from CU's objfile which contains the
9481 DIE at OFFSET. Raises an error on failure. */
9483 static struct dwarf2_per_cu_data *
9484 dwarf2_find_containing_comp_unit (unsigned long offset,
9485 struct objfile *objfile)
9487 struct dwarf2_per_cu_data *this_cu;
9491 high = dwarf2_per_objfile->n_comp_units - 1;
9494 int mid = low + (high - low) / 2;
9495 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9500 gdb_assert (low == high);
9501 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9504 error (_("Dwarf Error: could not find partial DIE containing "
9505 "offset 0x%lx [in module %s]"),
9506 (long) offset, bfd_get_filename (objfile->obfd));
9508 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9509 return dwarf2_per_objfile->all_comp_units[low-1];
9513 this_cu = dwarf2_per_objfile->all_comp_units[low];
9514 if (low == dwarf2_per_objfile->n_comp_units - 1
9515 && offset >= this_cu->offset + this_cu->length)
9516 error (_("invalid dwarf2 offset %ld"), offset);
9517 gdb_assert (offset < this_cu->offset + this_cu->length);
9522 /* Locate the compilation unit from OBJFILE which is located at exactly
9523 OFFSET. Raises an error on failure. */
9525 static struct dwarf2_per_cu_data *
9526 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9528 struct dwarf2_per_cu_data *this_cu;
9529 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9530 if (this_cu->offset != offset)
9531 error (_("no compilation unit with offset %ld."), offset);
9535 /* Release one cached compilation unit, CU. We unlink it from the tree
9536 of compilation units, but we don't remove it from the read_in_chain;
9537 the caller is responsible for that. */
9540 free_one_comp_unit (void *data)
9542 struct dwarf2_cu *cu = data;
9544 if (cu->per_cu != NULL)
9545 cu->per_cu->cu = NULL;
9548 obstack_free (&cu->comp_unit_obstack, NULL);
9550 free_die_list (cu->dies);
9555 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9556 when we're finished with it. We can't free the pointer itself, but be
9557 sure to unlink it from the cache. Also release any associated storage
9558 and perform cache maintenance.
9560 Only used during partial symbol parsing. */
9563 free_stack_comp_unit (void *data)
9565 struct dwarf2_cu *cu = data;
9567 obstack_free (&cu->comp_unit_obstack, NULL);
9568 cu->partial_dies = NULL;
9570 if (cu->per_cu != NULL)
9572 /* This compilation unit is on the stack in our caller, so we
9573 should not xfree it. Just unlink it. */
9574 cu->per_cu->cu = NULL;
9577 /* If we had a per-cu pointer, then we may have other compilation
9578 units loaded, so age them now. */
9579 age_cached_comp_units ();
9583 /* Free all cached compilation units. */
9586 free_cached_comp_units (void *data)
9588 struct dwarf2_per_cu_data *per_cu, **last_chain;
9590 per_cu = dwarf2_per_objfile->read_in_chain;
9591 last_chain = &dwarf2_per_objfile->read_in_chain;
9592 while (per_cu != NULL)
9594 struct dwarf2_per_cu_data *next_cu;
9596 next_cu = per_cu->cu->read_in_chain;
9598 free_one_comp_unit (per_cu->cu);
9599 *last_chain = next_cu;
9605 /* Increase the age counter on each cached compilation unit, and free
9606 any that are too old. */
9609 age_cached_comp_units (void)
9611 struct dwarf2_per_cu_data *per_cu, **last_chain;
9613 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
9614 per_cu = dwarf2_per_objfile->read_in_chain;
9615 while (per_cu != NULL)
9617 per_cu->cu->last_used ++;
9618 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
9619 dwarf2_mark (per_cu->cu);
9620 per_cu = per_cu->cu->read_in_chain;
9623 per_cu = dwarf2_per_objfile->read_in_chain;
9624 last_chain = &dwarf2_per_objfile->read_in_chain;
9625 while (per_cu != NULL)
9627 struct dwarf2_per_cu_data *next_cu;
9629 next_cu = per_cu->cu->read_in_chain;
9631 if (!per_cu->cu->mark)
9633 free_one_comp_unit (per_cu->cu);
9634 *last_chain = next_cu;
9637 last_chain = &per_cu->cu->read_in_chain;
9643 /* Remove a single compilation unit from the cache. */
9646 free_one_cached_comp_unit (void *target_cu)
9648 struct dwarf2_per_cu_data *per_cu, **last_chain;
9650 per_cu = dwarf2_per_objfile->read_in_chain;
9651 last_chain = &dwarf2_per_objfile->read_in_chain;
9652 while (per_cu != NULL)
9654 struct dwarf2_per_cu_data *next_cu;
9656 next_cu = per_cu->cu->read_in_chain;
9658 if (per_cu->cu == target_cu)
9660 free_one_comp_unit (per_cu->cu);
9661 *last_chain = next_cu;
9665 last_chain = &per_cu->cu->read_in_chain;
9671 /* A pair of DIE offset and GDB type pointer. We store these
9672 in a hash table separate from the DIEs, and preserve them
9673 when the DIEs are flushed out of cache. */
9675 struct dwarf2_offset_and_type
9677 unsigned int offset;
9681 /* Hash function for a dwarf2_offset_and_type. */
9684 offset_and_type_hash (const void *item)
9686 const struct dwarf2_offset_and_type *ofs = item;
9690 /* Equality function for a dwarf2_offset_and_type. */
9693 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
9695 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
9696 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
9697 return ofs_lhs->offset == ofs_rhs->offset;
9700 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9701 table if necessary. */
9704 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
9706 struct dwarf2_offset_and_type **slot, ofs;
9710 if (cu->per_cu == NULL)
9713 if (cu->per_cu->type_hash == NULL)
9714 cu->per_cu->type_hash
9715 = htab_create_alloc_ex (cu->header.length / 24,
9716 offset_and_type_hash,
9719 &cu->objfile->objfile_obstack,
9720 hashtab_obstack_allocate,
9721 dummy_obstack_deallocate);
9723 ofs.offset = die->offset;
9725 slot = (struct dwarf2_offset_and_type **)
9726 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
9727 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
9731 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9732 have a saved type. */
9734 static struct type *
9735 get_die_type (struct die_info *die, htab_t type_hash)
9737 struct dwarf2_offset_and_type *slot, ofs;
9739 ofs.offset = die->offset;
9740 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
9747 /* Restore the types of the DIE tree starting at START_DIE from the hash
9748 table saved in CU. */
9751 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
9753 struct die_info *die;
9755 if (cu->per_cu->type_hash == NULL)
9758 for (die = start_die; die != NULL; die = die->sibling)
9760 die->type = get_die_type (die, cu->per_cu->type_hash);
9761 if (die->child != NULL)
9762 reset_die_and_siblings_types (die->child, cu);
9766 /* Set the mark field in CU and in every other compilation unit in the
9767 cache that we must keep because we are keeping CU. */
9769 /* Add a dependence relationship from CU to REF_PER_CU. */
9772 dwarf2_add_dependence (struct dwarf2_cu *cu,
9773 struct dwarf2_per_cu_data *ref_per_cu)
9777 if (cu->dependencies == NULL)
9779 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
9780 NULL, &cu->comp_unit_obstack,
9781 hashtab_obstack_allocate,
9782 dummy_obstack_deallocate);
9784 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
9789 /* Set the mark field in CU and in every other compilation unit in the
9790 cache that we must keep because we are keeping CU. */
9793 dwarf2_mark_helper (void **slot, void *data)
9795 struct dwarf2_per_cu_data *per_cu;
9797 per_cu = (struct dwarf2_per_cu_data *) *slot;
9798 if (per_cu->cu->mark)
9800 per_cu->cu->mark = 1;
9802 if (per_cu->cu->dependencies != NULL)
9803 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
9809 dwarf2_mark (struct dwarf2_cu *cu)
9814 if (cu->dependencies != NULL)
9815 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
9819 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
9823 per_cu->cu->mark = 0;
9824 per_cu = per_cu->cu->read_in_chain;
9828 /* Trivial hash function for partial_die_info: the hash value of a DIE
9829 is its offset in .debug_info for this objfile. */
9832 partial_die_hash (const void *item)
9834 const struct partial_die_info *part_die = item;
9835 return part_die->offset;
9838 /* Trivial comparison function for partial_die_info structures: two DIEs
9839 are equal if they have the same offset. */
9842 partial_die_eq (const void *item_lhs, const void *item_rhs)
9844 const struct partial_die_info *part_die_lhs = item_lhs;
9845 const struct partial_die_info *part_die_rhs = item_rhs;
9846 return part_die_lhs->offset == part_die_rhs->offset;
9849 static struct cmd_list_element *set_dwarf2_cmdlist;
9850 static struct cmd_list_element *show_dwarf2_cmdlist;
9853 set_dwarf2_cmd (char *args, int from_tty)
9855 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
9859 show_dwarf2_cmd (char *args, int from_tty)
9861 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
9864 void _initialize_dwarf2_read (void);
9867 _initialize_dwarf2_read (void)
9869 dwarf2_objfile_data_key = register_objfile_data ();
9871 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
9872 Set DWARF 2 specific variables.\n\
9873 Configure DWARF 2 variables such as the cache size"),
9874 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
9875 0/*allow-unknown*/, &maintenance_set_cmdlist);
9877 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
9878 Show DWARF 2 specific variables\n\
9879 Show DWARF 2 variables such as the cache size"),
9880 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
9881 0/*allow-unknown*/, &maintenance_show_cmdlist);
9883 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
9884 &dwarf2_max_cache_age, _("\
9885 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9886 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9887 A higher limit means that cached compilation units will be stored\n\
9888 in memory longer, and more total memory will be used. Zero disables\n\
9889 caching, which can slow down startup."),
9891 show_dwarf2_max_cache_age,
9892 &set_dwarf2_cmdlist,
9893 &show_dwarf2_cmdlist);