1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or (at
18 your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 51 Franklin Street, Fifth Floor,
28 Boston, MA 02110-1301, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
52 #include "gdb_string.h"
53 #include "gdb_assert.h"
54 #include <sys/types.h>
56 /* A note on memory usage for this file.
58 At the present time, this code reads the debug info sections into
59 the objfile's objfile_obstack. A definite improvement for startup
60 time, on platforms which do not emit relocations for debug
61 sections, would be to use mmap instead. The object's complete
62 debug information is loaded into memory, partly to simplify
63 absolute DIE references.
65 Whether using obstacks or mmap, the sections should remain loaded
66 until the objfile is released, and pointers into the section data
67 can be used for any other data associated to the objfile (symbol
68 names, type names, location expressions to name a few). */
70 #ifndef DWARF2_REG_TO_REGNUM
71 #define DWARF2_REG_TO_REGNUM(REG) (REG)
75 /* .debug_info header for a compilation unit
76 Because of alignment constraints, this structure has padding and cannot
77 be mapped directly onto the beginning of the .debug_info section. */
78 typedef struct comp_unit_header
80 unsigned int length
; /* length of the .debug_info
82 unsigned short version
; /* version number -- 2 for DWARF
84 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
85 unsigned char addr_size
; /* byte size of an address -- 4 */
88 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
91 /* .debug_pubnames header
92 Because of alignment constraints, this structure has padding and cannot
93 be mapped directly onto the beginning of the .debug_info section. */
94 typedef struct pubnames_header
96 unsigned int length
; /* length of the .debug_pubnames
98 unsigned char version
; /* version number -- 2 for DWARF
100 unsigned int info_offset
; /* offset into .debug_info section */
101 unsigned int info_size
; /* byte size of .debug_info section
105 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
107 /* .debug_pubnames header
108 Because of alignment constraints, this structure has padding and cannot
109 be mapped directly onto the beginning of the .debug_info section. */
110 typedef struct aranges_header
112 unsigned int length
; /* byte len of the .debug_aranges
114 unsigned short version
; /* version number -- 2 for DWARF
116 unsigned int info_offset
; /* offset into .debug_info section */
117 unsigned char addr_size
; /* byte size of an address */
118 unsigned char seg_size
; /* byte size of segment descriptor */
121 #define _ACTUAL_ARANGES_HEADER_SIZE 12
123 /* .debug_line statement program prologue
124 Because of alignment constraints, this structure has padding and cannot
125 be mapped directly onto the beginning of the .debug_info section. */
126 typedef struct statement_prologue
128 unsigned int total_length
; /* byte length of the statement
130 unsigned short version
; /* version number -- 2 for DWARF
132 unsigned int prologue_length
; /* # bytes between prologue &
134 unsigned char minimum_instruction_length
; /* byte size of
136 unsigned char default_is_stmt
; /* initial value of is_stmt
139 unsigned char line_range
;
140 unsigned char opcode_base
; /* number assigned to first special
142 unsigned char *standard_opcode_lengths
;
146 static const struct objfile_data
*dwarf2_objfile_data_key
;
148 struct dwarf2_per_objfile
150 /* Sizes of debugging sections. */
151 unsigned int info_size
;
152 unsigned int abbrev_size
;
153 unsigned int line_size
;
154 unsigned int pubnames_size
;
155 unsigned int aranges_size
;
156 unsigned int loc_size
;
157 unsigned int macinfo_size
;
158 unsigned int str_size
;
159 unsigned int ranges_size
;
160 unsigned int frame_size
;
161 unsigned int eh_frame_size
;
163 /* Loaded data from the sections. */
164 gdb_byte
*info_buffer
;
165 gdb_byte
*abbrev_buffer
;
166 gdb_byte
*line_buffer
;
167 gdb_byte
*str_buffer
;
168 gdb_byte
*macinfo_buffer
;
169 gdb_byte
*ranges_buffer
;
170 gdb_byte
*loc_buffer
;
172 /* A list of all the compilation units. This is used to locate
173 the target compilation unit of a particular reference. */
174 struct dwarf2_per_cu_data
**all_comp_units
;
176 /* The number of compilation units in ALL_COMP_UNITS. */
179 /* A chain of compilation units that are currently read in, so that
180 they can be freed later. */
181 struct dwarf2_per_cu_data
*read_in_chain
;
183 /* A flag indicating wether this objfile has a section loaded at a
185 int has_section_at_zero
;
188 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
190 static asection
*dwarf_info_section
;
191 static asection
*dwarf_abbrev_section
;
192 static asection
*dwarf_line_section
;
193 static asection
*dwarf_pubnames_section
;
194 static asection
*dwarf_aranges_section
;
195 static asection
*dwarf_loc_section
;
196 static asection
*dwarf_macinfo_section
;
197 static asection
*dwarf_str_section
;
198 static asection
*dwarf_ranges_section
;
199 asection
*dwarf_frame_section
;
200 asection
*dwarf_eh_frame_section
;
202 /* names of the debugging sections */
204 #define INFO_SECTION ".debug_info"
205 #define ABBREV_SECTION ".debug_abbrev"
206 #define LINE_SECTION ".debug_line"
207 #define PUBNAMES_SECTION ".debug_pubnames"
208 #define ARANGES_SECTION ".debug_aranges"
209 #define LOC_SECTION ".debug_loc"
210 #define MACINFO_SECTION ".debug_macinfo"
211 #define STR_SECTION ".debug_str"
212 #define RANGES_SECTION ".debug_ranges"
213 #define FRAME_SECTION ".debug_frame"
214 #define EH_FRAME_SECTION ".eh_frame"
216 /* local data types */
218 /* We hold several abbreviation tables in memory at the same time. */
219 #ifndef ABBREV_HASH_SIZE
220 #define ABBREV_HASH_SIZE 121
223 /* The data in a compilation unit header, after target2host
224 translation, looks like this. */
225 struct comp_unit_head
227 unsigned long length
;
229 unsigned int abbrev_offset
;
230 unsigned char addr_size
;
231 unsigned char signed_addr_p
;
233 /* Size of file offsets; either 4 or 8. */
234 unsigned int offset_size
;
236 /* Size of the length field; either 4 or 12. */
237 unsigned int initial_length_size
;
239 /* Offset to the first byte of this compilation unit header in the
240 .debug_info section, for resolving relative reference dies. */
243 /* Pointer to this compilation unit header in the .debug_info
245 gdb_byte
*cu_head_ptr
;
247 /* Pointer to the first die of this compilation unit. This will be
248 the first byte following the compilation unit header. */
249 gdb_byte
*first_die_ptr
;
251 /* Pointer to the next compilation unit header in the program. */
252 struct comp_unit_head
*next
;
254 /* Base address of this compilation unit. */
255 CORE_ADDR base_address
;
257 /* Non-zero if base_address has been set. */
261 /* Fixed size for the DIE hash table. */
262 #ifndef REF_HASH_SIZE
263 #define REF_HASH_SIZE 1021
266 /* Internal state when decoding a particular compilation unit. */
269 /* The objfile containing this compilation unit. */
270 struct objfile
*objfile
;
272 /* The header of the compilation unit.
274 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
275 should logically be moved to the dwarf2_cu structure. */
276 struct comp_unit_head header
;
278 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
280 /* The language we are debugging. */
281 enum language language
;
282 const struct language_defn
*language_defn
;
284 const char *producer
;
286 /* The generic symbol table building routines have separate lists for
287 file scope symbols and all all other scopes (local scopes). So
288 we need to select the right one to pass to add_symbol_to_list().
289 We do it by keeping a pointer to the correct list in list_in_scope.
291 FIXME: The original dwarf code just treated the file scope as the
292 first local scope, and all other local scopes as nested local
293 scopes, and worked fine. Check to see if we really need to
294 distinguish these in buildsym.c. */
295 struct pending
**list_in_scope
;
297 /* Maintain an array of referenced fundamental types for the current
298 compilation unit being read. For DWARF version 1, we have to construct
299 the fundamental types on the fly, since no information about the
300 fundamental types is supplied. Each such fundamental type is created by
301 calling a language dependent routine to create the type, and then a
302 pointer to that type is then placed in the array at the index specified
303 by it's FT_<TYPENAME> value. The array has a fixed size set by the
304 FT_NUM_MEMBERS compile time constant, which is the number of predefined
305 fundamental types gdb knows how to construct. */
306 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
308 /* DWARF abbreviation table associated with this compilation unit. */
309 struct abbrev_info
**dwarf2_abbrevs
;
311 /* Storage for the abbrev table. */
312 struct obstack abbrev_obstack
;
314 /* Hash table holding all the loaded partial DIEs. */
317 /* Storage for things with the same lifetime as this read-in compilation
318 unit, including partial DIEs. */
319 struct obstack comp_unit_obstack
;
321 /* When multiple dwarf2_cu structures are living in memory, this field
322 chains them all together, so that they can be released efficiently.
323 We will probably also want a generation counter so that most-recently-used
324 compilation units are cached... */
325 struct dwarf2_per_cu_data
*read_in_chain
;
327 /* Backchain to our per_cu entry if the tree has been built. */
328 struct dwarf2_per_cu_data
*per_cu
;
330 /* How many compilation units ago was this CU last referenced? */
333 /* A hash table of die offsets for following references. */
334 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
336 /* Full DIEs if read in. */
337 struct die_info
*dies
;
339 /* A set of pointers to dwarf2_per_cu_data objects for compilation
340 units referenced by this one. Only set during full symbol processing;
341 partial symbol tables do not have dependencies. */
344 /* Header data from the line table, during full symbol processing. */
345 struct line_header
*line_header
;
347 /* Mark used when releasing cached dies. */
348 unsigned int mark
: 1;
350 /* This flag will be set if this compilation unit might include
351 inter-compilation-unit references. */
352 unsigned int has_form_ref_addr
: 1;
354 /* This flag will be set if this compilation unit includes any
355 DW_TAG_namespace DIEs. If we know that there are explicit
356 DIEs for namespaces, we don't need to try to infer them
357 from mangled names. */
358 unsigned int has_namespace_info
: 1;
361 /* Persistent data held for a compilation unit, even when not
362 processing it. We put a pointer to this structure in the
363 read_symtab_private field of the psymtab. If we encounter
364 inter-compilation-unit references, we also maintain a sorted
365 list of all compilation units. */
367 struct dwarf2_per_cu_data
369 /* The start offset and length of this compilation unit. 2**30-1
370 bytes should suffice to store the length of any compilation unit
371 - if it doesn't, GDB will fall over anyway. */
372 unsigned long offset
;
373 unsigned long length
: 30;
375 /* Flag indicating this compilation unit will be read in before
376 any of the current compilation units are processed. */
377 unsigned long queued
: 1;
379 /* This flag will be set if we need to load absolutely all DIEs
380 for this compilation unit, instead of just the ones we think
381 are interesting. It gets set if we look for a DIE in the
382 hash table and don't find it. */
383 unsigned int load_all_dies
: 1;
385 /* Set iff currently read in. */
386 struct dwarf2_cu
*cu
;
388 /* If full symbols for this CU have been read in, then this field
389 holds a map of DIE offsets to types. It isn't always possible
390 to reconstruct this information later, so we have to preserve
394 /* The partial symbol table associated with this compilation unit,
395 or NULL for partial units (which do not have an associated
397 struct partial_symtab
*psymtab
;
400 /* The line number information for a compilation unit (found in the
401 .debug_line section) begins with a "statement program header",
402 which contains the following information. */
405 unsigned int total_length
;
406 unsigned short version
;
407 unsigned int header_length
;
408 unsigned char minimum_instruction_length
;
409 unsigned char default_is_stmt
;
411 unsigned char line_range
;
412 unsigned char opcode_base
;
414 /* standard_opcode_lengths[i] is the number of operands for the
415 standard opcode whose value is i. This means that
416 standard_opcode_lengths[0] is unused, and the last meaningful
417 element is standard_opcode_lengths[opcode_base - 1]. */
418 unsigned char *standard_opcode_lengths
;
420 /* The include_directories table. NOTE! These strings are not
421 allocated with xmalloc; instead, they are pointers into
422 debug_line_buffer. If you try to free them, `free' will get
424 unsigned int num_include_dirs
, include_dirs_size
;
427 /* The file_names table. NOTE! These strings are not allocated
428 with xmalloc; instead, they are pointers into debug_line_buffer.
429 Don't try to free them directly. */
430 unsigned int num_file_names
, file_names_size
;
434 unsigned int dir_index
;
435 unsigned int mod_time
;
437 int included_p
; /* Non-zero if referenced by the Line Number Program. */
438 struct symtab
*symtab
; /* The associated symbol table, if any. */
441 /* The start and end of the statement program following this
442 header. These point into dwarf2_per_objfile->line_buffer. */
443 gdb_byte
*statement_program_start
, *statement_program_end
;
446 /* When we construct a partial symbol table entry we only
447 need this much information. */
448 struct partial_die_info
450 /* Offset of this DIE. */
453 /* DWARF-2 tag for this DIE. */
454 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
456 /* Language code associated with this DIE. This is only used
457 for the compilation unit DIE. */
458 unsigned int language
: 8;
460 /* Assorted flags describing the data found in this DIE. */
461 unsigned int has_children
: 1;
462 unsigned int is_external
: 1;
463 unsigned int is_declaration
: 1;
464 unsigned int has_type
: 1;
465 unsigned int has_specification
: 1;
466 unsigned int has_stmt_list
: 1;
467 unsigned int has_pc_info
: 1;
469 /* Flag set if the SCOPE field of this structure has been
471 unsigned int scope_set
: 1;
473 /* Flag set if the DIE has a byte_size attribute. */
474 unsigned int has_byte_size
: 1;
476 /* The name of this DIE. Normally the value of DW_AT_name, but
477 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
482 /* The scope to prepend to our children. This is generally
483 allocated on the comp_unit_obstack, so will disappear
484 when this compilation unit leaves the cache. */
487 /* The location description associated with this DIE, if any. */
488 struct dwarf_block
*locdesc
;
490 /* If HAS_PC_INFO, the PC range associated with this DIE. */
494 /* Pointer into the info_buffer pointing at the target of
495 DW_AT_sibling, if any. */
498 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
499 DW_AT_specification (or DW_AT_abstract_origin or
501 unsigned int spec_offset
;
503 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
504 unsigned int line_offset
;
506 /* Pointers to this DIE's parent, first child, and next sibling,
508 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
511 /* This data structure holds the information of an abbrev. */
514 unsigned int number
; /* number identifying abbrev */
515 enum dwarf_tag tag
; /* dwarf tag */
516 unsigned short has_children
; /* boolean */
517 unsigned short num_attrs
; /* number of attributes */
518 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
519 struct abbrev_info
*next
; /* next in chain */
524 enum dwarf_attribute name
;
525 enum dwarf_form form
;
528 /* This data structure holds a complete die structure. */
531 enum dwarf_tag tag
; /* Tag indicating type of die */
532 unsigned int abbrev
; /* Abbrev number */
533 unsigned int offset
; /* Offset in .debug_info section */
534 unsigned int num_attrs
; /* Number of attributes */
535 struct attribute
*attrs
; /* An array of attributes */
536 struct die_info
*next_ref
; /* Next die in ref hash table */
538 /* The dies in a compilation unit form an n-ary tree. PARENT
539 points to this die's parent; CHILD points to the first child of
540 this node; and all the children of a given node are chained
541 together via their SIBLING fields, terminated by a die whose
543 struct die_info
*child
; /* Its first child, if any. */
544 struct die_info
*sibling
; /* Its next sibling, if any. */
545 struct die_info
*parent
; /* Its parent, if any. */
547 struct type
*type
; /* Cached type information */
550 /* Attributes have a name and a value */
553 enum dwarf_attribute name
;
554 enum dwarf_form form
;
558 struct dwarf_block
*blk
;
566 struct function_range
569 CORE_ADDR lowpc
, highpc
;
571 struct function_range
*next
;
574 /* Get at parts of an attribute structure */
576 #define DW_STRING(attr) ((attr)->u.str)
577 #define DW_UNSND(attr) ((attr)->u.unsnd)
578 #define DW_BLOCK(attr) ((attr)->u.blk)
579 #define DW_SND(attr) ((attr)->u.snd)
580 #define DW_ADDR(attr) ((attr)->u.addr)
582 /* Blocks are a bunch of untyped bytes. */
589 #ifndef ATTR_ALLOC_CHUNK
590 #define ATTR_ALLOC_CHUNK 4
593 /* Allocate fields for structs, unions and enums in this size. */
594 #ifndef DW_FIELD_ALLOC_CHUNK
595 #define DW_FIELD_ALLOC_CHUNK 4
598 /* A zeroed version of a partial die for initialization purposes. */
599 static struct partial_die_info zeroed_partial_die
;
601 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
602 but this would require a corresponding change in unpack_field_as_long
604 static int bits_per_byte
= 8;
606 /* The routines that read and process dies for a C struct or C++ class
607 pass lists of data member fields and lists of member function fields
608 in an instance of a field_info structure, as defined below. */
611 /* List of data member and baseclasses fields. */
614 struct nextfield
*next
;
621 /* Number of fields. */
624 /* Number of baseclasses. */
627 /* Set if the accesibility of one of the fields is not public. */
628 int non_public_fields
;
630 /* Member function fields array, entries are allocated in the order they
631 are encountered in the object file. */
634 struct nextfnfield
*next
;
635 struct fn_field fnfield
;
639 /* Member function fieldlist array, contains name of possibly overloaded
640 member function, number of overloaded member functions and a pointer
641 to the head of the member function field chain. */
646 struct nextfnfield
*head
;
650 /* Number of entries in the fnfieldlists array. */
654 /* One item on the queue of compilation units to read in full symbols
656 struct dwarf2_queue_item
658 struct dwarf2_per_cu_data
*per_cu
;
659 struct dwarf2_queue_item
*next
;
662 /* The current queue. */
663 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
665 /* Loaded secondary compilation units are kept in memory until they
666 have not been referenced for the processing of this many
667 compilation units. Set this to zero to disable caching. Cache
668 sizes of up to at least twenty will improve startup time for
669 typical inter-CU-reference binaries, at an obvious memory cost. */
670 static int dwarf2_max_cache_age
= 5;
672 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
673 struct cmd_list_element
*c
, const char *value
)
675 fprintf_filtered (file
, _("\
676 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
681 /* Various complaints about symbol reading that don't abort the process */
684 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
686 complaint (&symfile_complaints
,
687 _("statement list doesn't fit in .debug_line section"));
691 dwarf2_complex_location_expr_complaint (void)
693 complaint (&symfile_complaints
, _("location expression too complex"));
697 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
700 complaint (&symfile_complaints
,
701 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
706 dwarf2_macros_too_long_complaint (void)
708 complaint (&symfile_complaints
,
709 _("macro info runs off end of `.debug_macinfo' section"));
713 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
715 complaint (&symfile_complaints
,
716 _("macro debug info contains a malformed macro definition:\n`%s'"),
721 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
723 complaint (&symfile_complaints
,
724 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
727 /* local function prototypes */
729 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
732 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
735 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
738 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
739 struct partial_die_info
*,
740 struct partial_symtab
*);
742 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
744 static void scan_partial_symbols (struct partial_die_info
*,
745 CORE_ADDR
*, CORE_ADDR
*,
748 static void add_partial_symbol (struct partial_die_info
*,
751 static int pdi_needs_namespace (enum dwarf_tag tag
);
753 static void add_partial_namespace (struct partial_die_info
*pdi
,
754 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
755 struct dwarf2_cu
*cu
);
757 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
758 struct dwarf2_cu
*cu
);
760 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
763 struct dwarf2_cu
*cu
);
765 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
767 static void psymtab_to_symtab_1 (struct partial_symtab
*);
769 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
771 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
773 static void dwarf2_free_abbrev_table (void *);
775 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
778 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
781 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
784 static gdb_byte
*read_partial_die (struct partial_die_info
*,
785 struct abbrev_info
*abbrev
, unsigned int,
786 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
788 static struct partial_die_info
*find_partial_die (unsigned long,
791 static void fixup_partial_die (struct partial_die_info
*,
794 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
795 struct dwarf2_cu
*, int *);
797 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
798 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
800 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
801 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
803 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
805 static int read_1_signed_byte (bfd
*, gdb_byte
*);
807 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
809 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
811 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
813 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
816 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
817 struct comp_unit_head
*, unsigned int *);
819 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
822 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
824 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
826 static char *read_indirect_string (bfd
*, gdb_byte
*,
827 const struct comp_unit_head
*,
830 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
832 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
834 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
836 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
838 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
841 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
842 struct dwarf2_cu
*cu
);
844 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
846 static struct die_info
*die_specification (struct die_info
*die
,
849 static void free_line_header (struct line_header
*lh
);
851 static void add_file_name (struct line_header
*, char *, unsigned int,
852 unsigned int, unsigned int);
854 static struct line_header
*(dwarf_decode_line_header
855 (unsigned int offset
,
856 bfd
*abfd
, struct dwarf2_cu
*cu
));
858 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
859 struct dwarf2_cu
*, struct partial_symtab
*);
861 static void dwarf2_start_subfile (char *, char *, char *);
863 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
866 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
869 static void dwarf2_const_value_data (struct attribute
*attr
,
873 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
875 static struct type
*die_containing_type (struct die_info
*,
878 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
880 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
882 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
884 static char *typename_concat (struct obstack
*,
889 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
891 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
893 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
895 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
897 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
899 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
901 static int dwarf2_get_pc_bounds (struct die_info
*,
902 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
904 static void get_scope_pc_bounds (struct die_info
*,
905 CORE_ADDR
*, CORE_ADDR
*,
908 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
911 static void dwarf2_attach_fields_to_type (struct field_info
*,
912 struct type
*, struct dwarf2_cu
*);
914 static void dwarf2_add_member_fn (struct field_info
*,
915 struct die_info
*, struct type
*,
918 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
919 struct type
*, struct dwarf2_cu
*);
921 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
923 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
925 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
927 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
929 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
931 static const char *namespace_name (struct die_info
*die
,
932 int *is_anonymous
, struct dwarf2_cu
*);
934 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
936 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
938 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
940 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
942 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
944 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
947 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
949 static void read_tag_ptr_to_member_type (struct die_info
*,
952 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
954 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
956 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
958 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
960 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
962 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
964 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
966 gdb_byte
**new_info_ptr
,
967 struct die_info
*parent
);
969 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
971 gdb_byte
**new_info_ptr
,
972 struct die_info
*parent
);
974 static void free_die_list (struct die_info
*);
976 static void process_die (struct die_info
*, struct dwarf2_cu
*);
978 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
980 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
982 static struct die_info
*dwarf2_extension (struct die_info
*die
,
985 static char *dwarf_tag_name (unsigned int);
987 static char *dwarf_attr_name (unsigned int);
989 static char *dwarf_form_name (unsigned int);
991 static char *dwarf_stack_op_name (unsigned int);
993 static char *dwarf_bool_name (unsigned int);
995 static char *dwarf_type_encoding_name (unsigned int);
998 static char *dwarf_cfi_name (unsigned int);
1000 struct die_info
*copy_die (struct die_info
*);
1003 static struct die_info
*sibling_die (struct die_info
*);
1005 static void dump_die (struct die_info
*);
1007 static void dump_die_list (struct die_info
*);
1009 static void store_in_ref_table (unsigned int, struct die_info
*,
1010 struct dwarf2_cu
*);
1012 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1013 struct dwarf2_cu
*);
1015 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1017 static struct die_info
*follow_die_ref (struct die_info
*,
1019 struct dwarf2_cu
*);
1021 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1022 struct dwarf2_cu
*);
1024 /* memory allocation interface */
1026 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1028 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1030 static struct die_info
*dwarf_alloc_die (void);
1032 static void initialize_cu_func_list (struct dwarf2_cu
*);
1034 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1035 struct dwarf2_cu
*);
1037 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1038 char *, bfd
*, struct dwarf2_cu
*);
1040 static int attr_form_is_block (struct attribute
*);
1043 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1044 struct dwarf2_cu
*cu
);
1046 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1047 struct dwarf2_cu
*cu
);
1049 static void free_stack_comp_unit (void *);
1051 static hashval_t
partial_die_hash (const void *item
);
1053 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1055 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1056 (unsigned long offset
, struct objfile
*objfile
);
1058 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1059 (unsigned long offset
, struct objfile
*objfile
);
1061 static void free_one_comp_unit (void *);
1063 static void free_cached_comp_units (void *);
1065 static void age_cached_comp_units (void);
1067 static void free_one_cached_comp_unit (void *);
1069 static void set_die_type (struct die_info
*, struct type
*,
1070 struct dwarf2_cu
*);
1072 static void reset_die_and_siblings_types (struct die_info
*,
1073 struct dwarf2_cu
*);
1075 static void create_all_comp_units (struct objfile
*);
1077 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1080 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1082 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1083 struct dwarf2_per_cu_data
*);
1085 static void dwarf2_mark (struct dwarf2_cu
*);
1087 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1089 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1092 /* Try to locate the sections we need for DWARF 2 debugging
1093 information and return true if we have enough to do something. */
1096 dwarf2_has_info (struct objfile
*objfile
)
1098 struct dwarf2_per_objfile
*data
;
1100 /* Initialize per-objfile state. */
1101 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1102 memset (data
, 0, sizeof (*data
));
1103 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1104 dwarf2_per_objfile
= data
;
1106 dwarf_info_section
= 0;
1107 dwarf_abbrev_section
= 0;
1108 dwarf_line_section
= 0;
1109 dwarf_str_section
= 0;
1110 dwarf_macinfo_section
= 0;
1111 dwarf_frame_section
= 0;
1112 dwarf_eh_frame_section
= 0;
1113 dwarf_ranges_section
= 0;
1114 dwarf_loc_section
= 0;
1116 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1117 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1120 /* This function is mapped across the sections and remembers the
1121 offset and size of each of the debugging sections we are interested
1125 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1127 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1129 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1130 dwarf_info_section
= sectp
;
1132 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1134 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1135 dwarf_abbrev_section
= sectp
;
1137 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1139 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1140 dwarf_line_section
= sectp
;
1142 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1144 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1145 dwarf_pubnames_section
= sectp
;
1147 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1149 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1150 dwarf_aranges_section
= sectp
;
1152 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1154 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1155 dwarf_loc_section
= sectp
;
1157 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1159 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1160 dwarf_macinfo_section
= sectp
;
1162 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1164 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1165 dwarf_str_section
= sectp
;
1167 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1169 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1170 dwarf_frame_section
= sectp
;
1172 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1174 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1175 if (aflag
& SEC_HAS_CONTENTS
)
1177 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1178 dwarf_eh_frame_section
= sectp
;
1181 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1183 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1184 dwarf_ranges_section
= sectp
;
1187 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1188 && bfd_section_vma (abfd
, sectp
) == 0)
1189 dwarf2_per_objfile
->has_section_at_zero
= 1;
1192 /* Build a partial symbol table. */
1195 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1197 /* We definitely need the .debug_info and .debug_abbrev sections */
1199 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1200 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1202 if (dwarf_line_section
)
1203 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1205 dwarf2_per_objfile
->line_buffer
= NULL
;
1207 if (dwarf_str_section
)
1208 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1210 dwarf2_per_objfile
->str_buffer
= NULL
;
1212 if (dwarf_macinfo_section
)
1213 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1214 dwarf_macinfo_section
);
1216 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1218 if (dwarf_ranges_section
)
1219 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1221 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1223 if (dwarf_loc_section
)
1224 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1226 dwarf2_per_objfile
->loc_buffer
= NULL
;
1229 || (objfile
->global_psymbols
.size
== 0
1230 && objfile
->static_psymbols
.size
== 0))
1232 init_psymbol_list (objfile
, 1024);
1236 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1238 /* Things are significantly easier if we have .debug_aranges and
1239 .debug_pubnames sections */
1241 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1245 /* only test this case for now */
1247 /* In this case we have to work a bit harder */
1248 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1253 /* Build the partial symbol table from the information in the
1254 .debug_pubnames and .debug_aranges sections. */
1257 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1259 bfd
*abfd
= objfile
->obfd
;
1260 char *aranges_buffer
, *pubnames_buffer
;
1261 char *aranges_ptr
, *pubnames_ptr
;
1262 unsigned int entry_length
, version
, info_offset
, info_size
;
1264 pubnames_buffer
= dwarf2_read_section (objfile
,
1265 dwarf_pubnames_section
);
1266 pubnames_ptr
= pubnames_buffer
;
1267 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1269 struct comp_unit_head cu_header
;
1270 unsigned int bytes_read
;
1272 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1274 pubnames_ptr
+= bytes_read
;
1275 version
= read_1_byte (abfd
, pubnames_ptr
);
1277 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1279 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1283 aranges_buffer
= dwarf2_read_section (objfile
,
1284 dwarf_aranges_section
);
1289 /* Read in the comp unit header information from the debug_info at
1293 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1294 gdb_byte
*info_ptr
, bfd
*abfd
)
1297 unsigned int bytes_read
;
1298 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1300 info_ptr
+= bytes_read
;
1301 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1303 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1305 info_ptr
+= bytes_read
;
1306 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1308 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1309 if (signed_addr
< 0)
1310 internal_error (__FILE__
, __LINE__
,
1311 _("read_comp_unit_head: dwarf from non elf file"));
1312 cu_header
->signed_addr_p
= signed_addr
;
1317 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1320 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1322 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1324 if (header
->version
!= 2 && header
->version
!= 3)
1325 error (_("Dwarf Error: wrong version in compilation unit header "
1326 "(is %d, should be %d) [in module %s]"), header
->version
,
1327 2, bfd_get_filename (abfd
));
1329 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1330 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1331 "(offset 0x%lx + 6) [in module %s]"),
1332 (long) header
->abbrev_offset
,
1333 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1334 bfd_get_filename (abfd
));
1336 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1337 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1338 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1339 "(offset 0x%lx + 0) [in module %s]"),
1340 (long) header
->length
,
1341 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1342 bfd_get_filename (abfd
));
1347 /* Allocate a new partial symtab for file named NAME and mark this new
1348 partial symtab as being an include of PST. */
1351 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1352 struct objfile
*objfile
)
1354 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1356 subpst
->section_offsets
= pst
->section_offsets
;
1357 subpst
->textlow
= 0;
1358 subpst
->texthigh
= 0;
1360 subpst
->dependencies
= (struct partial_symtab
**)
1361 obstack_alloc (&objfile
->objfile_obstack
,
1362 sizeof (struct partial_symtab
*));
1363 subpst
->dependencies
[0] = pst
;
1364 subpst
->number_of_dependencies
= 1;
1366 subpst
->globals_offset
= 0;
1367 subpst
->n_global_syms
= 0;
1368 subpst
->statics_offset
= 0;
1369 subpst
->n_static_syms
= 0;
1370 subpst
->symtab
= NULL
;
1371 subpst
->read_symtab
= pst
->read_symtab
;
1374 /* No private part is necessary for include psymtabs. This property
1375 can be used to differentiate between such include psymtabs and
1376 the regular ones. */
1377 subpst
->read_symtab_private
= NULL
;
1380 /* Read the Line Number Program data and extract the list of files
1381 included by the source file represented by PST. Build an include
1382 partial symtab for each of these included files.
1384 This procedure assumes that there *is* a Line Number Program in
1385 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1386 before calling this procedure. */
1389 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1390 struct partial_die_info
*pdi
,
1391 struct partial_symtab
*pst
)
1393 struct objfile
*objfile
= cu
->objfile
;
1394 bfd
*abfd
= objfile
->obfd
;
1395 struct line_header
*lh
;
1397 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1399 return; /* No linetable, so no includes. */
1401 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1403 free_line_header (lh
);
1407 /* Build the partial symbol table by doing a quick pass through the
1408 .debug_info and .debug_abbrev sections. */
1411 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1413 /* Instead of reading this into a big buffer, we should probably use
1414 mmap() on architectures that support it. (FIXME) */
1415 bfd
*abfd
= objfile
->obfd
;
1417 gdb_byte
*beg_of_comp_unit
;
1418 struct partial_die_info comp_unit_die
;
1419 struct partial_symtab
*pst
;
1420 struct cleanup
*back_to
;
1421 CORE_ADDR lowpc
, highpc
, baseaddr
;
1423 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1425 /* Any cached compilation units will be linked by the per-objfile
1426 read_in_chain. Make sure to free them when we're done. */
1427 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1429 create_all_comp_units (objfile
);
1431 /* Since the objects we're extracting from .debug_info vary in
1432 length, only the individual functions to extract them (like
1433 read_comp_unit_head and load_partial_die) can really know whether
1434 the buffer is large enough to hold another complete object.
1436 At the moment, they don't actually check that. If .debug_info
1437 holds just one extra byte after the last compilation unit's dies,
1438 then read_comp_unit_head will happily read off the end of the
1439 buffer. read_partial_die is similarly casual. Those functions
1442 For this loop condition, simply checking whether there's any data
1443 left at all should be sufficient. */
1444 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1445 + dwarf2_per_objfile
->info_size
))
1447 struct cleanup
*back_to_inner
;
1448 struct dwarf2_cu cu
;
1449 struct abbrev_info
*abbrev
;
1450 unsigned int bytes_read
;
1451 struct dwarf2_per_cu_data
*this_cu
;
1453 beg_of_comp_unit
= info_ptr
;
1455 memset (&cu
, 0, sizeof (cu
));
1457 obstack_init (&cu
.comp_unit_obstack
);
1459 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1461 cu
.objfile
= objfile
;
1462 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1464 /* Complete the cu_header */
1465 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1466 cu
.header
.first_die_ptr
= info_ptr
;
1467 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1469 cu
.list_in_scope
= &file_symbols
;
1471 /* Read the abbrevs for this compilation unit into a table */
1472 dwarf2_read_abbrevs (abfd
, &cu
);
1473 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1475 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1477 /* Read the compilation unit die */
1478 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1479 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1480 abfd
, info_ptr
, &cu
);
1482 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1484 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1485 + cu
.header
.initial_length_size
);
1486 do_cleanups (back_to_inner
);
1490 /* Set the language we're debugging */
1491 set_cu_language (comp_unit_die
.language
, &cu
);
1493 /* Allocate a new partial symbol table structure */
1494 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1495 comp_unit_die
.name
? comp_unit_die
.name
: "",
1496 comp_unit_die
.lowpc
,
1497 objfile
->global_psymbols
.next
,
1498 objfile
->static_psymbols
.next
);
1500 if (comp_unit_die
.dirname
)
1501 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1503 pst
->read_symtab_private
= (char *) this_cu
;
1505 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1507 /* Store the function that reads in the rest of the symbol table */
1508 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1510 /* If this compilation unit was already read in, free the
1511 cached copy in order to read it in again. This is
1512 necessary because we skipped some symbols when we first
1513 read in the compilation unit (see load_partial_dies).
1514 This problem could be avoided, but the benefit is
1516 if (this_cu
->cu
!= NULL
)
1517 free_one_cached_comp_unit (this_cu
->cu
);
1519 cu
.per_cu
= this_cu
;
1521 /* Note that this is a pointer to our stack frame, being
1522 added to a global data structure. It will be cleaned up
1523 in free_stack_comp_unit when we finish with this
1524 compilation unit. */
1527 this_cu
->psymtab
= pst
;
1529 /* Check if comp unit has_children.
1530 If so, read the rest of the partial symbols from this comp unit.
1531 If not, there's no more debug_info for this comp unit. */
1532 if (comp_unit_die
.has_children
)
1534 struct partial_die_info
*first_die
;
1536 lowpc
= ((CORE_ADDR
) -1);
1537 highpc
= ((CORE_ADDR
) 0);
1539 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1541 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1543 /* If we didn't find a lowpc, set it to highpc to avoid
1544 complaints from `maint check'. */
1545 if (lowpc
== ((CORE_ADDR
) -1))
1548 /* If the compilation unit didn't have an explicit address range,
1549 then use the information extracted from its child dies. */
1550 if (! comp_unit_die
.has_pc_info
)
1552 comp_unit_die
.lowpc
= lowpc
;
1553 comp_unit_die
.highpc
= highpc
;
1556 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1557 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1559 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1560 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1561 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1562 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1563 sort_pst_symbols (pst
);
1565 /* If there is already a psymtab or symtab for a file of this
1566 name, remove it. (If there is a symtab, more drastic things
1567 also happen.) This happens in VxWorks. */
1568 free_named_symtabs (pst
->filename
);
1570 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1571 + cu
.header
.initial_length_size
;
1573 if (comp_unit_die
.has_stmt_list
)
1575 /* Get the list of files included in the current compilation unit,
1576 and build a psymtab for each of them. */
1577 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1580 do_cleanups (back_to_inner
);
1582 do_cleanups (back_to
);
1585 /* Load the DIEs for a secondary CU into memory. */
1588 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1590 bfd
*abfd
= objfile
->obfd
;
1591 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1592 struct partial_die_info comp_unit_die
;
1593 struct dwarf2_cu
*cu
;
1594 struct abbrev_info
*abbrev
;
1595 unsigned int bytes_read
;
1596 struct cleanup
*back_to
;
1598 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1599 beg_of_comp_unit
= info_ptr
;
1601 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1602 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1604 obstack_init (&cu
->comp_unit_obstack
);
1606 cu
->objfile
= objfile
;
1607 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1609 /* Complete the cu_header. */
1610 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1611 cu
->header
.first_die_ptr
= info_ptr
;
1612 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1614 /* Read the abbrevs for this compilation unit into a table. */
1615 dwarf2_read_abbrevs (abfd
, cu
);
1616 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1618 /* Read the compilation unit die. */
1619 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1620 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1621 abfd
, info_ptr
, cu
);
1623 /* Set the language we're debugging. */
1624 set_cu_language (comp_unit_die
.language
, cu
);
1626 /* Link this compilation unit into the compilation unit tree. */
1628 cu
->per_cu
= this_cu
;
1630 /* Check if comp unit has_children.
1631 If so, read the rest of the partial symbols from this comp unit.
1632 If not, there's no more debug_info for this comp unit. */
1633 if (comp_unit_die
.has_children
)
1634 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1636 do_cleanups (back_to
);
1639 /* Create a list of all compilation units in OBJFILE. We do this only
1640 if an inter-comp-unit reference is found; presumably if there is one,
1641 there will be many, and one will occur early in the .debug_info section.
1642 So there's no point in building this list incrementally. */
1645 create_all_comp_units (struct objfile
*objfile
)
1649 struct dwarf2_per_cu_data
**all_comp_units
;
1650 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1654 all_comp_units
= xmalloc (n_allocated
1655 * sizeof (struct dwarf2_per_cu_data
*));
1657 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1659 struct comp_unit_head cu_header
;
1660 gdb_byte
*beg_of_comp_unit
;
1661 struct dwarf2_per_cu_data
*this_cu
;
1662 unsigned long offset
;
1663 unsigned int bytes_read
;
1665 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1667 /* Read just enough information to find out where the next
1668 compilation unit is. */
1669 cu_header
.initial_length_size
= 0;
1670 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1671 &cu_header
, &bytes_read
);
1673 /* Save the compilation unit for later lookup. */
1674 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1675 sizeof (struct dwarf2_per_cu_data
));
1676 memset (this_cu
, 0, sizeof (*this_cu
));
1677 this_cu
->offset
= offset
;
1678 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1680 if (n_comp_units
== n_allocated
)
1683 all_comp_units
= xrealloc (all_comp_units
,
1685 * sizeof (struct dwarf2_per_cu_data
*));
1687 all_comp_units
[n_comp_units
++] = this_cu
;
1689 info_ptr
= info_ptr
+ this_cu
->length
;
1692 dwarf2_per_objfile
->all_comp_units
1693 = obstack_alloc (&objfile
->objfile_obstack
,
1694 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1695 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1696 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1697 xfree (all_comp_units
);
1698 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1701 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1702 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1706 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1707 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1709 struct objfile
*objfile
= cu
->objfile
;
1710 bfd
*abfd
= objfile
->obfd
;
1711 struct partial_die_info
*pdi
;
1713 /* Now, march along the PDI's, descending into ones which have
1714 interesting children but skipping the children of the other ones,
1715 until we reach the end of the compilation unit. */
1721 fixup_partial_die (pdi
, cu
);
1723 /* Anonymous namespaces have no name but have interesting
1724 children, so we need to look at them. Ditto for anonymous
1727 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1728 || pdi
->tag
== DW_TAG_enumeration_type
)
1732 case DW_TAG_subprogram
:
1733 if (pdi
->has_pc_info
)
1735 if (pdi
->lowpc
< *lowpc
)
1737 *lowpc
= pdi
->lowpc
;
1739 if (pdi
->highpc
> *highpc
)
1741 *highpc
= pdi
->highpc
;
1743 if (!pdi
->is_declaration
)
1745 add_partial_symbol (pdi
, cu
);
1749 case DW_TAG_variable
:
1750 case DW_TAG_typedef
:
1751 case DW_TAG_union_type
:
1752 if (!pdi
->is_declaration
)
1754 add_partial_symbol (pdi
, cu
);
1757 case DW_TAG_class_type
:
1758 case DW_TAG_structure_type
:
1759 if (!pdi
->is_declaration
)
1761 add_partial_symbol (pdi
, cu
);
1764 case DW_TAG_enumeration_type
:
1765 if (!pdi
->is_declaration
)
1766 add_partial_enumeration (pdi
, cu
);
1768 case DW_TAG_base_type
:
1769 case DW_TAG_subrange_type
:
1770 /* File scope base type definitions are added to the partial
1772 add_partial_symbol (pdi
, cu
);
1774 case DW_TAG_namespace
:
1775 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1782 /* If the die has a sibling, skip to the sibling. */
1784 pdi
= pdi
->die_sibling
;
1788 /* Functions used to compute the fully scoped name of a partial DIE.
1790 Normally, this is simple. For C++, the parent DIE's fully scoped
1791 name is concatenated with "::" and the partial DIE's name. For
1792 Java, the same thing occurs except that "." is used instead of "::".
1793 Enumerators are an exception; they use the scope of their parent
1794 enumeration type, i.e. the name of the enumeration type is not
1795 prepended to the enumerator.
1797 There are two complexities. One is DW_AT_specification; in this
1798 case "parent" means the parent of the target of the specification,
1799 instead of the direct parent of the DIE. The other is compilers
1800 which do not emit DW_TAG_namespace; in this case we try to guess
1801 the fully qualified name of structure types from their members'
1802 linkage names. This must be done using the DIE's children rather
1803 than the children of any DW_AT_specification target. We only need
1804 to do this for structures at the top level, i.e. if the target of
1805 any DW_AT_specification (if any; otherwise the DIE itself) does not
1808 /* Compute the scope prefix associated with PDI's parent, in
1809 compilation unit CU. The result will be allocated on CU's
1810 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1811 field. NULL is returned if no prefix is necessary. */
1813 partial_die_parent_scope (struct partial_die_info
*pdi
,
1814 struct dwarf2_cu
*cu
)
1816 char *grandparent_scope
;
1817 struct partial_die_info
*parent
, *real_pdi
;
1819 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1820 then this means the parent of the specification DIE. */
1823 while (real_pdi
->has_specification
)
1824 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1826 parent
= real_pdi
->die_parent
;
1830 if (parent
->scope_set
)
1831 return parent
->scope
;
1833 fixup_partial_die (parent
, cu
);
1835 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1837 if (parent
->tag
== DW_TAG_namespace
1838 || parent
->tag
== DW_TAG_structure_type
1839 || parent
->tag
== DW_TAG_class_type
1840 || parent
->tag
== DW_TAG_union_type
)
1842 if (grandparent_scope
== NULL
)
1843 parent
->scope
= parent
->name
;
1845 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1848 else if (parent
->tag
== DW_TAG_enumeration_type
)
1849 /* Enumerators should not get the name of the enumeration as a prefix. */
1850 parent
->scope
= grandparent_scope
;
1853 /* FIXME drow/2004-04-01: What should we be doing with
1854 function-local names? For partial symbols, we should probably be
1856 complaint (&symfile_complaints
,
1857 _("unhandled containing DIE tag %d for DIE at %d"),
1858 parent
->tag
, pdi
->offset
);
1859 parent
->scope
= grandparent_scope
;
1862 parent
->scope_set
= 1;
1863 return parent
->scope
;
1866 /* Return the fully scoped name associated with PDI, from compilation unit
1867 CU. The result will be allocated with malloc. */
1869 partial_die_full_name (struct partial_die_info
*pdi
,
1870 struct dwarf2_cu
*cu
)
1874 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1875 if (parent_scope
== NULL
)
1878 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1882 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1884 struct objfile
*objfile
= cu
->objfile
;
1887 const char *my_prefix
;
1888 const struct partial_symbol
*psym
= NULL
;
1890 int built_actual_name
= 0;
1892 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1896 if (pdi_needs_namespace (pdi
->tag
))
1898 actual_name
= partial_die_full_name (pdi
, cu
);
1900 built_actual_name
= 1;
1903 if (actual_name
== NULL
)
1904 actual_name
= pdi
->name
;
1908 case DW_TAG_subprogram
:
1909 if (pdi
->is_external
)
1911 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1912 mst_text, objfile); */
1913 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1914 VAR_DOMAIN
, LOC_BLOCK
,
1915 &objfile
->global_psymbols
,
1916 0, pdi
->lowpc
+ baseaddr
,
1917 cu
->language
, objfile
);
1921 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1922 mst_file_text, objfile); */
1923 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1924 VAR_DOMAIN
, LOC_BLOCK
,
1925 &objfile
->static_psymbols
,
1926 0, pdi
->lowpc
+ baseaddr
,
1927 cu
->language
, objfile
);
1930 case DW_TAG_variable
:
1931 if (pdi
->is_external
)
1934 Don't enter into the minimal symbol tables as there is
1935 a minimal symbol table entry from the ELF symbols already.
1936 Enter into partial symbol table if it has a location
1937 descriptor or a type.
1938 If the location descriptor is missing, new_symbol will create
1939 a LOC_UNRESOLVED symbol, the address of the variable will then
1940 be determined from the minimal symbol table whenever the variable
1942 The address for the partial symbol table entry is not
1943 used by GDB, but it comes in handy for debugging partial symbol
1947 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1948 if (pdi
->locdesc
|| pdi
->has_type
)
1949 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1950 VAR_DOMAIN
, LOC_STATIC
,
1951 &objfile
->global_psymbols
,
1953 cu
->language
, objfile
);
1957 /* Static Variable. Skip symbols without location descriptors. */
1958 if (pdi
->locdesc
== NULL
)
1960 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1961 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1962 mst_file_data, objfile); */
1963 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1964 VAR_DOMAIN
, LOC_STATIC
,
1965 &objfile
->static_psymbols
,
1967 cu
->language
, objfile
);
1970 case DW_TAG_typedef
:
1971 case DW_TAG_base_type
:
1972 case DW_TAG_subrange_type
:
1973 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1974 VAR_DOMAIN
, LOC_TYPEDEF
,
1975 &objfile
->static_psymbols
,
1976 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1978 case DW_TAG_namespace
:
1979 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1980 VAR_DOMAIN
, LOC_TYPEDEF
,
1981 &objfile
->global_psymbols
,
1982 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1984 case DW_TAG_class_type
:
1985 case DW_TAG_structure_type
:
1986 case DW_TAG_union_type
:
1987 case DW_TAG_enumeration_type
:
1988 /* Skip external references. The DWARF standard says in the section
1989 about "Structure, Union, and Class Type Entries": "An incomplete
1990 structure, union or class type is represented by a structure,
1991 union or class entry that does not have a byte size attribute
1992 and that has a DW_AT_declaration attribute." */
1993 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
1996 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1997 static vs. global. */
1998 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1999 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2000 (cu
->language
== language_cplus
2001 || cu
->language
== language_java
)
2002 ? &objfile
->global_psymbols
2003 : &objfile
->static_psymbols
,
2004 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2006 if (cu
->language
== language_cplus
2007 || cu
->language
== language_java
2008 || cu
->language
== language_ada
)
2010 /* For C++ and Java, these implicitly act as typedefs as well. */
2011 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2012 VAR_DOMAIN
, LOC_TYPEDEF
,
2013 &objfile
->global_psymbols
,
2014 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2017 case DW_TAG_enumerator
:
2018 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2019 VAR_DOMAIN
, LOC_CONST
,
2020 (cu
->language
== language_cplus
2021 || cu
->language
== language_java
)
2022 ? &objfile
->global_psymbols
2023 : &objfile
->static_psymbols
,
2024 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2030 /* Check to see if we should scan the name for possible namespace
2031 info. Only do this if this is C++, if we don't have namespace
2032 debugging info in the file, if the psym is of an appropriate type
2033 (otherwise we'll have psym == NULL), and if we actually had a
2034 mangled name to begin with. */
2036 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2037 cases which do not set PSYM above? */
2039 if (cu
->language
== language_cplus
2040 && cu
->has_namespace_info
== 0
2042 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2043 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2046 if (built_actual_name
)
2047 xfree (actual_name
);
2050 /* Determine whether a die of type TAG living in a C++ class or
2051 namespace needs to have the name of the scope prepended to the
2052 name listed in the die. */
2055 pdi_needs_namespace (enum dwarf_tag tag
)
2059 case DW_TAG_namespace
:
2060 case DW_TAG_typedef
:
2061 case DW_TAG_class_type
:
2062 case DW_TAG_structure_type
:
2063 case DW_TAG_union_type
:
2064 case DW_TAG_enumeration_type
:
2065 case DW_TAG_enumerator
:
2072 /* Read a partial die corresponding to a namespace; also, add a symbol
2073 corresponding to that namespace to the symbol table. NAMESPACE is
2074 the name of the enclosing namespace. */
2077 add_partial_namespace (struct partial_die_info
*pdi
,
2078 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2079 struct dwarf2_cu
*cu
)
2081 struct objfile
*objfile
= cu
->objfile
;
2083 /* Add a symbol for the namespace. */
2085 add_partial_symbol (pdi
, cu
);
2087 /* Now scan partial symbols in that namespace. */
2089 if (pdi
->has_children
)
2090 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2093 /* See if we can figure out if the class lives in a namespace. We do
2094 this by looking for a member function; its demangled name will
2095 contain namespace info, if there is any. */
2098 guess_structure_name (struct partial_die_info
*struct_pdi
,
2099 struct dwarf2_cu
*cu
)
2101 if ((cu
->language
== language_cplus
2102 || cu
->language
== language_java
)
2103 && cu
->has_namespace_info
== 0
2104 && struct_pdi
->has_children
)
2106 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2107 what template types look like, because the demangler
2108 frequently doesn't give the same name as the debug info. We
2109 could fix this by only using the demangled name to get the
2110 prefix (but see comment in read_structure_type). */
2112 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2113 struct partial_die_info
*real_pdi
;
2115 /* If this DIE (this DIE's specification, if any) has a parent, then
2116 we should not do this. We'll prepend the parent's fully qualified
2117 name when we create the partial symbol. */
2119 real_pdi
= struct_pdi
;
2120 while (real_pdi
->has_specification
)
2121 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2123 if (real_pdi
->die_parent
!= NULL
)
2126 while (child_pdi
!= NULL
)
2128 if (child_pdi
->tag
== DW_TAG_subprogram
)
2130 char *actual_class_name
2131 = language_class_name_from_physname (cu
->language_defn
,
2133 if (actual_class_name
!= NULL
)
2136 = obsavestring (actual_class_name
,
2137 strlen (actual_class_name
),
2138 &cu
->comp_unit_obstack
);
2139 xfree (actual_class_name
);
2144 child_pdi
= child_pdi
->die_sibling
;
2149 /* Read a partial die corresponding to an enumeration type. */
2152 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2153 struct dwarf2_cu
*cu
)
2155 struct objfile
*objfile
= cu
->objfile
;
2156 bfd
*abfd
= objfile
->obfd
;
2157 struct partial_die_info
*pdi
;
2159 if (enum_pdi
->name
!= NULL
)
2160 add_partial_symbol (enum_pdi
, cu
);
2162 pdi
= enum_pdi
->die_child
;
2165 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2166 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2168 add_partial_symbol (pdi
, cu
);
2169 pdi
= pdi
->die_sibling
;
2173 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2174 Return the corresponding abbrev, or NULL if the number is zero (indicating
2175 an empty DIE). In either case *BYTES_READ will be set to the length of
2176 the initial number. */
2178 static struct abbrev_info
*
2179 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2180 struct dwarf2_cu
*cu
)
2182 bfd
*abfd
= cu
->objfile
->obfd
;
2183 unsigned int abbrev_number
;
2184 struct abbrev_info
*abbrev
;
2186 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2188 if (abbrev_number
== 0)
2191 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2194 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2195 bfd_get_filename (abfd
));
2201 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2202 pointer to the end of a series of DIEs, terminated by an empty
2203 DIE. Any children of the skipped DIEs will also be skipped. */
2206 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2208 struct abbrev_info
*abbrev
;
2209 unsigned int bytes_read
;
2213 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2215 return info_ptr
+ bytes_read
;
2217 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2221 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2222 should point just after the initial uleb128 of a DIE, and the
2223 abbrev corresponding to that skipped uleb128 should be passed in
2224 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2228 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2229 struct dwarf2_cu
*cu
)
2231 unsigned int bytes_read
;
2232 struct attribute attr
;
2233 bfd
*abfd
= cu
->objfile
->obfd
;
2234 unsigned int form
, i
;
2236 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2238 /* The only abbrev we care about is DW_AT_sibling. */
2239 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2241 read_attribute (&attr
, &abbrev
->attrs
[i
],
2242 abfd
, info_ptr
, cu
);
2243 if (attr
.form
== DW_FORM_ref_addr
)
2244 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2246 return dwarf2_per_objfile
->info_buffer
2247 + dwarf2_get_ref_die_offset (&attr
, cu
);
2250 /* If it isn't DW_AT_sibling, skip this attribute. */
2251 form
= abbrev
->attrs
[i
].form
;
2256 case DW_FORM_ref_addr
:
2257 info_ptr
+= cu
->header
.addr_size
;
2276 case DW_FORM_string
:
2277 read_string (abfd
, info_ptr
, &bytes_read
);
2278 info_ptr
+= bytes_read
;
2281 info_ptr
+= cu
->header
.offset_size
;
2284 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2285 info_ptr
+= bytes_read
;
2287 case DW_FORM_block1
:
2288 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2290 case DW_FORM_block2
:
2291 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2293 case DW_FORM_block4
:
2294 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2298 case DW_FORM_ref_udata
:
2299 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2301 case DW_FORM_indirect
:
2302 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2303 info_ptr
+= bytes_read
;
2304 /* We need to continue parsing from here, so just go back to
2306 goto skip_attribute
;
2309 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2310 dwarf_form_name (form
),
2311 bfd_get_filename (abfd
));
2315 if (abbrev
->has_children
)
2316 return skip_children (info_ptr
, cu
);
2321 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2322 the next DIE after ORIG_PDI. */
2325 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2326 bfd
*abfd
, struct dwarf2_cu
*cu
)
2328 /* Do we know the sibling already? */
2330 if (orig_pdi
->sibling
)
2331 return orig_pdi
->sibling
;
2333 /* Are there any children to deal with? */
2335 if (!orig_pdi
->has_children
)
2338 /* Skip the children the long way. */
2340 return skip_children (info_ptr
, cu
);
2343 /* Expand this partial symbol table into a full symbol table. */
2346 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2348 /* FIXME: This is barely more than a stub. */
2353 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2359 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2360 gdb_flush (gdb_stdout
);
2363 /* Restore our global data. */
2364 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2365 dwarf2_objfile_data_key
);
2367 psymtab_to_symtab_1 (pst
);
2369 /* Finish up the debug error message. */
2371 printf_filtered (_("done.\n"));
2376 /* Add PER_CU to the queue. */
2379 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2381 struct dwarf2_queue_item
*item
;
2384 item
= xmalloc (sizeof (*item
));
2385 item
->per_cu
= per_cu
;
2388 if (dwarf2_queue
== NULL
)
2389 dwarf2_queue
= item
;
2391 dwarf2_queue_tail
->next
= item
;
2393 dwarf2_queue_tail
= item
;
2396 /* Process the queue. */
2399 process_queue (struct objfile
*objfile
)
2401 struct dwarf2_queue_item
*item
, *next_item
;
2403 /* Initially, there is just one item on the queue. Load its DIEs,
2404 and the DIEs of any other compilation units it requires,
2407 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2409 /* Read in this compilation unit. This may add new items to
2410 the end of the queue. */
2411 load_full_comp_unit (item
->per_cu
, objfile
);
2413 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2414 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2416 /* If this compilation unit has already had full symbols created,
2417 reset the TYPE fields in each DIE. */
2418 if (item
->per_cu
->type_hash
)
2419 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2423 /* Now everything left on the queue needs to be read in. Process
2424 them, one at a time, removing from the queue as we finish. */
2425 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2427 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2428 process_full_comp_unit (item
->per_cu
);
2430 item
->per_cu
->queued
= 0;
2431 next_item
= item
->next
;
2435 dwarf2_queue_tail
= NULL
;
2438 /* Free all allocated queue entries. This function only releases anything if
2439 an error was thrown; if the queue was processed then it would have been
2440 freed as we went along. */
2443 dwarf2_release_queue (void *dummy
)
2445 struct dwarf2_queue_item
*item
, *last
;
2447 item
= dwarf2_queue
;
2450 /* Anything still marked queued is likely to be in an
2451 inconsistent state, so discard it. */
2452 if (item
->per_cu
->queued
)
2454 if (item
->per_cu
->cu
!= NULL
)
2455 free_one_cached_comp_unit (item
->per_cu
->cu
);
2456 item
->per_cu
->queued
= 0;
2464 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2467 /* Read in full symbols for PST, and anything it depends on. */
2470 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2472 struct dwarf2_per_cu_data
*per_cu
;
2473 struct cleanup
*back_to
;
2476 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2477 if (!pst
->dependencies
[i
]->readin
)
2479 /* Inform about additional files that need to be read in. */
2482 /* FIXME: i18n: Need to make this a single string. */
2483 fputs_filtered (" ", gdb_stdout
);
2485 fputs_filtered ("and ", gdb_stdout
);
2487 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2488 wrap_here (""); /* Flush output */
2489 gdb_flush (gdb_stdout
);
2491 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2494 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2498 /* It's an include file, no symbols to read for it.
2499 Everything is in the parent symtab. */
2504 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2506 queue_comp_unit (per_cu
);
2508 process_queue (pst
->objfile
);
2510 /* Age the cache, releasing compilation units that have not
2511 been used recently. */
2512 age_cached_comp_units ();
2514 do_cleanups (back_to
);
2517 /* Load the DIEs associated with PST and PER_CU into memory. */
2519 static struct dwarf2_cu
*
2520 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2522 bfd
*abfd
= objfile
->obfd
;
2523 struct dwarf2_cu
*cu
;
2524 unsigned long offset
;
2526 struct cleanup
*back_to
, *free_cu_cleanup
;
2527 struct attribute
*attr
;
2530 /* Set local variables from the partial symbol table info. */
2531 offset
= per_cu
->offset
;
2533 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2535 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2536 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2538 /* If an error occurs while loading, release our storage. */
2539 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2541 cu
->objfile
= objfile
;
2543 /* read in the comp_unit header */
2544 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2546 /* Read the abbrevs for this compilation unit */
2547 dwarf2_read_abbrevs (abfd
, cu
);
2548 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2550 cu
->header
.offset
= offset
;
2552 cu
->per_cu
= per_cu
;
2555 /* We use this obstack for block values in dwarf_alloc_block. */
2556 obstack_init (&cu
->comp_unit_obstack
);
2558 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2560 /* We try not to read any attributes in this function, because not
2561 all objfiles needed for references have been loaded yet, and symbol
2562 table processing isn't initialized. But we have to set the CU language,
2563 or we won't be able to build types correctly. */
2564 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2566 set_cu_language (DW_UNSND (attr
), cu
);
2568 set_cu_language (language_minimal
, cu
);
2570 do_cleanups (back_to
);
2572 /* We've successfully allocated this compilation unit. Let our caller
2573 clean it up when finished with it. */
2574 discard_cleanups (free_cu_cleanup
);
2579 /* Generate full symbol information for PST and CU, whose DIEs have
2580 already been loaded into memory. */
2583 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2585 struct partial_symtab
*pst
= per_cu
->psymtab
;
2586 struct dwarf2_cu
*cu
= per_cu
->cu
;
2587 struct objfile
*objfile
= pst
->objfile
;
2588 bfd
*abfd
= objfile
->obfd
;
2589 CORE_ADDR lowpc
, highpc
;
2590 struct symtab
*symtab
;
2591 struct cleanup
*back_to
;
2592 struct attribute
*attr
;
2595 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2597 /* We're in the global namespace. */
2598 processing_current_prefix
= "";
2601 back_to
= make_cleanup (really_free_pendings
, NULL
);
2603 cu
->list_in_scope
= &file_symbols
;
2605 /* Find the base address of the compilation unit for range lists and
2606 location lists. It will normally be specified by DW_AT_low_pc.
2607 In DWARF-3 draft 4, the base address could be overridden by
2608 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2609 compilation units with discontinuous ranges. */
2611 cu
->header
.base_known
= 0;
2612 cu
->header
.base_address
= 0;
2614 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2617 cu
->header
.base_address
= DW_ADDR (attr
);
2618 cu
->header
.base_known
= 1;
2622 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2625 cu
->header
.base_address
= DW_ADDR (attr
);
2626 cu
->header
.base_known
= 1;
2630 /* Do line number decoding in read_file_scope () */
2631 process_die (cu
->dies
, cu
);
2633 /* Some compilers don't define a DW_AT_high_pc attribute for the
2634 compilation unit. If the DW_AT_high_pc is missing, synthesize
2635 it, by scanning the DIE's below the compilation unit. */
2636 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2638 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2640 /* Set symtab language to language from DW_AT_language.
2641 If the compilation is from a C file generated by language preprocessors,
2642 do not set the language if it was already deduced by start_subfile. */
2644 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2646 symtab
->language
= cu
->language
;
2648 pst
->symtab
= symtab
;
2651 do_cleanups (back_to
);
2654 /* Process a die and its children. */
2657 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2661 case DW_TAG_padding
:
2663 case DW_TAG_compile_unit
:
2664 read_file_scope (die
, cu
);
2666 case DW_TAG_subprogram
:
2667 read_subroutine_type (die
, cu
);
2668 read_func_scope (die
, cu
);
2670 case DW_TAG_inlined_subroutine
:
2671 /* FIXME: These are ignored for now.
2672 They could be used to set breakpoints on all inlined instances
2673 of a function and make GDB `next' properly over inlined functions. */
2675 case DW_TAG_lexical_block
:
2676 case DW_TAG_try_block
:
2677 case DW_TAG_catch_block
:
2678 read_lexical_block_scope (die
, cu
);
2680 case DW_TAG_class_type
:
2681 case DW_TAG_structure_type
:
2682 case DW_TAG_union_type
:
2683 read_structure_type (die
, cu
);
2684 process_structure_scope (die
, cu
);
2686 case DW_TAG_enumeration_type
:
2687 read_enumeration_type (die
, cu
);
2688 process_enumeration_scope (die
, cu
);
2691 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2692 a symbol or process any children. Therefore it doesn't do anything
2693 that won't be done on-demand by read_type_die. */
2694 case DW_TAG_subroutine_type
:
2695 read_subroutine_type (die
, cu
);
2697 case DW_TAG_set_type
:
2698 read_set_type (die
, cu
);
2700 case DW_TAG_array_type
:
2701 read_array_type (die
, cu
);
2703 case DW_TAG_pointer_type
:
2704 read_tag_pointer_type (die
, cu
);
2706 case DW_TAG_ptr_to_member_type
:
2707 read_tag_ptr_to_member_type (die
, cu
);
2709 case DW_TAG_reference_type
:
2710 read_tag_reference_type (die
, cu
);
2712 case DW_TAG_string_type
:
2713 read_tag_string_type (die
, cu
);
2717 case DW_TAG_base_type
:
2718 read_base_type (die
, cu
);
2719 /* Add a typedef symbol for the type definition, if it has a
2721 new_symbol (die
, die
->type
, cu
);
2723 case DW_TAG_subrange_type
:
2724 read_subrange_type (die
, cu
);
2725 /* Add a typedef symbol for the type definition, if it has a
2727 new_symbol (die
, die
->type
, cu
);
2729 case DW_TAG_common_block
:
2730 read_common_block (die
, cu
);
2732 case DW_TAG_common_inclusion
:
2734 case DW_TAG_namespace
:
2735 processing_has_namespace_info
= 1;
2736 read_namespace (die
, cu
);
2738 case DW_TAG_imported_declaration
:
2739 case DW_TAG_imported_module
:
2740 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2741 information contained in these. DW_TAG_imported_declaration
2742 dies shouldn't have children; DW_TAG_imported_module dies
2743 shouldn't in the C++ case, but conceivably could in the
2744 Fortran case, so we'll have to replace this gdb_assert if
2745 Fortran compilers start generating that info. */
2746 processing_has_namespace_info
= 1;
2747 gdb_assert (die
->child
== NULL
);
2750 new_symbol (die
, NULL
, cu
);
2756 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2758 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2762 free_cu_line_header (void *arg
)
2764 struct dwarf2_cu
*cu
= arg
;
2766 free_line_header (cu
->line_header
);
2767 cu
->line_header
= NULL
;
2771 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2773 struct objfile
*objfile
= cu
->objfile
;
2774 struct comp_unit_head
*cu_header
= &cu
->header
;
2775 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2776 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2777 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2778 struct attribute
*attr
;
2779 char *name
= "<unknown>";
2780 char *comp_dir
= NULL
;
2781 struct die_info
*child_die
;
2782 bfd
*abfd
= objfile
->obfd
;
2783 struct line_header
*line_header
= 0;
2786 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2788 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2790 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2791 from finish_block. */
2792 if (lowpc
== ((CORE_ADDR
) -1))
2797 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2800 name
= DW_STRING (attr
);
2802 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2805 comp_dir
= DW_STRING (attr
);
2808 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2809 directory, get rid of it. */
2810 char *cp
= strchr (comp_dir
, ':');
2812 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2817 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2820 set_cu_language (DW_UNSND (attr
), cu
);
2823 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2825 cu
->producer
= DW_STRING (attr
);
2827 /* We assume that we're processing GCC output. */
2828 processing_gcc_compilation
= 2;
2830 /* The compilation unit may be in a different language or objfile,
2831 zero out all remembered fundamental types. */
2832 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2834 start_symtab (name
, comp_dir
, lowpc
);
2835 record_debugformat ("DWARF 2");
2836 record_producer (cu
->producer
);
2838 initialize_cu_func_list (cu
);
2840 /* Decode line number information if present. We do this before
2841 processing child DIEs, so that the line header table is available
2842 for DW_AT_decl_file. */
2843 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2846 unsigned int line_offset
= DW_UNSND (attr
);
2847 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2850 cu
->line_header
= line_header
;
2851 make_cleanup (free_cu_line_header
, cu
);
2852 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2856 /* Process all dies in compilation unit. */
2857 if (die
->child
!= NULL
)
2859 child_die
= die
->child
;
2860 while (child_die
&& child_die
->tag
)
2862 process_die (child_die
, cu
);
2863 child_die
= sibling_die (child_die
);
2867 /* Decode macro information, if present. Dwarf 2 macro information
2868 refers to information in the line number info statement program
2869 header, so we can only read it if we've read the header
2871 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2872 if (attr
&& line_header
)
2874 unsigned int macro_offset
= DW_UNSND (attr
);
2875 dwarf_decode_macros (line_header
, macro_offset
,
2876 comp_dir
, abfd
, cu
);
2878 do_cleanups (back_to
);
2882 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2883 struct dwarf2_cu
*cu
)
2885 struct function_range
*thisfn
;
2887 thisfn
= (struct function_range
*)
2888 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2889 thisfn
->name
= name
;
2890 thisfn
->lowpc
= lowpc
;
2891 thisfn
->highpc
= highpc
;
2892 thisfn
->seen_line
= 0;
2893 thisfn
->next
= NULL
;
2895 if (cu
->last_fn
== NULL
)
2896 cu
->first_fn
= thisfn
;
2898 cu
->last_fn
->next
= thisfn
;
2900 cu
->last_fn
= thisfn
;
2904 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2906 struct objfile
*objfile
= cu
->objfile
;
2907 struct context_stack
*new;
2910 struct die_info
*child_die
;
2911 struct attribute
*attr
;
2913 const char *previous_prefix
= processing_current_prefix
;
2914 struct cleanup
*back_to
= NULL
;
2917 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2919 name
= dwarf2_linkage_name (die
, cu
);
2921 /* Ignore functions with missing or empty names and functions with
2922 missing or invalid low and high pc attributes. */
2923 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2926 if (cu
->language
== language_cplus
2927 || cu
->language
== language_java
)
2929 struct die_info
*spec_die
= die_specification (die
, cu
);
2931 /* NOTE: carlton/2004-01-23: We have to be careful in the
2932 presence of DW_AT_specification. For example, with GCC 3.4,
2937 // Definition of N::foo.
2941 then we'll have a tree of DIEs like this:
2943 1: DW_TAG_compile_unit
2944 2: DW_TAG_namespace // N
2945 3: DW_TAG_subprogram // declaration of N::foo
2946 4: DW_TAG_subprogram // definition of N::foo
2947 DW_AT_specification // refers to die #3
2949 Thus, when processing die #4, we have to pretend that we're
2950 in the context of its DW_AT_specification, namely the contex
2953 if (spec_die
!= NULL
)
2955 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2956 processing_current_prefix
= specification_prefix
;
2957 back_to
= make_cleanup (xfree
, specification_prefix
);
2964 /* Record the function range for dwarf_decode_lines. */
2965 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2967 new = push_context (0, lowpc
);
2968 new->name
= new_symbol (die
, die
->type
, cu
);
2970 /* If there is a location expression for DW_AT_frame_base, record
2972 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2974 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2975 expression is being recorded directly in the function's symbol
2976 and not in a separate frame-base object. I guess this hack is
2977 to avoid adding some sort of frame-base adjunct/annex to the
2978 function's symbol :-(. The problem with doing this is that it
2979 results in a function symbol with a location expression that
2980 has nothing to do with the location of the function, ouch! The
2981 relationship should be: a function's symbol has-a frame base; a
2982 frame-base has-a location expression. */
2983 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2985 cu
->list_in_scope
= &local_symbols
;
2987 if (die
->child
!= NULL
)
2989 child_die
= die
->child
;
2990 while (child_die
&& child_die
->tag
)
2992 process_die (child_die
, cu
);
2993 child_die
= sibling_die (child_die
);
2997 new = pop_context ();
2998 /* Make a block for the local symbols within. */
2999 finish_block (new->name
, &local_symbols
, new->old_blocks
,
3000 lowpc
, highpc
, objfile
);
3002 /* In C++, we can have functions nested inside functions (e.g., when
3003 a function declares a class that has methods). This means that
3004 when we finish processing a function scope, we may need to go
3005 back to building a containing block's symbol lists. */
3006 local_symbols
= new->locals
;
3007 param_symbols
= new->params
;
3009 /* If we've finished processing a top-level function, subsequent
3010 symbols go in the file symbol list. */
3011 if (outermost_context_p ())
3012 cu
->list_in_scope
= &file_symbols
;
3014 processing_current_prefix
= previous_prefix
;
3015 if (back_to
!= NULL
)
3016 do_cleanups (back_to
);
3019 /* Process all the DIES contained within a lexical block scope. Start
3020 a new scope, process the dies, and then close the scope. */
3023 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3025 struct objfile
*objfile
= cu
->objfile
;
3026 struct context_stack
*new;
3027 CORE_ADDR lowpc
, highpc
;
3028 struct die_info
*child_die
;
3031 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3033 /* Ignore blocks with missing or invalid low and high pc attributes. */
3034 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3035 as multiple lexical blocks? Handling children in a sane way would
3036 be nasty. Might be easier to properly extend generic blocks to
3038 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3043 push_context (0, lowpc
);
3044 if (die
->child
!= NULL
)
3046 child_die
= die
->child
;
3047 while (child_die
&& child_die
->tag
)
3049 process_die (child_die
, cu
);
3050 child_die
= sibling_die (child_die
);
3053 new = pop_context ();
3055 if (local_symbols
!= NULL
)
3057 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3060 local_symbols
= new->locals
;
3063 /* Get low and high pc attributes from a die. Return 1 if the attributes
3064 are present and valid, otherwise, return 0. Return -1 if the range is
3065 discontinuous, i.e. derived from DW_AT_ranges information. */
3067 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3068 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3070 struct objfile
*objfile
= cu
->objfile
;
3071 struct comp_unit_head
*cu_header
= &cu
->header
;
3072 struct attribute
*attr
;
3073 bfd
*obfd
= objfile
->obfd
;
3078 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3081 high
= DW_ADDR (attr
);
3082 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3084 low
= DW_ADDR (attr
);
3086 /* Found high w/o low attribute. */
3089 /* Found consecutive range of addresses. */
3094 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3097 unsigned int addr_size
= cu_header
->addr_size
;
3098 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3099 /* Value of the DW_AT_ranges attribute is the offset in the
3100 .debug_ranges section. */
3101 unsigned int offset
= DW_UNSND (attr
);
3102 /* Base address selection entry. */
3110 found_base
= cu_header
->base_known
;
3111 base
= cu_header
->base_address
;
3113 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3115 complaint (&symfile_complaints
,
3116 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3120 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3122 /* Read in the largest possible address. */
3123 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3124 if ((marker
& mask
) == mask
)
3126 /* If we found the largest possible address, then
3127 read the base address. */
3128 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3129 buffer
+= 2 * addr_size
;
3130 offset
+= 2 * addr_size
;
3138 CORE_ADDR range_beginning
, range_end
;
3140 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3141 buffer
+= addr_size
;
3142 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3143 buffer
+= addr_size
;
3144 offset
+= 2 * addr_size
;
3146 /* An end of list marker is a pair of zero addresses. */
3147 if (range_beginning
== 0 && range_end
== 0)
3148 /* Found the end of list entry. */
3151 /* Each base address selection entry is a pair of 2 values.
3152 The first is the largest possible address, the second is
3153 the base address. Check for a base address here. */
3154 if ((range_beginning
& mask
) == mask
)
3156 /* If we found the largest possible address, then
3157 read the base address. */
3158 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3165 /* We have no valid base address for the ranges
3167 complaint (&symfile_complaints
,
3168 _("Invalid .debug_ranges data (no base address)"));
3172 range_beginning
+= base
;
3175 /* FIXME: This is recording everything as a low-high
3176 segment of consecutive addresses. We should have a
3177 data structure for discontiguous block ranges
3181 low
= range_beginning
;
3187 if (range_beginning
< low
)
3188 low
= range_beginning
;
3189 if (range_end
> high
)
3195 /* If the first entry is an end-of-list marker, the range
3196 describes an empty scope, i.e. no instructions. */
3206 /* When using the GNU linker, .gnu.linkonce. sections are used to
3207 eliminate duplicate copies of functions and vtables and such.
3208 The linker will arbitrarily choose one and discard the others.
3209 The AT_*_pc values for such functions refer to local labels in
3210 these sections. If the section from that file was discarded, the
3211 labels are not in the output, so the relocs get a value of 0.
3212 If this is a discarded function, mark the pc bounds as invalid,
3213 so that GDB will ignore it. */
3214 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3222 /* Get the low and high pc's represented by the scope DIE, and store
3223 them in *LOWPC and *HIGHPC. If the correct values can't be
3224 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3227 get_scope_pc_bounds (struct die_info
*die
,
3228 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3229 struct dwarf2_cu
*cu
)
3231 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3232 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3233 CORE_ADDR current_low
, current_high
;
3235 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3237 best_low
= current_low
;
3238 best_high
= current_high
;
3242 struct die_info
*child
= die
->child
;
3244 while (child
&& child
->tag
)
3246 switch (child
->tag
) {
3247 case DW_TAG_subprogram
:
3248 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3250 best_low
= min (best_low
, current_low
);
3251 best_high
= max (best_high
, current_high
);
3254 case DW_TAG_namespace
:
3255 /* FIXME: carlton/2004-01-16: Should we do this for
3256 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3257 that current GCC's always emit the DIEs corresponding
3258 to definitions of methods of classes as children of a
3259 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3260 the DIEs giving the declarations, which could be
3261 anywhere). But I don't see any reason why the
3262 standards says that they have to be there. */
3263 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3265 if (current_low
!= ((CORE_ADDR
) -1))
3267 best_low
= min (best_low
, current_low
);
3268 best_high
= max (best_high
, current_high
);
3276 child
= sibling_die (child
);
3281 *highpc
= best_high
;
3284 /* Add an aggregate field to the field list. */
3287 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3288 struct dwarf2_cu
*cu
)
3290 struct objfile
*objfile
= cu
->objfile
;
3291 struct nextfield
*new_field
;
3292 struct attribute
*attr
;
3294 char *fieldname
= "";
3296 /* Allocate a new field list entry and link it in. */
3297 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3298 make_cleanup (xfree
, new_field
);
3299 memset (new_field
, 0, sizeof (struct nextfield
));
3300 new_field
->next
= fip
->fields
;
3301 fip
->fields
= new_field
;
3304 /* Handle accessibility and virtuality of field.
3305 The default accessibility for members is public, the default
3306 accessibility for inheritance is private. */
3307 if (die
->tag
!= DW_TAG_inheritance
)
3308 new_field
->accessibility
= DW_ACCESS_public
;
3310 new_field
->accessibility
= DW_ACCESS_private
;
3311 new_field
->virtuality
= DW_VIRTUALITY_none
;
3313 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3315 new_field
->accessibility
= DW_UNSND (attr
);
3316 if (new_field
->accessibility
!= DW_ACCESS_public
)
3317 fip
->non_public_fields
= 1;
3318 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3320 new_field
->virtuality
= DW_UNSND (attr
);
3322 fp
= &new_field
->field
;
3324 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3326 /* Data member other than a C++ static data member. */
3328 /* Get type of field. */
3329 fp
->type
= die_type (die
, cu
);
3331 FIELD_STATIC_KIND (*fp
) = 0;
3333 /* Get bit size of field (zero if none). */
3334 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3337 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3341 FIELD_BITSIZE (*fp
) = 0;
3344 /* Get bit offset of field. */
3345 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3348 FIELD_BITPOS (*fp
) =
3349 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3352 FIELD_BITPOS (*fp
) = 0;
3353 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3356 if (BITS_BIG_ENDIAN
)
3358 /* For big endian bits, the DW_AT_bit_offset gives the
3359 additional bit offset from the MSB of the containing
3360 anonymous object to the MSB of the field. We don't
3361 have to do anything special since we don't need to
3362 know the size of the anonymous object. */
3363 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3367 /* For little endian bits, compute the bit offset to the
3368 MSB of the anonymous object, subtract off the number of
3369 bits from the MSB of the field to the MSB of the
3370 object, and then subtract off the number of bits of
3371 the field itself. The result is the bit offset of
3372 the LSB of the field. */
3374 int bit_offset
= DW_UNSND (attr
);
3376 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3379 /* The size of the anonymous object containing
3380 the bit field is explicit, so use the
3381 indicated size (in bytes). */
3382 anonymous_size
= DW_UNSND (attr
);
3386 /* The size of the anonymous object containing
3387 the bit field must be inferred from the type
3388 attribute of the data member containing the
3390 anonymous_size
= TYPE_LENGTH (fp
->type
);
3392 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3393 - bit_offset
- FIELD_BITSIZE (*fp
);
3397 /* Get name of field. */
3398 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3399 if (attr
&& DW_STRING (attr
))
3400 fieldname
= DW_STRING (attr
);
3402 /* The name is already allocated along with this objfile, so we don't
3403 need to duplicate it for the type. */
3404 fp
->name
= fieldname
;
3406 /* Change accessibility for artificial fields (e.g. virtual table
3407 pointer or virtual base class pointer) to private. */
3408 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3410 new_field
->accessibility
= DW_ACCESS_private
;
3411 fip
->non_public_fields
= 1;
3414 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3416 /* C++ static member. */
3418 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3419 is a declaration, but all versions of G++ as of this writing
3420 (so through at least 3.2.1) incorrectly generate
3421 DW_TAG_variable tags. */
3425 /* Get name of field. */
3426 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3427 if (attr
&& DW_STRING (attr
))
3428 fieldname
= DW_STRING (attr
);
3432 /* Get physical name. */
3433 physname
= dwarf2_linkage_name (die
, cu
);
3435 /* The name is already allocated along with this objfile, so we don't
3436 need to duplicate it for the type. */
3437 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3438 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3439 FIELD_NAME (*fp
) = fieldname
;
3441 else if (die
->tag
== DW_TAG_inheritance
)
3443 /* C++ base class field. */
3444 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3446 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3448 FIELD_BITSIZE (*fp
) = 0;
3449 FIELD_STATIC_KIND (*fp
) = 0;
3450 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3451 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3452 fip
->nbaseclasses
++;
3456 /* Create the vector of fields, and attach it to the type. */
3459 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3460 struct dwarf2_cu
*cu
)
3462 int nfields
= fip
->nfields
;
3464 /* Record the field count, allocate space for the array of fields,
3465 and create blank accessibility bitfields if necessary. */
3466 TYPE_NFIELDS (type
) = nfields
;
3467 TYPE_FIELDS (type
) = (struct field
*)
3468 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3469 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3471 if (fip
->non_public_fields
)
3473 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3475 TYPE_FIELD_PRIVATE_BITS (type
) =
3476 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3477 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3479 TYPE_FIELD_PROTECTED_BITS (type
) =
3480 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3481 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3483 TYPE_FIELD_IGNORE_BITS (type
) =
3484 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3485 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3488 /* If the type has baseclasses, allocate and clear a bit vector for
3489 TYPE_FIELD_VIRTUAL_BITS. */
3490 if (fip
->nbaseclasses
)
3492 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3493 unsigned char *pointer
;
3495 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3496 pointer
= TYPE_ALLOC (type
, num_bytes
);
3497 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3498 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3499 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3502 /* Copy the saved-up fields into the field vector. Start from the head
3503 of the list, adding to the tail of the field array, so that they end
3504 up in the same order in the array in which they were added to the list. */
3505 while (nfields
-- > 0)
3507 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3508 switch (fip
->fields
->accessibility
)
3510 case DW_ACCESS_private
:
3511 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3514 case DW_ACCESS_protected
:
3515 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3518 case DW_ACCESS_public
:
3522 /* Unknown accessibility. Complain and treat it as public. */
3524 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3525 fip
->fields
->accessibility
);
3529 if (nfields
< fip
->nbaseclasses
)
3531 switch (fip
->fields
->virtuality
)
3533 case DW_VIRTUALITY_virtual
:
3534 case DW_VIRTUALITY_pure_virtual
:
3535 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3539 fip
->fields
= fip
->fields
->next
;
3543 /* Add a member function to the proper fieldlist. */
3546 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3547 struct type
*type
, struct dwarf2_cu
*cu
)
3549 struct objfile
*objfile
= cu
->objfile
;
3550 struct attribute
*attr
;
3551 struct fnfieldlist
*flp
;
3553 struct fn_field
*fnp
;
3556 struct nextfnfield
*new_fnfield
;
3558 /* Get name of member function. */
3559 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3560 if (attr
&& DW_STRING (attr
))
3561 fieldname
= DW_STRING (attr
);
3565 /* Get the mangled name. */
3566 physname
= dwarf2_linkage_name (die
, cu
);
3568 /* Look up member function name in fieldlist. */
3569 for (i
= 0; i
< fip
->nfnfields
; i
++)
3571 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3575 /* Create new list element if necessary. */
3576 if (i
< fip
->nfnfields
)
3577 flp
= &fip
->fnfieldlists
[i
];
3580 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3582 fip
->fnfieldlists
= (struct fnfieldlist
*)
3583 xrealloc (fip
->fnfieldlists
,
3584 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3585 * sizeof (struct fnfieldlist
));
3586 if (fip
->nfnfields
== 0)
3587 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3589 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3590 flp
->name
= fieldname
;
3596 /* Create a new member function field and chain it to the field list
3598 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3599 make_cleanup (xfree
, new_fnfield
);
3600 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3601 new_fnfield
->next
= flp
->head
;
3602 flp
->head
= new_fnfield
;
3605 /* Fill in the member function field info. */
3606 fnp
= &new_fnfield
->fnfield
;
3607 /* The name is already allocated along with this objfile, so we don't
3608 need to duplicate it for the type. */
3609 fnp
->physname
= physname
? physname
: "";
3610 fnp
->type
= alloc_type (objfile
);
3611 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3613 int nparams
= TYPE_NFIELDS (die
->type
);
3615 /* TYPE is the domain of this method, and DIE->TYPE is the type
3616 of the method itself (TYPE_CODE_METHOD). */
3617 smash_to_method_type (fnp
->type
, type
,
3618 TYPE_TARGET_TYPE (die
->type
),
3619 TYPE_FIELDS (die
->type
),
3620 TYPE_NFIELDS (die
->type
),
3621 TYPE_VARARGS (die
->type
));
3623 /* Handle static member functions.
3624 Dwarf2 has no clean way to discern C++ static and non-static
3625 member functions. G++ helps GDB by marking the first
3626 parameter for non-static member functions (which is the
3627 this pointer) as artificial. We obtain this information
3628 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3629 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3630 fnp
->voffset
= VOFFSET_STATIC
;
3633 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3636 /* Get fcontext from DW_AT_containing_type if present. */
3637 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3638 fnp
->fcontext
= die_containing_type (die
, cu
);
3640 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3641 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3643 /* Get accessibility. */
3644 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3647 switch (DW_UNSND (attr
))
3649 case DW_ACCESS_private
:
3650 fnp
->is_private
= 1;
3652 case DW_ACCESS_protected
:
3653 fnp
->is_protected
= 1;
3658 /* Check for artificial methods. */
3659 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3660 if (attr
&& DW_UNSND (attr
) != 0)
3661 fnp
->is_artificial
= 1;
3663 /* Get index in virtual function table if it is a virtual member function. */
3664 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3667 /* Support the .debug_loc offsets */
3668 if (attr_form_is_block (attr
))
3670 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3672 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3674 dwarf2_complex_location_expr_complaint ();
3678 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3684 /* Create the vector of member function fields, and attach it to the type. */
3687 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3688 struct dwarf2_cu
*cu
)
3690 struct fnfieldlist
*flp
;
3691 int total_length
= 0;
3694 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3695 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3696 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3698 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3700 struct nextfnfield
*nfp
= flp
->head
;
3701 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3704 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3705 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3706 fn_flp
->fn_fields
= (struct fn_field
*)
3707 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3708 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3709 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3711 total_length
+= flp
->length
;
3714 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3715 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3718 /* Returns non-zero if NAME is the name of a vtable member in CU's
3719 language, zero otherwise. */
3721 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3723 static const char vptr
[] = "_vptr";
3724 static const char vtable
[] = "vtable";
3726 /* Look for the C++ and Java forms of the vtable. */
3727 if ((cu
->language
== language_java
3728 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3729 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3730 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3736 /* GCC outputs unnamed structures that are really pointers to member
3737 functions, with the ABI-specified layout. If DIE (from CU) describes
3738 such a structure, set its type, and return nonzero. Otherwise return
3741 GCC shouldn't do this; it should just output pointer to member DIEs.
3742 This is GCC PR debug/28767. */
3745 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3747 struct objfile
*objfile
= cu
->objfile
;
3749 struct die_info
*pfn_die
, *delta_die
;
3750 struct attribute
*pfn_name
, *delta_name
;
3751 struct type
*pfn_type
, *domain_type
;
3753 /* Check for a structure with no name and two children. */
3754 if (die
->tag
!= DW_TAG_structure_type
3755 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3756 || die
->child
== NULL
3757 || die
->child
->sibling
== NULL
3758 || (die
->child
->sibling
->sibling
!= NULL
3759 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3762 /* Check for __pfn and __delta members. */
3763 pfn_die
= die
->child
;
3764 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3765 if (pfn_die
->tag
!= DW_TAG_member
3767 || DW_STRING (pfn_name
) == NULL
3768 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3771 delta_die
= pfn_die
->sibling
;
3772 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3773 if (delta_die
->tag
!= DW_TAG_member
3774 || delta_name
== NULL
3775 || DW_STRING (delta_name
) == NULL
3776 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3779 /* Find the type of the method. */
3780 pfn_type
= die_type (pfn_die
, cu
);
3781 if (pfn_type
== NULL
3782 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3783 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3786 /* Look for the "this" argument. */
3787 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3788 if (TYPE_NFIELDS (pfn_type
) == 0
3789 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3792 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3793 type
= alloc_type (objfile
);
3794 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3795 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3796 TYPE_VARARGS (pfn_type
));
3797 type
= lookup_methodptr_type (type
);
3798 set_die_type (die
, type
, cu
);
3803 /* Called when we find the DIE that starts a structure or union scope
3804 (definition) to process all dies that define the members of the
3807 NOTE: we need to call struct_type regardless of whether or not the
3808 DIE has an at_name attribute, since it might be an anonymous
3809 structure or union. This gets the type entered into our set of
3812 However, if the structure is incomplete (an opaque struct/union)
3813 then suppress creating a symbol table entry for it since gdb only
3814 wants to find the one with the complete definition. Note that if
3815 it is complete, we just call new_symbol, which does it's own
3816 checking about whether the struct/union is anonymous or not (and
3817 suppresses creating a symbol table entry itself). */
3820 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3822 struct objfile
*objfile
= cu
->objfile
;
3824 struct attribute
*attr
;
3825 const char *previous_prefix
= processing_current_prefix
;
3826 struct cleanup
*back_to
= NULL
;
3831 if (quirk_gcc_member_function_pointer (die
, cu
))
3834 type
= alloc_type (objfile
);
3835 INIT_CPLUS_SPECIFIC (type
);
3836 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3837 if (attr
&& DW_STRING (attr
))
3839 if (cu
->language
== language_cplus
3840 || cu
->language
== language_java
)
3842 char *new_prefix
= determine_class_name (die
, cu
);
3843 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3844 strlen (new_prefix
),
3845 &objfile
->objfile_obstack
);
3846 back_to
= make_cleanup (xfree
, new_prefix
);
3847 processing_current_prefix
= new_prefix
;
3851 /* The name is already allocated along with this objfile, so
3852 we don't need to duplicate it for the type. */
3853 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3857 if (die
->tag
== DW_TAG_structure_type
)
3859 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3861 else if (die
->tag
== DW_TAG_union_type
)
3863 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3867 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3869 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3872 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3875 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3879 TYPE_LENGTH (type
) = 0;
3882 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB_SUPPORTED
;
3883 if (die_is_declaration (die
, cu
))
3884 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3886 /* We need to add the type field to the die immediately so we don't
3887 infinitely recurse when dealing with pointers to the structure
3888 type within the structure itself. */
3889 set_die_type (die
, type
, cu
);
3891 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3893 struct field_info fi
;
3894 struct die_info
*child_die
;
3895 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3897 memset (&fi
, 0, sizeof (struct field_info
));
3899 child_die
= die
->child
;
3901 while (child_die
&& child_die
->tag
)
3903 if (child_die
->tag
== DW_TAG_member
3904 || child_die
->tag
== DW_TAG_variable
)
3906 /* NOTE: carlton/2002-11-05: A C++ static data member
3907 should be a DW_TAG_member that is a declaration, but
3908 all versions of G++ as of this writing (so through at
3909 least 3.2.1) incorrectly generate DW_TAG_variable
3910 tags for them instead. */
3911 dwarf2_add_field (&fi
, child_die
, cu
);
3913 else if (child_die
->tag
== DW_TAG_subprogram
)
3915 /* C++ member function. */
3916 read_type_die (child_die
, cu
);
3917 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3919 else if (child_die
->tag
== DW_TAG_inheritance
)
3921 /* C++ base class field. */
3922 dwarf2_add_field (&fi
, child_die
, cu
);
3924 child_die
= sibling_die (child_die
);
3927 /* Attach fields and member functions to the type. */
3929 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3932 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3934 /* Get the type which refers to the base class (possibly this
3935 class itself) which contains the vtable pointer for the current
3936 class from the DW_AT_containing_type attribute. */
3938 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3940 struct type
*t
= die_containing_type (die
, cu
);
3942 TYPE_VPTR_BASETYPE (type
) = t
;
3947 /* Our own class provides vtbl ptr. */
3948 for (i
= TYPE_NFIELDS (t
) - 1;
3949 i
>= TYPE_N_BASECLASSES (t
);
3952 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3954 if (is_vtable_name (fieldname
, cu
))
3956 TYPE_VPTR_FIELDNO (type
) = i
;
3961 /* Complain if virtual function table field not found. */
3962 if (i
< TYPE_N_BASECLASSES (t
))
3963 complaint (&symfile_complaints
,
3964 _("virtual function table pointer not found when defining class '%s'"),
3965 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3970 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3973 else if (cu
->producer
3974 && strncmp (cu
->producer
,
3975 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3977 /* The IBM XLC compiler does not provide direct indication
3978 of the containing type, but the vtable pointer is
3979 always named __vfp. */
3983 for (i
= TYPE_NFIELDS (type
) - 1;
3984 i
>= TYPE_N_BASECLASSES (type
);
3987 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3989 TYPE_VPTR_FIELDNO (type
) = i
;
3990 TYPE_VPTR_BASETYPE (type
) = type
;
3997 do_cleanups (back_to
);
4000 processing_current_prefix
= previous_prefix
;
4001 if (back_to
!= NULL
)
4002 do_cleanups (back_to
);
4006 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4008 struct objfile
*objfile
= cu
->objfile
;
4009 const char *previous_prefix
= processing_current_prefix
;
4010 struct die_info
*child_die
= die
->child
;
4012 if (TYPE_TAG_NAME (die
->type
) != NULL
)
4013 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
4015 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4016 snapshots) has been known to create a die giving a declaration
4017 for a class that has, as a child, a die giving a definition for a
4018 nested class. So we have to process our children even if the
4019 current die is a declaration. Normally, of course, a declaration
4020 won't have any children at all. */
4022 while (child_die
!= NULL
&& child_die
->tag
)
4024 if (child_die
->tag
== DW_TAG_member
4025 || child_die
->tag
== DW_TAG_variable
4026 || child_die
->tag
== DW_TAG_inheritance
)
4031 process_die (child_die
, cu
);
4033 child_die
= sibling_die (child_die
);
4036 /* Do not consider external references. According to the DWARF standard,
4037 these DIEs are identified by the fact that they have no byte_size
4038 attribute, and a declaration attribute. */
4039 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4040 || !die_is_declaration (die
, cu
))
4041 new_symbol (die
, die
->type
, cu
);
4043 processing_current_prefix
= previous_prefix
;
4046 /* Given a DW_AT_enumeration_type die, set its type. We do not
4047 complete the type's fields yet, or create any symbols. */
4050 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4052 struct objfile
*objfile
= cu
->objfile
;
4054 struct attribute
*attr
;
4059 type
= alloc_type (objfile
);
4061 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4062 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4063 if (attr
&& DW_STRING (attr
))
4065 char *name
= DW_STRING (attr
);
4067 if (processing_has_namespace_info
)
4069 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4070 processing_current_prefix
,
4075 /* The name is already allocated along with this objfile, so
4076 we don't need to duplicate it for the type. */
4077 TYPE_TAG_NAME (type
) = name
;
4081 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4084 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4088 TYPE_LENGTH (type
) = 0;
4091 set_die_type (die
, type
, cu
);
4094 /* Determine the name of the type represented by DIE, which should be
4095 a named C++ or Java compound type. Return the name in question; the caller
4096 is responsible for xfree()'ing it. */
4099 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4101 struct cleanup
*back_to
= NULL
;
4102 struct die_info
*spec_die
= die_specification (die
, cu
);
4103 char *new_prefix
= NULL
;
4105 /* If this is the definition of a class that is declared by another
4106 die, then processing_current_prefix may not be accurate; see
4107 read_func_scope for a similar example. */
4108 if (spec_die
!= NULL
)
4110 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4111 processing_current_prefix
= specification_prefix
;
4112 back_to
= make_cleanup (xfree
, specification_prefix
);
4115 /* If we don't have namespace debug info, guess the name by trying
4116 to demangle the names of members, just like we did in
4117 guess_structure_name. */
4118 if (!processing_has_namespace_info
)
4120 struct die_info
*child
;
4122 for (child
= die
->child
;
4123 child
!= NULL
&& child
->tag
!= 0;
4124 child
= sibling_die (child
))
4126 if (child
->tag
== DW_TAG_subprogram
)
4129 = language_class_name_from_physname (cu
->language_defn
,
4133 if (new_prefix
!= NULL
)
4139 if (new_prefix
== NULL
)
4141 const char *name
= dwarf2_name (die
, cu
);
4142 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4143 name
? name
: "<<anonymous>>",
4147 if (back_to
!= NULL
)
4148 do_cleanups (back_to
);
4153 /* Given a pointer to a die which begins an enumeration, process all
4154 the dies that define the members of the enumeration, and create the
4155 symbol for the enumeration type.
4157 NOTE: We reverse the order of the element list. */
4160 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4162 struct objfile
*objfile
= cu
->objfile
;
4163 struct die_info
*child_die
;
4164 struct field
*fields
;
4165 struct attribute
*attr
;
4168 int unsigned_enum
= 1;
4172 if (die
->child
!= NULL
)
4174 child_die
= die
->child
;
4175 while (child_die
&& child_die
->tag
)
4177 if (child_die
->tag
!= DW_TAG_enumerator
)
4179 process_die (child_die
, cu
);
4183 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4186 sym
= new_symbol (child_die
, die
->type
, cu
);
4187 if (SYMBOL_VALUE (sym
) < 0)
4190 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4192 fields
= (struct field
*)
4194 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4195 * sizeof (struct field
));
4198 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4199 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4200 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4201 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4202 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4208 child_die
= sibling_die (child_die
);
4213 TYPE_NFIELDS (die
->type
) = num_fields
;
4214 TYPE_FIELDS (die
->type
) = (struct field
*)
4215 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4216 memcpy (TYPE_FIELDS (die
->type
), fields
,
4217 sizeof (struct field
) * num_fields
);
4221 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4224 new_symbol (die
, die
->type
, cu
);
4227 /* Extract all information from a DW_TAG_array_type DIE and put it in
4228 the DIE's type field. For now, this only handles one dimensional
4232 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4234 struct objfile
*objfile
= cu
->objfile
;
4235 struct die_info
*child_die
;
4236 struct type
*type
= NULL
;
4237 struct type
*element_type
, *range_type
, *index_type
;
4238 struct type
**range_types
= NULL
;
4239 struct attribute
*attr
;
4241 struct cleanup
*back_to
;
4243 /* Return if we've already decoded this type. */
4249 element_type
= die_type (die
, cu
);
4251 /* Irix 6.2 native cc creates array types without children for
4252 arrays with unspecified length. */
4253 if (die
->child
== NULL
)
4255 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4256 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4257 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4262 back_to
= make_cleanup (null_cleanup
, NULL
);
4263 child_die
= die
->child
;
4264 while (child_die
&& child_die
->tag
)
4266 if (child_die
->tag
== DW_TAG_subrange_type
)
4268 read_subrange_type (child_die
, cu
);
4270 if (child_die
->type
!= NULL
)
4272 /* The range type was succesfully read. Save it for
4273 the array type creation. */
4274 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4276 range_types
= (struct type
**)
4277 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4278 * sizeof (struct type
*));
4280 make_cleanup (free_current_contents
, &range_types
);
4282 range_types
[ndim
++] = child_die
->type
;
4285 child_die
= sibling_die (child_die
);
4288 /* Dwarf2 dimensions are output from left to right, create the
4289 necessary array types in backwards order. */
4291 type
= element_type
;
4293 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4297 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4302 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4305 /* Understand Dwarf2 support for vector types (like they occur on
4306 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4307 array type. This is not part of the Dwarf2/3 standard yet, but a
4308 custom vendor extension. The main difference between a regular
4309 array and the vector variant is that vectors are passed by value
4311 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4313 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4315 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4316 if (attr
&& DW_STRING (attr
))
4317 TYPE_NAME (type
) = DW_STRING (attr
);
4319 do_cleanups (back_to
);
4321 /* Install the type in the die. */
4322 set_die_type (die
, type
, cu
);
4325 static enum dwarf_array_dim_ordering
4326 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4328 struct attribute
*attr
;
4330 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4332 if (attr
) return DW_SND (attr
);
4335 GNU F77 is a special case, as at 08/2004 array type info is the
4336 opposite order to the dwarf2 specification, but data is still
4337 laid out as per normal fortran.
4339 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4343 if (cu
->language
== language_fortran
&&
4344 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4346 return DW_ORD_row_major
;
4349 switch (cu
->language_defn
->la_array_ordering
)
4351 case array_column_major
:
4352 return DW_ORD_col_major
;
4353 case array_row_major
:
4355 return DW_ORD_row_major
;
4359 /* Extract all information from a DW_TAG_set_type DIE and put it in
4360 the DIE's type field. */
4363 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4365 if (die
->type
== NULL
)
4366 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4369 /* First cut: install each common block member as a global variable. */
4372 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4374 struct die_info
*child_die
;
4375 struct attribute
*attr
;
4377 CORE_ADDR base
= (CORE_ADDR
) 0;
4379 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4382 /* Support the .debug_loc offsets */
4383 if (attr_form_is_block (attr
))
4385 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4387 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4389 dwarf2_complex_location_expr_complaint ();
4393 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4394 "common block member");
4397 if (die
->child
!= NULL
)
4399 child_die
= die
->child
;
4400 while (child_die
&& child_die
->tag
)
4402 sym
= new_symbol (child_die
, NULL
, cu
);
4403 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4406 SYMBOL_VALUE_ADDRESS (sym
) =
4407 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4408 add_symbol_to_list (sym
, &global_symbols
);
4410 child_die
= sibling_die (child_die
);
4415 /* Read a C++ namespace. */
4418 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4420 struct objfile
*objfile
= cu
->objfile
;
4421 const char *previous_prefix
= processing_current_prefix
;
4424 struct die_info
*current_die
;
4425 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4427 name
= namespace_name (die
, &is_anonymous
, cu
);
4429 /* Now build the name of the current namespace. */
4431 if (previous_prefix
[0] == '\0')
4433 processing_current_prefix
= name
;
4437 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4438 make_cleanup (xfree
, temp_name
);
4439 processing_current_prefix
= temp_name
;
4442 /* Add a symbol associated to this if we haven't seen the namespace
4443 before. Also, add a using directive if it's an anonymous
4446 if (dwarf2_extension (die
, cu
) == NULL
)
4450 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4451 this cast will hopefully become unnecessary. */
4452 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4453 (char *) processing_current_prefix
,
4455 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4457 new_symbol (die
, type
, cu
);
4458 set_die_type (die
, type
, cu
);
4461 cp_add_using_directive (processing_current_prefix
,
4462 strlen (previous_prefix
),
4463 strlen (processing_current_prefix
));
4466 if (die
->child
!= NULL
)
4468 struct die_info
*child_die
= die
->child
;
4470 while (child_die
&& child_die
->tag
)
4472 process_die (child_die
, cu
);
4473 child_die
= sibling_die (child_die
);
4477 processing_current_prefix
= previous_prefix
;
4478 do_cleanups (back_to
);
4481 /* Return the name of the namespace represented by DIE. Set
4482 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4486 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4488 struct die_info
*current_die
;
4489 const char *name
= NULL
;
4491 /* Loop through the extensions until we find a name. */
4493 for (current_die
= die
;
4494 current_die
!= NULL
;
4495 current_die
= dwarf2_extension (die
, cu
))
4497 name
= dwarf2_name (current_die
, cu
);
4502 /* Is it an anonymous namespace? */
4504 *is_anonymous
= (name
== NULL
);
4506 name
= "(anonymous namespace)";
4511 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4512 the user defined type vector. */
4515 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4517 struct comp_unit_head
*cu_header
= &cu
->header
;
4519 struct attribute
*attr_byte_size
;
4520 struct attribute
*attr_address_class
;
4521 int byte_size
, addr_class
;
4528 type
= lookup_pointer_type (die_type (die
, cu
));
4530 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4532 byte_size
= DW_UNSND (attr_byte_size
);
4534 byte_size
= cu_header
->addr_size
;
4536 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4537 if (attr_address_class
)
4538 addr_class
= DW_UNSND (attr_address_class
);
4540 addr_class
= DW_ADDR_none
;
4542 /* If the pointer size or address class is different than the
4543 default, create a type variant marked as such and set the
4544 length accordingly. */
4545 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4547 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4551 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4552 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4553 type
= make_type_with_address_space (type
, type_flags
);
4555 else if (TYPE_LENGTH (type
) != byte_size
)
4557 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4560 /* Should we also complain about unhandled address classes? */
4564 TYPE_LENGTH (type
) = byte_size
;
4565 set_die_type (die
, type
, cu
);
4568 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4569 the user defined type vector. */
4572 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4574 struct objfile
*objfile
= cu
->objfile
;
4576 struct type
*to_type
;
4577 struct type
*domain
;
4584 to_type
= die_type (die
, cu
);
4585 domain
= die_containing_type (die
, cu
);
4587 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4588 type
= lookup_methodptr_type (to_type
);
4590 type
= lookup_memberptr_type (to_type
, domain
);
4592 set_die_type (die
, type
, cu
);
4595 /* Extract all information from a DW_TAG_reference_type DIE and add to
4596 the user defined type vector. */
4599 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4601 struct comp_unit_head
*cu_header
= &cu
->header
;
4603 struct attribute
*attr
;
4610 type
= lookup_reference_type (die_type (die
, cu
));
4611 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4614 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4618 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4620 set_die_type (die
, type
, cu
);
4624 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4626 struct type
*base_type
;
4633 base_type
= die_type (die
, cu
);
4634 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4639 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4641 struct type
*base_type
;
4648 base_type
= die_type (die
, cu
);
4649 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4653 /* Extract all information from a DW_TAG_string_type DIE and add to
4654 the user defined type vector. It isn't really a user defined type,
4655 but it behaves like one, with other DIE's using an AT_user_def_type
4656 attribute to reference it. */
4659 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4661 struct objfile
*objfile
= cu
->objfile
;
4662 struct type
*type
, *range_type
, *index_type
, *char_type
;
4663 struct attribute
*attr
;
4664 unsigned int length
;
4671 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4674 length
= DW_UNSND (attr
);
4678 /* check for the DW_AT_byte_size attribute */
4679 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4682 length
= DW_UNSND (attr
);
4689 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4690 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4691 if (cu
->language
== language_fortran
)
4693 /* Need to create a unique string type for bounds
4695 type
= create_string_type (0, range_type
);
4699 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4700 type
= create_string_type (char_type
, range_type
);
4702 set_die_type (die
, type
, cu
);
4705 /* Handle DIES due to C code like:
4709 int (*funcp)(int a, long l);
4713 ('funcp' generates a DW_TAG_subroutine_type DIE)
4717 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4719 struct type
*type
; /* Type that this function returns */
4720 struct type
*ftype
; /* Function that returns above type */
4721 struct attribute
*attr
;
4723 /* Decode the type that this subroutine returns */
4728 type
= die_type (die
, cu
);
4729 ftype
= make_function_type (type
, (struct type
**) 0);
4731 /* All functions in C++ and Java have prototypes. */
4732 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4733 if ((attr
&& (DW_UNSND (attr
) != 0))
4734 || cu
->language
== language_cplus
4735 || cu
->language
== language_java
)
4736 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4738 if (die
->child
!= NULL
)
4740 struct die_info
*child_die
;
4744 /* Count the number of parameters.
4745 FIXME: GDB currently ignores vararg functions, but knows about
4746 vararg member functions. */
4747 child_die
= die
->child
;
4748 while (child_die
&& child_die
->tag
)
4750 if (child_die
->tag
== DW_TAG_formal_parameter
)
4752 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4753 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4754 child_die
= sibling_die (child_die
);
4757 /* Allocate storage for parameters and fill them in. */
4758 TYPE_NFIELDS (ftype
) = nparams
;
4759 TYPE_FIELDS (ftype
) = (struct field
*)
4760 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4762 child_die
= die
->child
;
4763 while (child_die
&& child_die
->tag
)
4765 if (child_die
->tag
== DW_TAG_formal_parameter
)
4767 /* Dwarf2 has no clean way to discern C++ static and non-static
4768 member functions. G++ helps GDB by marking the first
4769 parameter for non-static member functions (which is the
4770 this pointer) as artificial. We pass this information
4771 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4772 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4774 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4776 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4777 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4780 child_die
= sibling_die (child_die
);
4784 set_die_type (die
, ftype
, cu
);
4788 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4790 struct objfile
*objfile
= cu
->objfile
;
4791 struct attribute
*attr
;
4796 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4797 if (attr
&& DW_STRING (attr
))
4799 name
= DW_STRING (attr
);
4801 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4802 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4804 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4808 /* Find a representation of a given base type and install
4809 it in the TYPE field of the die. */
4812 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4814 struct objfile
*objfile
= cu
->objfile
;
4816 struct attribute
*attr
;
4817 int encoding
= 0, size
= 0;
4819 /* If we've already decoded this die, this is a no-op. */
4825 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4828 encoding
= DW_UNSND (attr
);
4830 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4833 size
= DW_UNSND (attr
);
4835 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4836 if (attr
&& DW_STRING (attr
))
4838 enum type_code code
= TYPE_CODE_INT
;
4843 case DW_ATE_address
:
4844 /* Turn DW_ATE_address into a void * pointer. */
4845 code
= TYPE_CODE_PTR
;
4846 type_flags
|= TYPE_FLAG_UNSIGNED
;
4848 case DW_ATE_boolean
:
4849 code
= TYPE_CODE_BOOL
;
4850 type_flags
|= TYPE_FLAG_UNSIGNED
;
4852 case DW_ATE_complex_float
:
4853 code
= TYPE_CODE_COMPLEX
;
4856 code
= TYPE_CODE_FLT
;
4860 case DW_ATE_unsigned
:
4861 type_flags
|= TYPE_FLAG_UNSIGNED
;
4863 case DW_ATE_signed_char
:
4864 if (cu
->language
== language_m2
)
4865 code
= TYPE_CODE_CHAR
;
4867 case DW_ATE_unsigned_char
:
4868 if (cu
->language
== language_m2
)
4869 code
= TYPE_CODE_CHAR
;
4870 type_flags
|= TYPE_FLAG_UNSIGNED
;
4873 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4874 dwarf_type_encoding_name (encoding
));
4877 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4878 if (encoding
== DW_ATE_address
)
4879 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4881 else if (encoding
== DW_ATE_complex_float
)
4884 TYPE_TARGET_TYPE (type
)
4885 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4886 else if (size
== 16)
4887 TYPE_TARGET_TYPE (type
)
4888 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4890 TYPE_TARGET_TYPE (type
)
4891 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4896 type
= dwarf_base_type (encoding
, size
, cu
);
4898 set_die_type (die
, type
, cu
);
4901 /* Read the given DW_AT_subrange DIE. */
4904 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4906 struct type
*base_type
;
4907 struct type
*range_type
;
4908 struct attribute
*attr
;
4912 /* If we have already decoded this die, then nothing more to do. */
4916 base_type
= die_type (die
, cu
);
4917 if (base_type
== NULL
)
4919 complaint (&symfile_complaints
,
4920 _("DW_AT_type missing from DW_TAG_subrange_type"));
4924 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4925 base_type
= alloc_type (NULL
);
4927 if (cu
->language
== language_fortran
)
4929 /* FORTRAN implies a lower bound of 1, if not given. */
4933 /* FIXME: For variable sized arrays either of these could be
4934 a variable rather than a constant value. We'll allow it,
4935 but we don't know how to handle it. */
4936 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4938 low
= dwarf2_get_attr_constant_value (attr
, 0);
4940 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4943 if (attr
->form
== DW_FORM_block1
)
4945 /* GCC encodes arrays with unspecified or dynamic length
4946 with a DW_FORM_block1 attribute.
4947 FIXME: GDB does not yet know how to handle dynamic
4948 arrays properly, treat them as arrays with unspecified
4951 FIXME: jimb/2003-09-22: GDB does not really know
4952 how to handle arrays of unspecified length
4953 either; we just represent them as zero-length
4954 arrays. Choose an appropriate upper bound given
4955 the lower bound we've computed above. */
4959 high
= dwarf2_get_attr_constant_value (attr
, 1);
4962 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4964 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4965 if (attr
&& DW_STRING (attr
))
4966 TYPE_NAME (range_type
) = DW_STRING (attr
);
4968 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4970 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4972 set_die_type (die
, range_type
, cu
);
4976 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4979 struct attribute
*attr
;
4984 /* For now, we only support the C meaning of an unspecified type: void. */
4986 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4987 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4990 set_die_type (die
, type
, cu
);
4993 /* Read a whole compilation unit into a linked list of dies. */
4995 static struct die_info
*
4996 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4998 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
5001 /* Read a single die and all its descendents. Set the die's sibling
5002 field to NULL; set other fields in the die correctly, and set all
5003 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5004 location of the info_ptr after reading all of those dies. PARENT
5005 is the parent of the die in question. */
5007 static struct die_info
*
5008 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5009 struct dwarf2_cu
*cu
,
5010 gdb_byte
**new_info_ptr
,
5011 struct die_info
*parent
)
5013 struct die_info
*die
;
5017 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5018 store_in_ref_table (die
->offset
, die
, cu
);
5022 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5028 *new_info_ptr
= cur_ptr
;
5031 die
->sibling
= NULL
;
5032 die
->parent
= parent
;
5036 /* Read a die, all of its descendents, and all of its siblings; set
5037 all of the fields of all of the dies correctly. Arguments are as
5038 in read_die_and_children. */
5040 static struct die_info
*
5041 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5042 struct dwarf2_cu
*cu
,
5043 gdb_byte
**new_info_ptr
,
5044 struct die_info
*parent
)
5046 struct die_info
*first_die
, *last_sibling
;
5050 first_die
= last_sibling
= NULL
;
5054 struct die_info
*die
5055 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5063 last_sibling
->sibling
= die
;
5068 *new_info_ptr
= cur_ptr
;
5078 /* Free a linked list of dies. */
5081 free_die_list (struct die_info
*dies
)
5083 struct die_info
*die
, *next
;
5088 if (die
->child
!= NULL
)
5089 free_die_list (die
->child
);
5090 next
= die
->sibling
;
5097 /* Read the contents of the section at OFFSET and of size SIZE from the
5098 object file specified by OBJFILE into the objfile_obstack and return it. */
5101 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5103 bfd
*abfd
= objfile
->obfd
;
5104 gdb_byte
*buf
, *retbuf
;
5105 bfd_size_type size
= bfd_get_section_size (sectp
);
5110 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5111 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5115 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5116 || bfd_bread (buf
, size
, abfd
) != size
)
5117 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5118 bfd_get_filename (abfd
));
5123 /* In DWARF version 2, the description of the debugging information is
5124 stored in a separate .debug_abbrev section. Before we read any
5125 dies from a section we read in all abbreviations and install them
5126 in a hash table. This function also sets flags in CU describing
5127 the data found in the abbrev table. */
5130 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5132 struct comp_unit_head
*cu_header
= &cu
->header
;
5133 gdb_byte
*abbrev_ptr
;
5134 struct abbrev_info
*cur_abbrev
;
5135 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5136 unsigned int abbrev_form
, hash_number
;
5137 struct attr_abbrev
*cur_attrs
;
5138 unsigned int allocated_attrs
;
5140 /* Initialize dwarf2 abbrevs */
5141 obstack_init (&cu
->abbrev_obstack
);
5142 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5144 * sizeof (struct abbrev_info
*)));
5145 memset (cu
->dwarf2_abbrevs
, 0,
5146 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5148 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5149 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5150 abbrev_ptr
+= bytes_read
;
5152 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5153 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5155 /* loop until we reach an abbrev number of 0 */
5156 while (abbrev_number
)
5158 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5160 /* read in abbrev header */
5161 cur_abbrev
->number
= abbrev_number
;
5162 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5163 abbrev_ptr
+= bytes_read
;
5164 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5167 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5168 cu
->has_namespace_info
= 1;
5170 /* now read in declarations */
5171 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5172 abbrev_ptr
+= bytes_read
;
5173 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5174 abbrev_ptr
+= bytes_read
;
5177 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5179 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5181 = xrealloc (cur_attrs
, (allocated_attrs
5182 * sizeof (struct attr_abbrev
)));
5185 /* Record whether this compilation unit might have
5186 inter-compilation-unit references. If we don't know what form
5187 this attribute will have, then it might potentially be a
5188 DW_FORM_ref_addr, so we conservatively expect inter-CU
5191 if (abbrev_form
== DW_FORM_ref_addr
5192 || abbrev_form
== DW_FORM_indirect
)
5193 cu
->has_form_ref_addr
= 1;
5195 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5196 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5197 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5198 abbrev_ptr
+= bytes_read
;
5199 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5200 abbrev_ptr
+= bytes_read
;
5203 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5204 (cur_abbrev
->num_attrs
5205 * sizeof (struct attr_abbrev
)));
5206 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5207 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5209 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5210 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5211 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5213 /* Get next abbreviation.
5214 Under Irix6 the abbreviations for a compilation unit are not
5215 always properly terminated with an abbrev number of 0.
5216 Exit loop if we encounter an abbreviation which we have
5217 already read (which means we are about to read the abbreviations
5218 for the next compile unit) or if the end of the abbreviation
5219 table is reached. */
5220 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5221 >= dwarf2_per_objfile
->abbrev_size
)
5223 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5224 abbrev_ptr
+= bytes_read
;
5225 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5232 /* Release the memory used by the abbrev table for a compilation unit. */
5235 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5237 struct dwarf2_cu
*cu
= ptr_to_cu
;
5239 obstack_free (&cu
->abbrev_obstack
, NULL
);
5240 cu
->dwarf2_abbrevs
= NULL
;
5243 /* Lookup an abbrev_info structure in the abbrev hash table. */
5245 static struct abbrev_info
*
5246 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5248 unsigned int hash_number
;
5249 struct abbrev_info
*abbrev
;
5251 hash_number
= number
% ABBREV_HASH_SIZE
;
5252 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5256 if (abbrev
->number
== number
)
5259 abbrev
= abbrev
->next
;
5264 /* Returns nonzero if TAG represents a type that we might generate a partial
5268 is_type_tag_for_partial (int tag
)
5273 /* Some types that would be reasonable to generate partial symbols for,
5274 that we don't at present. */
5275 case DW_TAG_array_type
:
5276 case DW_TAG_file_type
:
5277 case DW_TAG_ptr_to_member_type
:
5278 case DW_TAG_set_type
:
5279 case DW_TAG_string_type
:
5280 case DW_TAG_subroutine_type
:
5282 case DW_TAG_base_type
:
5283 case DW_TAG_class_type
:
5284 case DW_TAG_enumeration_type
:
5285 case DW_TAG_structure_type
:
5286 case DW_TAG_subrange_type
:
5287 case DW_TAG_typedef
:
5288 case DW_TAG_union_type
:
5295 /* Load all DIEs that are interesting for partial symbols into memory. */
5297 static struct partial_die_info
*
5298 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5299 struct dwarf2_cu
*cu
)
5301 struct partial_die_info
*part_die
;
5302 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5303 struct abbrev_info
*abbrev
;
5304 unsigned int bytes_read
;
5305 unsigned int load_all
= 0;
5307 int nesting_level
= 1;
5312 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5316 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5320 &cu
->comp_unit_obstack
,
5321 hashtab_obstack_allocate
,
5322 dummy_obstack_deallocate
);
5324 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5325 sizeof (struct partial_die_info
));
5329 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5331 /* A NULL abbrev means the end of a series of children. */
5334 if (--nesting_level
== 0)
5336 /* PART_DIE was probably the last thing allocated on the
5337 comp_unit_obstack, so we could call obstack_free
5338 here. We don't do that because the waste is small,
5339 and will be cleaned up when we're done with this
5340 compilation unit. This way, we're also more robust
5341 against other users of the comp_unit_obstack. */
5344 info_ptr
+= bytes_read
;
5345 last_die
= parent_die
;
5346 parent_die
= parent_die
->die_parent
;
5350 /* Check whether this DIE is interesting enough to save. Normally
5351 we would not be interested in members here, but there may be
5352 later variables referencing them via DW_AT_specification (for
5355 && !is_type_tag_for_partial (abbrev
->tag
)
5356 && abbrev
->tag
!= DW_TAG_enumerator
5357 && abbrev
->tag
!= DW_TAG_subprogram
5358 && abbrev
->tag
!= DW_TAG_variable
5359 && abbrev
->tag
!= DW_TAG_namespace
5360 && abbrev
->tag
!= DW_TAG_member
)
5362 /* Otherwise we skip to the next sibling, if any. */
5363 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5367 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5368 abfd
, info_ptr
, cu
);
5370 /* This two-pass algorithm for processing partial symbols has a
5371 high cost in cache pressure. Thus, handle some simple cases
5372 here which cover the majority of C partial symbols. DIEs
5373 which neither have specification tags in them, nor could have
5374 specification tags elsewhere pointing at them, can simply be
5375 processed and discarded.
5377 This segment is also optional; scan_partial_symbols and
5378 add_partial_symbol will handle these DIEs if we chain
5379 them in normally. When compilers which do not emit large
5380 quantities of duplicate debug information are more common,
5381 this code can probably be removed. */
5383 /* Any complete simple types at the top level (pretty much all
5384 of them, for a language without namespaces), can be processed
5386 if (parent_die
== NULL
5387 && part_die
->has_specification
== 0
5388 && part_die
->is_declaration
== 0
5389 && (part_die
->tag
== DW_TAG_typedef
5390 || part_die
->tag
== DW_TAG_base_type
5391 || part_die
->tag
== DW_TAG_subrange_type
))
5393 if (building_psymtab
&& part_die
->name
!= NULL
)
5394 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5395 VAR_DOMAIN
, LOC_TYPEDEF
,
5396 &cu
->objfile
->static_psymbols
,
5397 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5398 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5402 /* If we're at the second level, and we're an enumerator, and
5403 our parent has no specification (meaning possibly lives in a
5404 namespace elsewhere), then we can add the partial symbol now
5405 instead of queueing it. */
5406 if (part_die
->tag
== DW_TAG_enumerator
5407 && parent_die
!= NULL
5408 && parent_die
->die_parent
== NULL
5409 && parent_die
->tag
== DW_TAG_enumeration_type
5410 && parent_die
->has_specification
== 0)
5412 if (part_die
->name
== NULL
)
5413 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5414 else if (building_psymtab
)
5415 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5416 VAR_DOMAIN
, LOC_CONST
,
5417 (cu
->language
== language_cplus
5418 || cu
->language
== language_java
)
5419 ? &cu
->objfile
->global_psymbols
5420 : &cu
->objfile
->static_psymbols
,
5421 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5423 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5427 /* We'll save this DIE so link it in. */
5428 part_die
->die_parent
= parent_die
;
5429 part_die
->die_sibling
= NULL
;
5430 part_die
->die_child
= NULL
;
5432 if (last_die
&& last_die
== parent_die
)
5433 last_die
->die_child
= part_die
;
5435 last_die
->die_sibling
= part_die
;
5437 last_die
= part_die
;
5439 if (first_die
== NULL
)
5440 first_die
= part_die
;
5442 /* Maybe add the DIE to the hash table. Not all DIEs that we
5443 find interesting need to be in the hash table, because we
5444 also have the parent/sibling/child chains; only those that we
5445 might refer to by offset later during partial symbol reading.
5447 For now this means things that might have be the target of a
5448 DW_AT_specification, DW_AT_abstract_origin, or
5449 DW_AT_extension. DW_AT_extension will refer only to
5450 namespaces; DW_AT_abstract_origin refers to functions (and
5451 many things under the function DIE, but we do not recurse
5452 into function DIEs during partial symbol reading) and
5453 possibly variables as well; DW_AT_specification refers to
5454 declarations. Declarations ought to have the DW_AT_declaration
5455 flag. It happens that GCC forgets to put it in sometimes, but
5456 only for functions, not for types.
5458 Adding more things than necessary to the hash table is harmless
5459 except for the performance cost. Adding too few will result in
5460 wasted time in find_partial_die, when we reread the compilation
5461 unit with load_all_dies set. */
5464 || abbrev
->tag
== DW_TAG_subprogram
5465 || abbrev
->tag
== DW_TAG_variable
5466 || abbrev
->tag
== DW_TAG_namespace
5467 || part_die
->is_declaration
)
5471 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5472 part_die
->offset
, INSERT
);
5476 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5477 sizeof (struct partial_die_info
));
5479 /* For some DIEs we want to follow their children (if any). For C
5480 we have no reason to follow the children of structures; for other
5481 languages we have to, both so that we can get at method physnames
5482 to infer fully qualified class names, and for DW_AT_specification. */
5483 if (last_die
->has_children
5485 || last_die
->tag
== DW_TAG_namespace
5486 || last_die
->tag
== DW_TAG_enumeration_type
5487 || (cu
->language
!= language_c
5488 && (last_die
->tag
== DW_TAG_class_type
5489 || last_die
->tag
== DW_TAG_structure_type
5490 || last_die
->tag
== DW_TAG_union_type
))))
5493 parent_die
= last_die
;
5497 /* Otherwise we skip to the next sibling, if any. */
5498 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5500 /* Back to the top, do it again. */
5504 /* Read a minimal amount of information into the minimal die structure. */
5507 read_partial_die (struct partial_die_info
*part_die
,
5508 struct abbrev_info
*abbrev
,
5509 unsigned int abbrev_len
, bfd
*abfd
,
5510 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5512 unsigned int bytes_read
, i
;
5513 struct attribute attr
;
5514 int has_low_pc_attr
= 0;
5515 int has_high_pc_attr
= 0;
5517 memset (part_die
, 0, sizeof (struct partial_die_info
));
5519 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5521 info_ptr
+= abbrev_len
;
5526 part_die
->tag
= abbrev
->tag
;
5527 part_die
->has_children
= abbrev
->has_children
;
5529 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5531 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5533 /* Store the data if it is of an attribute we want to keep in a
5534 partial symbol table. */
5539 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5540 if (part_die
->name
== NULL
)
5541 part_die
->name
= DW_STRING (&attr
);
5543 case DW_AT_comp_dir
:
5544 if (part_die
->dirname
== NULL
)
5545 part_die
->dirname
= DW_STRING (&attr
);
5547 case DW_AT_MIPS_linkage_name
:
5548 part_die
->name
= DW_STRING (&attr
);
5551 has_low_pc_attr
= 1;
5552 part_die
->lowpc
= DW_ADDR (&attr
);
5555 has_high_pc_attr
= 1;
5556 part_die
->highpc
= DW_ADDR (&attr
);
5558 case DW_AT_location
:
5559 /* Support the .debug_loc offsets */
5560 if (attr_form_is_block (&attr
))
5562 part_die
->locdesc
= DW_BLOCK (&attr
);
5564 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5566 dwarf2_complex_location_expr_complaint ();
5570 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5571 "partial symbol information");
5574 case DW_AT_language
:
5575 part_die
->language
= DW_UNSND (&attr
);
5577 case DW_AT_external
:
5578 part_die
->is_external
= DW_UNSND (&attr
);
5580 case DW_AT_declaration
:
5581 part_die
->is_declaration
= DW_UNSND (&attr
);
5584 part_die
->has_type
= 1;
5586 case DW_AT_abstract_origin
:
5587 case DW_AT_specification
:
5588 case DW_AT_extension
:
5589 part_die
->has_specification
= 1;
5590 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5593 /* Ignore absolute siblings, they might point outside of
5594 the current compile unit. */
5595 if (attr
.form
== DW_FORM_ref_addr
)
5596 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5598 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5599 + dwarf2_get_ref_die_offset (&attr
, cu
);
5601 case DW_AT_stmt_list
:
5602 part_die
->has_stmt_list
= 1;
5603 part_die
->line_offset
= DW_UNSND (&attr
);
5605 case DW_AT_byte_size
:
5606 part_die
->has_byte_size
= 1;
5613 /* When using the GNU linker, .gnu.linkonce. sections are used to
5614 eliminate duplicate copies of functions and vtables and such.
5615 The linker will arbitrarily choose one and discard the others.
5616 The AT_*_pc values for such functions refer to local labels in
5617 these sections. If the section from that file was discarded, the
5618 labels are not in the output, so the relocs get a value of 0.
5619 If this is a discarded function, mark the pc bounds as invalid,
5620 so that GDB will ignore it. */
5621 if (has_low_pc_attr
&& has_high_pc_attr
5622 && part_die
->lowpc
< part_die
->highpc
5623 && (part_die
->lowpc
!= 0
5624 || dwarf2_per_objfile
->has_section_at_zero
))
5625 part_die
->has_pc_info
= 1;
5629 /* Find a cached partial DIE at OFFSET in CU. */
5631 static struct partial_die_info
*
5632 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5634 struct partial_die_info
*lookup_die
= NULL
;
5635 struct partial_die_info part_die
;
5637 part_die
.offset
= offset
;
5638 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5643 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5645 static struct partial_die_info
*
5646 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5648 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5649 struct partial_die_info
*pd
= NULL
;
5651 if (offset
>= cu
->header
.offset
5652 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5654 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5659 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5661 if (per_cu
->cu
== NULL
)
5663 load_comp_unit (per_cu
, cu
->objfile
);
5664 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5665 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5668 per_cu
->cu
->last_used
= 0;
5669 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5671 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5673 struct cleanup
*back_to
;
5674 struct partial_die_info comp_unit_die
;
5675 struct abbrev_info
*abbrev
;
5676 unsigned int bytes_read
;
5679 per_cu
->load_all_dies
= 1;
5681 /* Re-read the DIEs. */
5682 back_to
= make_cleanup (null_cleanup
, 0);
5683 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5685 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5686 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5688 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5689 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5690 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5691 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5693 if (comp_unit_die
.has_children
)
5694 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5695 do_cleanups (back_to
);
5697 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5701 internal_error (__FILE__
, __LINE__
,
5702 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5703 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5707 /* Adjust PART_DIE before generating a symbol for it. This function
5708 may set the is_external flag or change the DIE's name. */
5711 fixup_partial_die (struct partial_die_info
*part_die
,
5712 struct dwarf2_cu
*cu
)
5714 /* If we found a reference attribute and the DIE has no name, try
5715 to find a name in the referred to DIE. */
5717 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5719 struct partial_die_info
*spec_die
;
5721 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5723 fixup_partial_die (spec_die
, cu
);
5727 part_die
->name
= spec_die
->name
;
5729 /* Copy DW_AT_external attribute if it is set. */
5730 if (spec_die
->is_external
)
5731 part_die
->is_external
= spec_die
->is_external
;
5735 /* Set default names for some unnamed DIEs. */
5736 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5737 || part_die
->tag
== DW_TAG_class_type
))
5738 part_die
->name
= "(anonymous class)";
5740 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5741 part_die
->name
= "(anonymous namespace)";
5743 if (part_die
->tag
== DW_TAG_structure_type
5744 || part_die
->tag
== DW_TAG_class_type
5745 || part_die
->tag
== DW_TAG_union_type
)
5746 guess_structure_name (part_die
, cu
);
5749 /* Read the die from the .debug_info section buffer. Set DIEP to
5750 point to a newly allocated die with its information, except for its
5751 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5752 whether the die has children or not. */
5755 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5756 struct dwarf2_cu
*cu
, int *has_children
)
5758 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5759 struct abbrev_info
*abbrev
;
5760 struct die_info
*die
;
5762 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5763 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5764 info_ptr
+= bytes_read
;
5767 die
= dwarf_alloc_die ();
5769 die
->abbrev
= abbrev_number
;
5776 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5779 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5781 bfd_get_filename (abfd
));
5783 die
= dwarf_alloc_die ();
5784 die
->offset
= offset
;
5785 die
->tag
= abbrev
->tag
;
5786 die
->abbrev
= abbrev_number
;
5789 die
->num_attrs
= abbrev
->num_attrs
;
5790 die
->attrs
= (struct attribute
*)
5791 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5793 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5795 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5796 abfd
, info_ptr
, cu
);
5798 /* If this attribute is an absolute reference to a different
5799 compilation unit, make sure that compilation unit is loaded
5801 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5802 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5803 || (DW_ADDR (&die
->attrs
[i
])
5804 >= cu
->header
.offset
+ cu
->header
.length
)))
5806 struct dwarf2_per_cu_data
*per_cu
;
5807 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5810 /* Mark the dependence relation so that we don't flush PER_CU
5812 dwarf2_add_dependence (cu
, per_cu
);
5814 /* If it's already on the queue, we have nothing to do. */
5818 /* If the compilation unit is already loaded, just mark it as
5820 if (per_cu
->cu
!= NULL
)
5822 per_cu
->cu
->last_used
= 0;
5826 /* Add it to the queue. */
5827 queue_comp_unit (per_cu
);
5832 *has_children
= abbrev
->has_children
;
5836 /* Read an attribute value described by an attribute form. */
5839 read_attribute_value (struct attribute
*attr
, unsigned form
,
5840 bfd
*abfd
, gdb_byte
*info_ptr
,
5841 struct dwarf2_cu
*cu
)
5843 struct comp_unit_head
*cu_header
= &cu
->header
;
5844 unsigned int bytes_read
;
5845 struct dwarf_block
*blk
;
5851 case DW_FORM_ref_addr
:
5852 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5853 info_ptr
+= bytes_read
;
5855 case DW_FORM_block2
:
5856 blk
= dwarf_alloc_block (cu
);
5857 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5859 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5860 info_ptr
+= blk
->size
;
5861 DW_BLOCK (attr
) = blk
;
5863 case DW_FORM_block4
:
5864 blk
= dwarf_alloc_block (cu
);
5865 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5867 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5868 info_ptr
+= blk
->size
;
5869 DW_BLOCK (attr
) = blk
;
5872 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5876 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5880 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5883 case DW_FORM_string
:
5884 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5885 info_ptr
+= bytes_read
;
5888 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5890 info_ptr
+= bytes_read
;
5893 blk
= dwarf_alloc_block (cu
);
5894 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5895 info_ptr
+= bytes_read
;
5896 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5897 info_ptr
+= blk
->size
;
5898 DW_BLOCK (attr
) = blk
;
5900 case DW_FORM_block1
:
5901 blk
= dwarf_alloc_block (cu
);
5902 blk
->size
= read_1_byte (abfd
, info_ptr
);
5904 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5905 info_ptr
+= blk
->size
;
5906 DW_BLOCK (attr
) = blk
;
5909 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5913 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5917 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5918 info_ptr
+= bytes_read
;
5921 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5922 info_ptr
+= bytes_read
;
5925 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5929 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5933 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5937 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5940 case DW_FORM_ref_udata
:
5941 DW_ADDR (attr
) = (cu
->header
.offset
5942 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5943 info_ptr
+= bytes_read
;
5945 case DW_FORM_indirect
:
5946 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5947 info_ptr
+= bytes_read
;
5948 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5951 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5952 dwarf_form_name (form
),
5953 bfd_get_filename (abfd
));
5958 /* Read an attribute described by an abbreviated attribute. */
5961 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5962 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5964 attr
->name
= abbrev
->name
;
5965 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5968 /* read dwarf information from a buffer */
5971 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5973 return bfd_get_8 (abfd
, buf
);
5977 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5979 return bfd_get_signed_8 (abfd
, buf
);
5983 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5985 return bfd_get_16 (abfd
, buf
);
5989 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5991 return bfd_get_signed_16 (abfd
, buf
);
5995 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5997 return bfd_get_32 (abfd
, buf
);
6001 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6003 return bfd_get_signed_32 (abfd
, buf
);
6006 static unsigned long
6007 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6009 return bfd_get_64 (abfd
, buf
);
6013 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6014 unsigned int *bytes_read
)
6016 struct comp_unit_head
*cu_header
= &cu
->header
;
6017 CORE_ADDR retval
= 0;
6019 if (cu_header
->signed_addr_p
)
6021 switch (cu_header
->addr_size
)
6024 retval
= bfd_get_signed_16 (abfd
, buf
);
6027 retval
= bfd_get_signed_32 (abfd
, buf
);
6030 retval
= bfd_get_signed_64 (abfd
, buf
);
6033 internal_error (__FILE__
, __LINE__
,
6034 _("read_address: bad switch, signed [in module %s]"),
6035 bfd_get_filename (abfd
));
6040 switch (cu_header
->addr_size
)
6043 retval
= bfd_get_16 (abfd
, buf
);
6046 retval
= bfd_get_32 (abfd
, buf
);
6049 retval
= bfd_get_64 (abfd
, buf
);
6052 internal_error (__FILE__
, __LINE__
,
6053 _("read_address: bad switch, unsigned [in module %s]"),
6054 bfd_get_filename (abfd
));
6058 *bytes_read
= cu_header
->addr_size
;
6062 /* Read the initial length from a section. The (draft) DWARF 3
6063 specification allows the initial length to take up either 4 bytes
6064 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6065 bytes describe the length and all offsets will be 8 bytes in length
6068 An older, non-standard 64-bit format is also handled by this
6069 function. The older format in question stores the initial length
6070 as an 8-byte quantity without an escape value. Lengths greater
6071 than 2^32 aren't very common which means that the initial 4 bytes
6072 is almost always zero. Since a length value of zero doesn't make
6073 sense for the 32-bit format, this initial zero can be considered to
6074 be an escape value which indicates the presence of the older 64-bit
6075 format. As written, the code can't detect (old format) lengths
6076 greater than 4GB. If it becomes necessary to handle lengths
6077 somewhat larger than 4GB, we could allow other small values (such
6078 as the non-sensical values of 1, 2, and 3) to also be used as
6079 escape values indicating the presence of the old format.
6081 The value returned via bytes_read should be used to increment the
6082 relevant pointer after calling read_initial_length().
6084 As a side effect, this function sets the fields initial_length_size
6085 and offset_size in cu_header to the values appropriate for the
6086 length field. (The format of the initial length field determines
6087 the width of file offsets to be fetched later with read_offset().)
6089 [ Note: read_initial_length() and read_offset() are based on the
6090 document entitled "DWARF Debugging Information Format", revision
6091 3, draft 8, dated November 19, 2001. This document was obtained
6094 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6096 This document is only a draft and is subject to change. (So beware.)
6098 Details regarding the older, non-standard 64-bit format were
6099 determined empirically by examining 64-bit ELF files produced by
6100 the SGI toolchain on an IRIX 6.5 machine.
6102 - Kevin, July 16, 2002
6106 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6107 unsigned int *bytes_read
)
6109 LONGEST length
= bfd_get_32 (abfd
, buf
);
6111 if (length
== 0xffffffff)
6113 length
= bfd_get_64 (abfd
, buf
+ 4);
6116 else if (length
== 0)
6118 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6119 length
= bfd_get_64 (abfd
, buf
);
6129 gdb_assert (cu_header
->initial_length_size
== 0
6130 || cu_header
->initial_length_size
== 4
6131 || cu_header
->initial_length_size
== 8
6132 || cu_header
->initial_length_size
== 12);
6134 if (cu_header
->initial_length_size
!= 0
6135 && cu_header
->initial_length_size
!= *bytes_read
)
6136 complaint (&symfile_complaints
,
6137 _("intermixed 32-bit and 64-bit DWARF sections"));
6139 cu_header
->initial_length_size
= *bytes_read
;
6140 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6146 /* Read an offset from the data stream. The size of the offset is
6147 given by cu_header->offset_size. */
6150 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6151 unsigned int *bytes_read
)
6155 switch (cu_header
->offset_size
)
6158 retval
= bfd_get_32 (abfd
, buf
);
6162 retval
= bfd_get_64 (abfd
, buf
);
6166 internal_error (__FILE__
, __LINE__
,
6167 _("read_offset: bad switch [in module %s]"),
6168 bfd_get_filename (abfd
));
6175 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6177 /* If the size of a host char is 8 bits, we can return a pointer
6178 to the buffer, otherwise we have to copy the data to a buffer
6179 allocated on the temporary obstack. */
6180 gdb_assert (HOST_CHAR_BIT
== 8);
6185 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6187 /* If the size of a host char is 8 bits, we can return a pointer
6188 to the string, otherwise we have to copy the string to a buffer
6189 allocated on the temporary obstack. */
6190 gdb_assert (HOST_CHAR_BIT
== 8);
6193 *bytes_read_ptr
= 1;
6196 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6197 return (char *) buf
;
6201 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6202 const struct comp_unit_head
*cu_header
,
6203 unsigned int *bytes_read_ptr
)
6205 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6208 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6210 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6211 bfd_get_filename (abfd
));
6214 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6216 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6217 bfd_get_filename (abfd
));
6220 gdb_assert (HOST_CHAR_BIT
== 8);
6221 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6223 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6226 static unsigned long
6227 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6229 unsigned long result
;
6230 unsigned int num_read
;
6240 byte
= bfd_get_8 (abfd
, buf
);
6243 result
|= ((unsigned long)(byte
& 127) << shift
);
6244 if ((byte
& 128) == 0)
6250 *bytes_read_ptr
= num_read
;
6255 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6258 int i
, shift
, num_read
;
6267 byte
= bfd_get_8 (abfd
, buf
);
6270 result
|= ((long)(byte
& 127) << shift
);
6272 if ((byte
& 128) == 0)
6277 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6278 result
|= -(((long)1) << shift
);
6279 *bytes_read_ptr
= num_read
;
6283 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6286 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6292 byte
= bfd_get_8 (abfd
, buf
);
6294 if ((byte
& 128) == 0)
6300 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6306 cu
->language
= language_c
;
6308 case DW_LANG_C_plus_plus
:
6309 cu
->language
= language_cplus
;
6311 case DW_LANG_Fortran77
:
6312 case DW_LANG_Fortran90
:
6313 case DW_LANG_Fortran95
:
6314 cu
->language
= language_fortran
;
6316 case DW_LANG_Mips_Assembler
:
6317 cu
->language
= language_asm
;
6320 cu
->language
= language_java
;
6324 cu
->language
= language_ada
;
6326 case DW_LANG_Modula2
:
6327 cu
->language
= language_m2
;
6329 case DW_LANG_Pascal83
:
6330 cu
->language
= language_pascal
;
6332 case DW_LANG_Cobol74
:
6333 case DW_LANG_Cobol85
:
6335 cu
->language
= language_minimal
;
6338 cu
->language_defn
= language_def (cu
->language
);
6341 /* Return the named attribute or NULL if not there. */
6343 static struct attribute
*
6344 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6347 struct attribute
*spec
= NULL
;
6349 for (i
= 0; i
< die
->num_attrs
; ++i
)
6351 if (die
->attrs
[i
].name
== name
)
6352 return &die
->attrs
[i
];
6353 if (die
->attrs
[i
].name
== DW_AT_specification
6354 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6355 spec
= &die
->attrs
[i
];
6359 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6364 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6365 and holds a non-zero value. This function should only be used for
6366 DW_FORM_flag attributes. */
6369 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6371 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6373 return (attr
&& DW_UNSND (attr
));
6377 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6379 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6380 which value is non-zero. However, we have to be careful with
6381 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6382 (via dwarf2_flag_true_p) follows this attribute. So we may
6383 end up accidently finding a declaration attribute that belongs
6384 to a different DIE referenced by the specification attribute,
6385 even though the given DIE does not have a declaration attribute. */
6386 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6387 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6390 /* Return the die giving the specification for DIE, if there is
6393 static struct die_info
*
6394 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6396 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6398 if (spec_attr
== NULL
)
6401 return follow_die_ref (die
, spec_attr
, cu
);
6404 /* Free the line_header structure *LH, and any arrays and strings it
6407 free_line_header (struct line_header
*lh
)
6409 if (lh
->standard_opcode_lengths
)
6410 xfree (lh
->standard_opcode_lengths
);
6412 /* Remember that all the lh->file_names[i].name pointers are
6413 pointers into debug_line_buffer, and don't need to be freed. */
6415 xfree (lh
->file_names
);
6417 /* Similarly for the include directory names. */
6418 if (lh
->include_dirs
)
6419 xfree (lh
->include_dirs
);
6425 /* Add an entry to LH's include directory table. */
6427 add_include_dir (struct line_header
*lh
, char *include_dir
)
6429 /* Grow the array if necessary. */
6430 if (lh
->include_dirs_size
== 0)
6432 lh
->include_dirs_size
= 1; /* for testing */
6433 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6434 * sizeof (*lh
->include_dirs
));
6436 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6438 lh
->include_dirs_size
*= 2;
6439 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6440 (lh
->include_dirs_size
6441 * sizeof (*lh
->include_dirs
)));
6444 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6448 /* Add an entry to LH's file name table. */
6450 add_file_name (struct line_header
*lh
,
6452 unsigned int dir_index
,
6453 unsigned int mod_time
,
6454 unsigned int length
)
6456 struct file_entry
*fe
;
6458 /* Grow the array if necessary. */
6459 if (lh
->file_names_size
== 0)
6461 lh
->file_names_size
= 1; /* for testing */
6462 lh
->file_names
= xmalloc (lh
->file_names_size
6463 * sizeof (*lh
->file_names
));
6465 else if (lh
->num_file_names
>= lh
->file_names_size
)
6467 lh
->file_names_size
*= 2;
6468 lh
->file_names
= xrealloc (lh
->file_names
,
6469 (lh
->file_names_size
6470 * sizeof (*lh
->file_names
)));
6473 fe
= &lh
->file_names
[lh
->num_file_names
++];
6475 fe
->dir_index
= dir_index
;
6476 fe
->mod_time
= mod_time
;
6477 fe
->length
= length
;
6483 /* Read the statement program header starting at OFFSET in
6484 .debug_line, according to the endianness of ABFD. Return a pointer
6485 to a struct line_header, allocated using xmalloc.
6487 NOTE: the strings in the include directory and file name tables of
6488 the returned object point into debug_line_buffer, and must not be
6490 static struct line_header
*
6491 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6492 struct dwarf2_cu
*cu
)
6494 struct cleanup
*back_to
;
6495 struct line_header
*lh
;
6497 unsigned int bytes_read
;
6499 char *cur_dir
, *cur_file
;
6501 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6503 complaint (&symfile_complaints
, _("missing .debug_line section"));
6507 /* Make sure that at least there's room for the total_length field.
6508 That could be 12 bytes long, but we're just going to fudge that. */
6509 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6511 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6515 lh
= xmalloc (sizeof (*lh
));
6516 memset (lh
, 0, sizeof (*lh
));
6517 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6520 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6522 /* Read in the header. */
6524 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6525 line_ptr
+= bytes_read
;
6526 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6527 + dwarf2_per_objfile
->line_size
))
6529 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6532 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6533 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6535 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6536 line_ptr
+= bytes_read
;
6537 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6539 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6541 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6543 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6545 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6547 lh
->standard_opcode_lengths
6548 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6550 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6551 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6553 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6557 /* Read directory table. */
6558 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6560 line_ptr
+= bytes_read
;
6561 add_include_dir (lh
, cur_dir
);
6563 line_ptr
+= bytes_read
;
6565 /* Read file name table. */
6566 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6568 unsigned int dir_index
, mod_time
, length
;
6570 line_ptr
+= bytes_read
;
6571 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6572 line_ptr
+= bytes_read
;
6573 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6574 line_ptr
+= bytes_read
;
6575 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6576 line_ptr
+= bytes_read
;
6578 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6580 line_ptr
+= bytes_read
;
6581 lh
->statement_program_start
= line_ptr
;
6583 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6584 + dwarf2_per_objfile
->line_size
))
6585 complaint (&symfile_complaints
,
6586 _("line number info header doesn't fit in `.debug_line' section"));
6588 discard_cleanups (back_to
);
6592 /* This function exists to work around a bug in certain compilers
6593 (particularly GCC 2.95), in which the first line number marker of a
6594 function does not show up until after the prologue, right before
6595 the second line number marker. This function shifts ADDRESS down
6596 to the beginning of the function if necessary, and is called on
6597 addresses passed to record_line. */
6600 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6602 struct function_range
*fn
;
6604 /* Find the function_range containing address. */
6609 cu
->cached_fn
= cu
->first_fn
;
6613 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6619 while (fn
&& fn
!= cu
->cached_fn
)
6620 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6630 if (address
!= fn
->lowpc
)
6631 complaint (&symfile_complaints
,
6632 _("misplaced first line number at 0x%lx for '%s'"),
6633 (unsigned long) address
, fn
->name
);
6638 /* Decode the Line Number Program (LNP) for the given line_header
6639 structure and CU. The actual information extracted and the type
6640 of structures created from the LNP depends on the value of PST.
6642 1. If PST is NULL, then this procedure uses the data from the program
6643 to create all necessary symbol tables, and their linetables.
6644 The compilation directory of the file is passed in COMP_DIR,
6645 and must not be NULL.
6647 2. If PST is not NULL, this procedure reads the program to determine
6648 the list of files included by the unit represented by PST, and
6649 builds all the associated partial symbol tables. In this case,
6650 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6651 is not used to compute the full name of the symtab, and therefore
6652 omitting it when building the partial symtab does not introduce
6653 the potential for inconsistency - a partial symtab and its associated
6654 symbtab having a different fullname -). */
6657 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6658 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6662 unsigned int bytes_read
;
6663 unsigned char op_code
, extended_op
, adj_opcode
;
6665 struct objfile
*objfile
= cu
->objfile
;
6666 const int decode_for_pst_p
= (pst
!= NULL
);
6667 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6669 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6671 line_ptr
= lh
->statement_program_start
;
6672 line_end
= lh
->statement_program_end
;
6674 /* Read the statement sequences until there's nothing left. */
6675 while (line_ptr
< line_end
)
6677 /* state machine registers */
6678 CORE_ADDR address
= 0;
6679 unsigned int file
= 1;
6680 unsigned int line
= 1;
6681 unsigned int column
= 0;
6682 int is_stmt
= lh
->default_is_stmt
;
6683 int basic_block
= 0;
6684 int end_sequence
= 0;
6686 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6688 /* Start a subfile for the current file of the state machine. */
6689 /* lh->include_dirs and lh->file_names are 0-based, but the
6690 directory and file name numbers in the statement program
6692 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6696 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6698 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6701 /* Decode the table. */
6702 while (!end_sequence
)
6704 op_code
= read_1_byte (abfd
, line_ptr
);
6707 if (op_code
>= lh
->opcode_base
)
6709 /* Special operand. */
6710 adj_opcode
= op_code
- lh
->opcode_base
;
6711 address
+= (adj_opcode
/ lh
->line_range
)
6712 * lh
->minimum_instruction_length
;
6713 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6714 lh
->file_names
[file
- 1].included_p
= 1;
6715 if (!decode_for_pst_p
)
6717 if (last_subfile
!= current_subfile
)
6720 record_line (last_subfile
, 0, address
);
6721 last_subfile
= current_subfile
;
6723 /* Append row to matrix using current values. */
6724 record_line (current_subfile
, line
,
6725 check_cu_functions (address
, cu
));
6729 else switch (op_code
)
6731 case DW_LNS_extended_op
:
6732 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6733 line_ptr
+= bytes_read
;
6734 extended_op
= read_1_byte (abfd
, line_ptr
);
6736 switch (extended_op
)
6738 case DW_LNE_end_sequence
:
6740 lh
->file_names
[file
- 1].included_p
= 1;
6741 if (!decode_for_pst_p
)
6742 record_line (current_subfile
, 0, address
);
6744 case DW_LNE_set_address
:
6745 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6746 line_ptr
+= bytes_read
;
6747 address
+= baseaddr
;
6749 case DW_LNE_define_file
:
6752 unsigned int dir_index
, mod_time
, length
;
6754 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6755 line_ptr
+= bytes_read
;
6757 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6758 line_ptr
+= bytes_read
;
6760 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6761 line_ptr
+= bytes_read
;
6763 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6764 line_ptr
+= bytes_read
;
6765 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6769 complaint (&symfile_complaints
,
6770 _("mangled .debug_line section"));
6775 lh
->file_names
[file
- 1].included_p
= 1;
6776 if (!decode_for_pst_p
)
6778 if (last_subfile
!= current_subfile
)
6781 record_line (last_subfile
, 0, address
);
6782 last_subfile
= current_subfile
;
6784 record_line (current_subfile
, line
,
6785 check_cu_functions (address
, cu
));
6789 case DW_LNS_advance_pc
:
6790 address
+= lh
->minimum_instruction_length
6791 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6792 line_ptr
+= bytes_read
;
6794 case DW_LNS_advance_line
:
6795 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6796 line_ptr
+= bytes_read
;
6798 case DW_LNS_set_file
:
6800 /* The arrays lh->include_dirs and lh->file_names are
6801 0-based, but the directory and file name numbers in
6802 the statement program are 1-based. */
6803 struct file_entry
*fe
;
6806 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6807 line_ptr
+= bytes_read
;
6808 fe
= &lh
->file_names
[file
- 1];
6810 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6812 if (!decode_for_pst_p
)
6814 last_subfile
= current_subfile
;
6815 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6819 case DW_LNS_set_column
:
6820 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6821 line_ptr
+= bytes_read
;
6823 case DW_LNS_negate_stmt
:
6824 is_stmt
= (!is_stmt
);
6826 case DW_LNS_set_basic_block
:
6829 /* Add to the address register of the state machine the
6830 address increment value corresponding to special opcode
6831 255. I.e., this value is scaled by the minimum
6832 instruction length since special opcode 255 would have
6833 scaled the the increment. */
6834 case DW_LNS_const_add_pc
:
6835 address
+= (lh
->minimum_instruction_length
6836 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6838 case DW_LNS_fixed_advance_pc
:
6839 address
+= read_2_bytes (abfd
, line_ptr
);
6844 /* Unknown standard opcode, ignore it. */
6847 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6849 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6850 line_ptr
+= bytes_read
;
6857 if (decode_for_pst_p
)
6861 /* Now that we're done scanning the Line Header Program, we can
6862 create the psymtab of each included file. */
6863 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6864 if (lh
->file_names
[file_index
].included_p
== 1)
6866 const struct file_entry fe
= lh
->file_names
[file_index
];
6867 char *include_name
= fe
.name
;
6868 char *dir_name
= NULL
;
6869 char *pst_filename
= pst
->filename
;
6872 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6874 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6876 include_name
= concat (dir_name
, SLASH_STRING
,
6877 include_name
, (char *)NULL
);
6878 make_cleanup (xfree
, include_name
);
6881 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6883 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6884 pst_filename
, (char *)NULL
);
6885 make_cleanup (xfree
, pst_filename
);
6888 if (strcmp (include_name
, pst_filename
) != 0)
6889 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6894 /* Make sure a symtab is created for every file, even files
6895 which contain only variables (i.e. no code with associated
6899 struct file_entry
*fe
;
6901 for (i
= 0; i
< lh
->num_file_names
; i
++)
6904 fe
= &lh
->file_names
[i
];
6906 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6907 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6909 /* Skip the main file; we don't need it, and it must be
6910 allocated last, so that it will show up before the
6911 non-primary symtabs in the objfile's symtab list. */
6912 if (current_subfile
== first_subfile
)
6915 if (current_subfile
->symtab
== NULL
)
6916 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
6918 fe
->symtab
= current_subfile
->symtab
;
6923 /* Start a subfile for DWARF. FILENAME is the name of the file and
6924 DIRNAME the name of the source directory which contains FILENAME
6925 or NULL if not known. COMP_DIR is the compilation directory for the
6926 linetable's compilation unit or NULL if not known.
6927 This routine tries to keep line numbers from identical absolute and
6928 relative file names in a common subfile.
6930 Using the `list' example from the GDB testsuite, which resides in
6931 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6932 of /srcdir/list0.c yields the following debugging information for list0.c:
6934 DW_AT_name: /srcdir/list0.c
6935 DW_AT_comp_dir: /compdir
6936 files.files[0].name: list0.h
6937 files.files[0].dir: /srcdir
6938 files.files[1].name: list0.c
6939 files.files[1].dir: /srcdir
6941 The line number information for list0.c has to end up in a single
6942 subfile, so that `break /srcdir/list0.c:1' works as expected.
6943 start_subfile will ensure that this happens provided that we pass the
6944 concatenation of files.files[1].dir and files.files[1].name as the
6948 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6952 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6953 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6954 second argument to start_subfile. To be consistent, we do the
6955 same here. In order not to lose the line information directory,
6956 we concatenate it to the filename when it makes sense.
6957 Note that the Dwarf3 standard says (speaking of filenames in line
6958 information): ``The directory index is ignored for file names
6959 that represent full path names''. Thus ignoring dirname in the
6960 `else' branch below isn't an issue. */
6962 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6963 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6965 fullname
= filename
;
6967 start_subfile (fullname
, comp_dir
);
6969 if (fullname
!= filename
)
6974 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6975 struct dwarf2_cu
*cu
)
6977 struct objfile
*objfile
= cu
->objfile
;
6978 struct comp_unit_head
*cu_header
= &cu
->header
;
6980 /* NOTE drow/2003-01-30: There used to be a comment and some special
6981 code here to turn a symbol with DW_AT_external and a
6982 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6983 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6984 with some versions of binutils) where shared libraries could have
6985 relocations against symbols in their debug information - the
6986 minimal symbol would have the right address, but the debug info
6987 would not. It's no longer necessary, because we will explicitly
6988 apply relocations when we read in the debug information now. */
6990 /* A DW_AT_location attribute with no contents indicates that a
6991 variable has been optimized away. */
6992 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6994 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6998 /* Handle one degenerate form of location expression specially, to
6999 preserve GDB's previous behavior when section offsets are
7000 specified. If this is just a DW_OP_addr then mark this symbol
7003 if (attr_form_is_block (attr
)
7004 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7005 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7009 SYMBOL_VALUE_ADDRESS (sym
) =
7010 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7011 fixup_symbol_section (sym
, objfile
);
7012 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7013 SYMBOL_SECTION (sym
));
7014 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7018 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7019 expression evaluator, and use LOC_COMPUTED only when necessary
7020 (i.e. when the value of a register or memory location is
7021 referenced, or a thread-local block, etc.). Then again, it might
7022 not be worthwhile. I'm assuming that it isn't unless performance
7023 or memory numbers show me otherwise. */
7025 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7026 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7029 /* Given a pointer to a DWARF information entry, figure out if we need
7030 to make a symbol table entry for it, and if so, create a new entry
7031 and return a pointer to it.
7032 If TYPE is NULL, determine symbol type from the die, otherwise
7033 used the passed type. */
7035 static struct symbol
*
7036 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7038 struct objfile
*objfile
= cu
->objfile
;
7039 struct symbol
*sym
= NULL
;
7041 struct attribute
*attr
= NULL
;
7042 struct attribute
*attr2
= NULL
;
7045 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7047 if (die
->tag
!= DW_TAG_namespace
)
7048 name
= dwarf2_linkage_name (die
, cu
);
7050 name
= TYPE_NAME (type
);
7054 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7055 sizeof (struct symbol
));
7056 OBJSTAT (objfile
, n_syms
++);
7057 memset (sym
, 0, sizeof (struct symbol
));
7059 /* Cache this symbol's name and the name's demangled form (if any). */
7060 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7061 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7063 /* Default assumptions.
7064 Use the passed type or decode it from the die. */
7065 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7066 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7068 SYMBOL_TYPE (sym
) = type
;
7070 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7071 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7074 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7077 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7080 int file_index
= DW_UNSND (attr
);
7081 if (cu
->line_header
== NULL
7082 || file_index
> cu
->line_header
->num_file_names
)
7083 complaint (&symfile_complaints
,
7084 _("file index out of range"));
7085 else if (file_index
> 0)
7087 struct file_entry
*fe
;
7088 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7089 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7096 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7099 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7101 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7103 case DW_TAG_subprogram
:
7104 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7106 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7107 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7108 if (attr2
&& (DW_UNSND (attr2
) != 0))
7110 add_symbol_to_list (sym
, &global_symbols
);
7114 add_symbol_to_list (sym
, cu
->list_in_scope
);
7117 case DW_TAG_variable
:
7118 /* Compilation with minimal debug info may result in variables
7119 with missing type entries. Change the misleading `void' type
7120 to something sensible. */
7121 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7122 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
7123 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
7124 "<variable, no debug info>",
7126 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7129 dwarf2_const_value (attr
, sym
, cu
);
7130 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7131 if (attr2
&& (DW_UNSND (attr2
) != 0))
7132 add_symbol_to_list (sym
, &global_symbols
);
7134 add_symbol_to_list (sym
, cu
->list_in_scope
);
7137 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7140 var_decode_location (attr
, sym
, cu
);
7141 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7142 if (attr2
&& (DW_UNSND (attr2
) != 0))
7143 add_symbol_to_list (sym
, &global_symbols
);
7145 add_symbol_to_list (sym
, cu
->list_in_scope
);
7149 /* We do not know the address of this symbol.
7150 If it is an external symbol and we have type information
7151 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7152 The address of the variable will then be determined from
7153 the minimal symbol table whenever the variable is
7155 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7156 if (attr2
&& (DW_UNSND (attr2
) != 0)
7157 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7159 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7160 add_symbol_to_list (sym
, &global_symbols
);
7164 case DW_TAG_formal_parameter
:
7165 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7168 var_decode_location (attr
, sym
, cu
);
7169 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7170 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7171 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7173 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7176 dwarf2_const_value (attr
, sym
, cu
);
7178 add_symbol_to_list (sym
, cu
->list_in_scope
);
7180 case DW_TAG_unspecified_parameters
:
7181 /* From varargs functions; gdb doesn't seem to have any
7182 interest in this information, so just ignore it for now.
7185 case DW_TAG_class_type
:
7186 case DW_TAG_structure_type
:
7187 case DW_TAG_union_type
:
7188 case DW_TAG_set_type
:
7189 case DW_TAG_enumeration_type
:
7190 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7191 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7193 /* Make sure that the symbol includes appropriate enclosing
7194 classes/namespaces in its name. These are calculated in
7195 read_structure_type, and the correct name is saved in
7198 if (cu
->language
== language_cplus
7199 || cu
->language
== language_java
)
7201 struct type
*type
= SYMBOL_TYPE (sym
);
7203 if (TYPE_TAG_NAME (type
) != NULL
)
7205 /* FIXME: carlton/2003-11-10: Should this use
7206 SYMBOL_SET_NAMES instead? (The same problem also
7207 arises further down in this function.) */
7208 /* The type's name is already allocated along with
7209 this objfile, so we don't need to duplicate it
7211 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7216 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7217 really ever be static objects: otherwise, if you try
7218 to, say, break of a class's method and you're in a file
7219 which doesn't mention that class, it won't work unless
7220 the check for all static symbols in lookup_symbol_aux
7221 saves you. See the OtherFileClass tests in
7222 gdb.c++/namespace.exp. */
7224 struct pending
**list_to_add
;
7226 list_to_add
= (cu
->list_in_scope
== &file_symbols
7227 && (cu
->language
== language_cplus
7228 || cu
->language
== language_java
)
7229 ? &global_symbols
: cu
->list_in_scope
);
7231 add_symbol_to_list (sym
, list_to_add
);
7233 /* The semantics of C++ state that "struct foo { ... }" also
7234 defines a typedef for "foo". A Java class declaration also
7235 defines a typedef for the class. Synthesize a typedef symbol
7236 so that "ptype foo" works as expected. */
7237 if (cu
->language
== language_cplus
7238 || cu
->language
== language_java
7239 || cu
->language
== language_ada
)
7241 struct symbol
*typedef_sym
= (struct symbol
*)
7242 obstack_alloc (&objfile
->objfile_obstack
,
7243 sizeof (struct symbol
));
7244 *typedef_sym
= *sym
;
7245 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7246 /* The symbol's name is already allocated along with
7247 this objfile, so we don't need to duplicate it for
7249 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7250 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7251 add_symbol_to_list (typedef_sym
, list_to_add
);
7255 case DW_TAG_typedef
:
7256 if (processing_has_namespace_info
7257 && processing_current_prefix
[0] != '\0')
7259 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7260 processing_current_prefix
,
7263 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7264 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7265 add_symbol_to_list (sym
, cu
->list_in_scope
);
7267 case DW_TAG_base_type
:
7268 case DW_TAG_subrange_type
:
7269 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7270 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7271 add_symbol_to_list (sym
, cu
->list_in_scope
);
7273 case DW_TAG_enumerator
:
7274 if (processing_has_namespace_info
7275 && processing_current_prefix
[0] != '\0')
7277 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7278 processing_current_prefix
,
7281 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7284 dwarf2_const_value (attr
, sym
, cu
);
7287 /* NOTE: carlton/2003-11-10: See comment above in the
7288 DW_TAG_class_type, etc. block. */
7290 struct pending
**list_to_add
;
7292 list_to_add
= (cu
->list_in_scope
== &file_symbols
7293 && (cu
->language
== language_cplus
7294 || cu
->language
== language_java
)
7295 ? &global_symbols
: cu
->list_in_scope
);
7297 add_symbol_to_list (sym
, list_to_add
);
7300 case DW_TAG_namespace
:
7301 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7302 add_symbol_to_list (sym
, &global_symbols
);
7305 /* Not a tag we recognize. Hopefully we aren't processing
7306 trash data, but since we must specifically ignore things
7307 we don't recognize, there is nothing else we should do at
7309 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7310 dwarf_tag_name (die
->tag
));
7317 /* Copy constant value from an attribute to a symbol. */
7320 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7321 struct dwarf2_cu
*cu
)
7323 struct objfile
*objfile
= cu
->objfile
;
7324 struct comp_unit_head
*cu_header
= &cu
->header
;
7325 struct dwarf_block
*blk
;
7330 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7331 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7332 cu_header
->addr_size
,
7333 TYPE_LENGTH (SYMBOL_TYPE
7335 SYMBOL_VALUE_BYTES (sym
) =
7336 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7337 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7338 it's body - store_unsigned_integer. */
7339 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7341 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7343 case DW_FORM_block1
:
7344 case DW_FORM_block2
:
7345 case DW_FORM_block4
:
7347 blk
= DW_BLOCK (attr
);
7348 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7349 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7351 TYPE_LENGTH (SYMBOL_TYPE
7353 SYMBOL_VALUE_BYTES (sym
) =
7354 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7355 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7356 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7359 /* The DW_AT_const_value attributes are supposed to carry the
7360 symbol's value "represented as it would be on the target
7361 architecture." By the time we get here, it's already been
7362 converted to host endianness, so we just need to sign- or
7363 zero-extend it as appropriate. */
7365 dwarf2_const_value_data (attr
, sym
, 8);
7368 dwarf2_const_value_data (attr
, sym
, 16);
7371 dwarf2_const_value_data (attr
, sym
, 32);
7374 dwarf2_const_value_data (attr
, sym
, 64);
7378 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7379 SYMBOL_CLASS (sym
) = LOC_CONST
;
7383 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7384 SYMBOL_CLASS (sym
) = LOC_CONST
;
7388 complaint (&symfile_complaints
,
7389 _("unsupported const value attribute form: '%s'"),
7390 dwarf_form_name (attr
->form
));
7391 SYMBOL_VALUE (sym
) = 0;
7392 SYMBOL_CLASS (sym
) = LOC_CONST
;
7398 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7399 or zero-extend it as appropriate for the symbol's type. */
7401 dwarf2_const_value_data (struct attribute
*attr
,
7405 LONGEST l
= DW_UNSND (attr
);
7407 if (bits
< sizeof (l
) * 8)
7409 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7410 l
&= ((LONGEST
) 1 << bits
) - 1;
7412 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7415 SYMBOL_VALUE (sym
) = l
;
7416 SYMBOL_CLASS (sym
) = LOC_CONST
;
7420 /* Return the type of the die in question using its DW_AT_type attribute. */
7422 static struct type
*
7423 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7426 struct attribute
*type_attr
;
7427 struct die_info
*type_die
;
7429 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7432 /* A missing DW_AT_type represents a void type. */
7433 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7436 type_die
= follow_die_ref (die
, type_attr
, cu
);
7438 type
= tag_type_to_type (type_die
, cu
);
7441 dump_die (type_die
);
7442 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7448 /* Return the containing type of the die in question using its
7449 DW_AT_containing_type attribute. */
7451 static struct type
*
7452 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7454 struct type
*type
= NULL
;
7455 struct attribute
*type_attr
;
7456 struct die_info
*type_die
= NULL
;
7458 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7461 type_die
= follow_die_ref (die
, type_attr
, cu
);
7462 type
= tag_type_to_type (type_die
, cu
);
7467 dump_die (type_die
);
7468 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7474 static struct type
*
7475 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7483 read_type_die (die
, cu
);
7487 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7495 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7497 char *prefix
= determine_prefix (die
, cu
);
7498 const char *old_prefix
= processing_current_prefix
;
7499 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7500 processing_current_prefix
= prefix
;
7504 case DW_TAG_class_type
:
7505 case DW_TAG_structure_type
:
7506 case DW_TAG_union_type
:
7507 read_structure_type (die
, cu
);
7509 case DW_TAG_enumeration_type
:
7510 read_enumeration_type (die
, cu
);
7512 case DW_TAG_subprogram
:
7513 case DW_TAG_subroutine_type
:
7514 read_subroutine_type (die
, cu
);
7516 case DW_TAG_array_type
:
7517 read_array_type (die
, cu
);
7519 case DW_TAG_set_type
:
7520 read_set_type (die
, cu
);
7522 case DW_TAG_pointer_type
:
7523 read_tag_pointer_type (die
, cu
);
7525 case DW_TAG_ptr_to_member_type
:
7526 read_tag_ptr_to_member_type (die
, cu
);
7528 case DW_TAG_reference_type
:
7529 read_tag_reference_type (die
, cu
);
7531 case DW_TAG_const_type
:
7532 read_tag_const_type (die
, cu
);
7534 case DW_TAG_volatile_type
:
7535 read_tag_volatile_type (die
, cu
);
7537 case DW_TAG_string_type
:
7538 read_tag_string_type (die
, cu
);
7540 case DW_TAG_typedef
:
7541 read_typedef (die
, cu
);
7543 case DW_TAG_subrange_type
:
7544 read_subrange_type (die
, cu
);
7546 case DW_TAG_base_type
:
7547 read_base_type (die
, cu
);
7549 case DW_TAG_unspecified_type
:
7550 read_unspecified_type (die
, cu
);
7553 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7554 dwarf_tag_name (die
->tag
));
7558 processing_current_prefix
= old_prefix
;
7559 do_cleanups (back_to
);
7562 /* Return the name of the namespace/class that DIE is defined within,
7563 or "" if we can't tell. The caller should xfree the result. */
7565 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7566 therein) for an example of how to use this function to deal with
7567 DW_AT_specification. */
7570 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7572 struct die_info
*parent
;
7574 if (cu
->language
!= language_cplus
7575 && cu
->language
!= language_java
)
7578 parent
= die
->parent
;
7582 return xstrdup ("");
7586 switch (parent
->tag
) {
7587 case DW_TAG_namespace
:
7589 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7590 before doing this check? */
7591 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7593 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7598 char *parent_prefix
= determine_prefix (parent
, cu
);
7599 char *retval
= typename_concat (NULL
, parent_prefix
,
7600 namespace_name (parent
, &dummy
,
7603 xfree (parent_prefix
);
7608 case DW_TAG_class_type
:
7609 case DW_TAG_structure_type
:
7611 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7613 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7617 const char *old_prefix
= processing_current_prefix
;
7618 char *new_prefix
= determine_prefix (parent
, cu
);
7621 processing_current_prefix
= new_prefix
;
7622 retval
= determine_class_name (parent
, cu
);
7623 processing_current_prefix
= old_prefix
;
7630 return determine_prefix (parent
, cu
);
7635 /* Return a newly-allocated string formed by concatenating PREFIX and
7636 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7637 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7638 perform an obconcat, otherwise allocate storage for the result. The CU argument
7639 is used to determine the language and hence, the appropriate separator. */
7641 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7644 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7645 struct dwarf2_cu
*cu
)
7649 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7651 else if (cu
->language
== language_java
)
7658 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7663 strcpy (retval
, prefix
);
7664 strcat (retval
, sep
);
7667 strcat (retval
, suffix
);
7673 /* We have an obstack. */
7674 return obconcat (obs
, prefix
, sep
, suffix
);
7678 static struct type
*
7679 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7681 struct objfile
*objfile
= cu
->objfile
;
7683 /* FIXME - this should not produce a new (struct type *)
7684 every time. It should cache base types. */
7688 case DW_ATE_address
:
7689 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7691 case DW_ATE_boolean
:
7692 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7694 case DW_ATE_complex_float
:
7697 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7701 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7707 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7711 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7718 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7721 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7725 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7729 case DW_ATE_signed_char
:
7730 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7732 case DW_ATE_unsigned
:
7736 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7739 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7743 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7747 case DW_ATE_unsigned_char
:
7748 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7751 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7758 copy_die (struct die_info
*old_die
)
7760 struct die_info
*new_die
;
7763 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7764 memset (new_die
, 0, sizeof (struct die_info
));
7766 new_die
->tag
= old_die
->tag
;
7767 new_die
->has_children
= old_die
->has_children
;
7768 new_die
->abbrev
= old_die
->abbrev
;
7769 new_die
->offset
= old_die
->offset
;
7770 new_die
->type
= NULL
;
7772 num_attrs
= old_die
->num_attrs
;
7773 new_die
->num_attrs
= num_attrs
;
7774 new_die
->attrs
= (struct attribute
*)
7775 xmalloc (num_attrs
* sizeof (struct attribute
));
7777 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7779 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7780 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7781 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7784 new_die
->next
= NULL
;
7789 /* Return sibling of die, NULL if no sibling. */
7791 static struct die_info
*
7792 sibling_die (struct die_info
*die
)
7794 return die
->sibling
;
7797 /* Get linkage name of a die, return NULL if not found. */
7800 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7802 struct attribute
*attr
;
7804 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7805 if (attr
&& DW_STRING (attr
))
7806 return DW_STRING (attr
);
7807 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7808 if (attr
&& DW_STRING (attr
))
7809 return DW_STRING (attr
);
7813 /* Get name of a die, return NULL if not found. */
7816 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7818 struct attribute
*attr
;
7820 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7821 if (attr
&& DW_STRING (attr
))
7822 return DW_STRING (attr
);
7826 /* Return the die that this die in an extension of, or NULL if there
7829 static struct die_info
*
7830 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7832 struct attribute
*attr
;
7834 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7838 return follow_die_ref (die
, attr
, cu
);
7841 /* Convert a DIE tag into its string name. */
7844 dwarf_tag_name (unsigned tag
)
7848 case DW_TAG_padding
:
7849 return "DW_TAG_padding";
7850 case DW_TAG_array_type
:
7851 return "DW_TAG_array_type";
7852 case DW_TAG_class_type
:
7853 return "DW_TAG_class_type";
7854 case DW_TAG_entry_point
:
7855 return "DW_TAG_entry_point";
7856 case DW_TAG_enumeration_type
:
7857 return "DW_TAG_enumeration_type";
7858 case DW_TAG_formal_parameter
:
7859 return "DW_TAG_formal_parameter";
7860 case DW_TAG_imported_declaration
:
7861 return "DW_TAG_imported_declaration";
7863 return "DW_TAG_label";
7864 case DW_TAG_lexical_block
:
7865 return "DW_TAG_lexical_block";
7867 return "DW_TAG_member";
7868 case DW_TAG_pointer_type
:
7869 return "DW_TAG_pointer_type";
7870 case DW_TAG_reference_type
:
7871 return "DW_TAG_reference_type";
7872 case DW_TAG_compile_unit
:
7873 return "DW_TAG_compile_unit";
7874 case DW_TAG_string_type
:
7875 return "DW_TAG_string_type";
7876 case DW_TAG_structure_type
:
7877 return "DW_TAG_structure_type";
7878 case DW_TAG_subroutine_type
:
7879 return "DW_TAG_subroutine_type";
7880 case DW_TAG_typedef
:
7881 return "DW_TAG_typedef";
7882 case DW_TAG_union_type
:
7883 return "DW_TAG_union_type";
7884 case DW_TAG_unspecified_parameters
:
7885 return "DW_TAG_unspecified_parameters";
7886 case DW_TAG_variant
:
7887 return "DW_TAG_variant";
7888 case DW_TAG_common_block
:
7889 return "DW_TAG_common_block";
7890 case DW_TAG_common_inclusion
:
7891 return "DW_TAG_common_inclusion";
7892 case DW_TAG_inheritance
:
7893 return "DW_TAG_inheritance";
7894 case DW_TAG_inlined_subroutine
:
7895 return "DW_TAG_inlined_subroutine";
7897 return "DW_TAG_module";
7898 case DW_TAG_ptr_to_member_type
:
7899 return "DW_TAG_ptr_to_member_type";
7900 case DW_TAG_set_type
:
7901 return "DW_TAG_set_type";
7902 case DW_TAG_subrange_type
:
7903 return "DW_TAG_subrange_type";
7904 case DW_TAG_with_stmt
:
7905 return "DW_TAG_with_stmt";
7906 case DW_TAG_access_declaration
:
7907 return "DW_TAG_access_declaration";
7908 case DW_TAG_base_type
:
7909 return "DW_TAG_base_type";
7910 case DW_TAG_catch_block
:
7911 return "DW_TAG_catch_block";
7912 case DW_TAG_const_type
:
7913 return "DW_TAG_const_type";
7914 case DW_TAG_constant
:
7915 return "DW_TAG_constant";
7916 case DW_TAG_enumerator
:
7917 return "DW_TAG_enumerator";
7918 case DW_TAG_file_type
:
7919 return "DW_TAG_file_type";
7921 return "DW_TAG_friend";
7922 case DW_TAG_namelist
:
7923 return "DW_TAG_namelist";
7924 case DW_TAG_namelist_item
:
7925 return "DW_TAG_namelist_item";
7926 case DW_TAG_packed_type
:
7927 return "DW_TAG_packed_type";
7928 case DW_TAG_subprogram
:
7929 return "DW_TAG_subprogram";
7930 case DW_TAG_template_type_param
:
7931 return "DW_TAG_template_type_param";
7932 case DW_TAG_template_value_param
:
7933 return "DW_TAG_template_value_param";
7934 case DW_TAG_thrown_type
:
7935 return "DW_TAG_thrown_type";
7936 case DW_TAG_try_block
:
7937 return "DW_TAG_try_block";
7938 case DW_TAG_variant_part
:
7939 return "DW_TAG_variant_part";
7940 case DW_TAG_variable
:
7941 return "DW_TAG_variable";
7942 case DW_TAG_volatile_type
:
7943 return "DW_TAG_volatile_type";
7944 case DW_TAG_dwarf_procedure
:
7945 return "DW_TAG_dwarf_procedure";
7946 case DW_TAG_restrict_type
:
7947 return "DW_TAG_restrict_type";
7948 case DW_TAG_interface_type
:
7949 return "DW_TAG_interface_type";
7950 case DW_TAG_namespace
:
7951 return "DW_TAG_namespace";
7952 case DW_TAG_imported_module
:
7953 return "DW_TAG_imported_module";
7954 case DW_TAG_unspecified_type
:
7955 return "DW_TAG_unspecified_type";
7956 case DW_TAG_partial_unit
:
7957 return "DW_TAG_partial_unit";
7958 case DW_TAG_imported_unit
:
7959 return "DW_TAG_imported_unit";
7960 case DW_TAG_condition
:
7961 return "DW_TAG_condition";
7962 case DW_TAG_shared_type
:
7963 return "DW_TAG_shared_type";
7964 case DW_TAG_MIPS_loop
:
7965 return "DW_TAG_MIPS_loop";
7966 case DW_TAG_HP_array_descriptor
:
7967 return "DW_TAG_HP_array_descriptor";
7968 case DW_TAG_format_label
:
7969 return "DW_TAG_format_label";
7970 case DW_TAG_function_template
:
7971 return "DW_TAG_function_template";
7972 case DW_TAG_class_template
:
7973 return "DW_TAG_class_template";
7974 case DW_TAG_GNU_BINCL
:
7975 return "DW_TAG_GNU_BINCL";
7976 case DW_TAG_GNU_EINCL
:
7977 return "DW_TAG_GNU_EINCL";
7978 case DW_TAG_upc_shared_type
:
7979 return "DW_TAG_upc_shared_type";
7980 case DW_TAG_upc_strict_type
:
7981 return "DW_TAG_upc_strict_type";
7982 case DW_TAG_upc_relaxed_type
:
7983 return "DW_TAG_upc_relaxed_type";
7984 case DW_TAG_PGI_kanji_type
:
7985 return "DW_TAG_PGI_kanji_type";
7986 case DW_TAG_PGI_interface_block
:
7987 return "DW_TAG_PGI_interface_block";
7989 return "DW_TAG_<unknown>";
7993 /* Convert a DWARF attribute code into its string name. */
7996 dwarf_attr_name (unsigned attr
)
8001 return "DW_AT_sibling";
8002 case DW_AT_location
:
8003 return "DW_AT_location";
8005 return "DW_AT_name";
8006 case DW_AT_ordering
:
8007 return "DW_AT_ordering";
8008 case DW_AT_subscr_data
:
8009 return "DW_AT_subscr_data";
8010 case DW_AT_byte_size
:
8011 return "DW_AT_byte_size";
8012 case DW_AT_bit_offset
:
8013 return "DW_AT_bit_offset";
8014 case DW_AT_bit_size
:
8015 return "DW_AT_bit_size";
8016 case DW_AT_element_list
:
8017 return "DW_AT_element_list";
8018 case DW_AT_stmt_list
:
8019 return "DW_AT_stmt_list";
8021 return "DW_AT_low_pc";
8023 return "DW_AT_high_pc";
8024 case DW_AT_language
:
8025 return "DW_AT_language";
8027 return "DW_AT_member";
8029 return "DW_AT_discr";
8030 case DW_AT_discr_value
:
8031 return "DW_AT_discr_value";
8032 case DW_AT_visibility
:
8033 return "DW_AT_visibility";
8035 return "DW_AT_import";
8036 case DW_AT_string_length
:
8037 return "DW_AT_string_length";
8038 case DW_AT_common_reference
:
8039 return "DW_AT_common_reference";
8040 case DW_AT_comp_dir
:
8041 return "DW_AT_comp_dir";
8042 case DW_AT_const_value
:
8043 return "DW_AT_const_value";
8044 case DW_AT_containing_type
:
8045 return "DW_AT_containing_type";
8046 case DW_AT_default_value
:
8047 return "DW_AT_default_value";
8049 return "DW_AT_inline";
8050 case DW_AT_is_optional
:
8051 return "DW_AT_is_optional";
8052 case DW_AT_lower_bound
:
8053 return "DW_AT_lower_bound";
8054 case DW_AT_producer
:
8055 return "DW_AT_producer";
8056 case DW_AT_prototyped
:
8057 return "DW_AT_prototyped";
8058 case DW_AT_return_addr
:
8059 return "DW_AT_return_addr";
8060 case DW_AT_start_scope
:
8061 return "DW_AT_start_scope";
8062 case DW_AT_stride_size
:
8063 return "DW_AT_stride_size";
8064 case DW_AT_upper_bound
:
8065 return "DW_AT_upper_bound";
8066 case DW_AT_abstract_origin
:
8067 return "DW_AT_abstract_origin";
8068 case DW_AT_accessibility
:
8069 return "DW_AT_accessibility";
8070 case DW_AT_address_class
:
8071 return "DW_AT_address_class";
8072 case DW_AT_artificial
:
8073 return "DW_AT_artificial";
8074 case DW_AT_base_types
:
8075 return "DW_AT_base_types";
8076 case DW_AT_calling_convention
:
8077 return "DW_AT_calling_convention";
8079 return "DW_AT_count";
8080 case DW_AT_data_member_location
:
8081 return "DW_AT_data_member_location";
8082 case DW_AT_decl_column
:
8083 return "DW_AT_decl_column";
8084 case DW_AT_decl_file
:
8085 return "DW_AT_decl_file";
8086 case DW_AT_decl_line
:
8087 return "DW_AT_decl_line";
8088 case DW_AT_declaration
:
8089 return "DW_AT_declaration";
8090 case DW_AT_discr_list
:
8091 return "DW_AT_discr_list";
8092 case DW_AT_encoding
:
8093 return "DW_AT_encoding";
8094 case DW_AT_external
:
8095 return "DW_AT_external";
8096 case DW_AT_frame_base
:
8097 return "DW_AT_frame_base";
8099 return "DW_AT_friend";
8100 case DW_AT_identifier_case
:
8101 return "DW_AT_identifier_case";
8102 case DW_AT_macro_info
:
8103 return "DW_AT_macro_info";
8104 case DW_AT_namelist_items
:
8105 return "DW_AT_namelist_items";
8106 case DW_AT_priority
:
8107 return "DW_AT_priority";
8109 return "DW_AT_segment";
8110 case DW_AT_specification
:
8111 return "DW_AT_specification";
8112 case DW_AT_static_link
:
8113 return "DW_AT_static_link";
8115 return "DW_AT_type";
8116 case DW_AT_use_location
:
8117 return "DW_AT_use_location";
8118 case DW_AT_variable_parameter
:
8119 return "DW_AT_variable_parameter";
8120 case DW_AT_virtuality
:
8121 return "DW_AT_virtuality";
8122 case DW_AT_vtable_elem_location
:
8123 return "DW_AT_vtable_elem_location";
8124 /* DWARF 3 values. */
8125 case DW_AT_allocated
:
8126 return "DW_AT_allocated";
8127 case DW_AT_associated
:
8128 return "DW_AT_associated";
8129 case DW_AT_data_location
:
8130 return "DW_AT_data_location";
8132 return "DW_AT_stride";
8133 case DW_AT_entry_pc
:
8134 return "DW_AT_entry_pc";
8135 case DW_AT_use_UTF8
:
8136 return "DW_AT_use_UTF8";
8137 case DW_AT_extension
:
8138 return "DW_AT_extension";
8140 return "DW_AT_ranges";
8141 case DW_AT_trampoline
:
8142 return "DW_AT_trampoline";
8143 case DW_AT_call_column
:
8144 return "DW_AT_call_column";
8145 case DW_AT_call_file
:
8146 return "DW_AT_call_file";
8147 case DW_AT_call_line
:
8148 return "DW_AT_call_line";
8149 case DW_AT_description
:
8150 return "DW_AT_description";
8151 case DW_AT_binary_scale
:
8152 return "DW_AT_binary_scale";
8153 case DW_AT_decimal_scale
:
8154 return "DW_AT_decimal_scale";
8156 return "DW_AT_small";
8157 case DW_AT_decimal_sign
:
8158 return "DW_AT_decimal_sign";
8159 case DW_AT_digit_count
:
8160 return "DW_AT_digit_count";
8161 case DW_AT_picture_string
:
8162 return "DW_AT_picture_string";
8164 return "DW_AT_mutable";
8165 case DW_AT_threads_scaled
:
8166 return "DW_AT_threads_scaled";
8167 case DW_AT_explicit
:
8168 return "DW_AT_explicit";
8169 case DW_AT_object_pointer
:
8170 return "DW_AT_object_pointer";
8171 case DW_AT_endianity
:
8172 return "DW_AT_endianity";
8173 case DW_AT_elemental
:
8174 return "DW_AT_elemental";
8176 return "DW_AT_pure";
8177 case DW_AT_recursive
:
8178 return "DW_AT_recursive";
8180 /* SGI/MIPS extensions. */
8181 case DW_AT_MIPS_fde
:
8182 return "DW_AT_MIPS_fde";
8183 case DW_AT_MIPS_loop_begin
:
8184 return "DW_AT_MIPS_loop_begin";
8185 case DW_AT_MIPS_tail_loop_begin
:
8186 return "DW_AT_MIPS_tail_loop_begin";
8187 case DW_AT_MIPS_epilog_begin
:
8188 return "DW_AT_MIPS_epilog_begin";
8189 case DW_AT_MIPS_loop_unroll_factor
:
8190 return "DW_AT_MIPS_loop_unroll_factor";
8191 case DW_AT_MIPS_software_pipeline_depth
:
8192 return "DW_AT_MIPS_software_pipeline_depth";
8193 case DW_AT_MIPS_linkage_name
:
8194 return "DW_AT_MIPS_linkage_name";
8195 case DW_AT_MIPS_stride
:
8196 return "DW_AT_MIPS_stride";
8197 case DW_AT_MIPS_abstract_name
:
8198 return "DW_AT_MIPS_abstract_name";
8199 case DW_AT_MIPS_clone_origin
:
8200 return "DW_AT_MIPS_clone_origin";
8201 case DW_AT_MIPS_has_inlines
:
8202 return "DW_AT_MIPS_has_inlines";
8204 /* HP extensions. */
8205 case DW_AT_HP_block_index
:
8206 return "DW_AT_HP_block_index";
8207 case DW_AT_HP_unmodifiable
:
8208 return "DW_AT_HP_unmodifiable";
8209 case DW_AT_HP_actuals_stmt_list
:
8210 return "DW_AT_HP_actuals_stmt_list";
8211 case DW_AT_HP_proc_per_section
:
8212 return "DW_AT_HP_proc_per_section";
8213 case DW_AT_HP_raw_data_ptr
:
8214 return "DW_AT_HP_raw_data_ptr";
8215 case DW_AT_HP_pass_by_reference
:
8216 return "DW_AT_HP_pass_by_reference";
8217 case DW_AT_HP_opt_level
:
8218 return "DW_AT_HP_opt_level";
8219 case DW_AT_HP_prof_version_id
:
8220 return "DW_AT_HP_prof_version_id";
8221 case DW_AT_HP_opt_flags
:
8222 return "DW_AT_HP_opt_flags";
8223 case DW_AT_HP_cold_region_low_pc
:
8224 return "DW_AT_HP_cold_region_low_pc";
8225 case DW_AT_HP_cold_region_high_pc
:
8226 return "DW_AT_HP_cold_region_high_pc";
8227 case DW_AT_HP_all_variables_modifiable
:
8228 return "DW_AT_HP_all_variables_modifiable";
8229 case DW_AT_HP_linkage_name
:
8230 return "DW_AT_HP_linkage_name";
8231 case DW_AT_HP_prof_flags
:
8232 return "DW_AT_HP_prof_flags";
8233 /* GNU extensions. */
8234 case DW_AT_sf_names
:
8235 return "DW_AT_sf_names";
8236 case DW_AT_src_info
:
8237 return "DW_AT_src_info";
8238 case DW_AT_mac_info
:
8239 return "DW_AT_mac_info";
8240 case DW_AT_src_coords
:
8241 return "DW_AT_src_coords";
8242 case DW_AT_body_begin
:
8243 return "DW_AT_body_begin";
8244 case DW_AT_body_end
:
8245 return "DW_AT_body_end";
8246 case DW_AT_GNU_vector
:
8247 return "DW_AT_GNU_vector";
8248 /* VMS extensions. */
8249 case DW_AT_VMS_rtnbeg_pd_address
:
8250 return "DW_AT_VMS_rtnbeg_pd_address";
8251 /* UPC extension. */
8252 case DW_AT_upc_threads_scaled
:
8253 return "DW_AT_upc_threads_scaled";
8254 /* PGI (STMicroelectronics) extensions. */
8255 case DW_AT_PGI_lbase
:
8256 return "DW_AT_PGI_lbase";
8257 case DW_AT_PGI_soffset
:
8258 return "DW_AT_PGI_soffset";
8259 case DW_AT_PGI_lstride
:
8260 return "DW_AT_PGI_lstride";
8262 return "DW_AT_<unknown>";
8266 /* Convert a DWARF value form code into its string name. */
8269 dwarf_form_name (unsigned form
)
8274 return "DW_FORM_addr";
8275 case DW_FORM_block2
:
8276 return "DW_FORM_block2";
8277 case DW_FORM_block4
:
8278 return "DW_FORM_block4";
8280 return "DW_FORM_data2";
8282 return "DW_FORM_data4";
8284 return "DW_FORM_data8";
8285 case DW_FORM_string
:
8286 return "DW_FORM_string";
8288 return "DW_FORM_block";
8289 case DW_FORM_block1
:
8290 return "DW_FORM_block1";
8292 return "DW_FORM_data1";
8294 return "DW_FORM_flag";
8296 return "DW_FORM_sdata";
8298 return "DW_FORM_strp";
8300 return "DW_FORM_udata";
8301 case DW_FORM_ref_addr
:
8302 return "DW_FORM_ref_addr";
8304 return "DW_FORM_ref1";
8306 return "DW_FORM_ref2";
8308 return "DW_FORM_ref4";
8310 return "DW_FORM_ref8";
8311 case DW_FORM_ref_udata
:
8312 return "DW_FORM_ref_udata";
8313 case DW_FORM_indirect
:
8314 return "DW_FORM_indirect";
8316 return "DW_FORM_<unknown>";
8320 /* Convert a DWARF stack opcode into its string name. */
8323 dwarf_stack_op_name (unsigned op
)
8328 return "DW_OP_addr";
8330 return "DW_OP_deref";
8332 return "DW_OP_const1u";
8334 return "DW_OP_const1s";
8336 return "DW_OP_const2u";
8338 return "DW_OP_const2s";
8340 return "DW_OP_const4u";
8342 return "DW_OP_const4s";
8344 return "DW_OP_const8u";
8346 return "DW_OP_const8s";
8348 return "DW_OP_constu";
8350 return "DW_OP_consts";
8354 return "DW_OP_drop";
8356 return "DW_OP_over";
8358 return "DW_OP_pick";
8360 return "DW_OP_swap";
8364 return "DW_OP_xderef";
8372 return "DW_OP_minus";
8384 return "DW_OP_plus";
8385 case DW_OP_plus_uconst
:
8386 return "DW_OP_plus_uconst";
8392 return "DW_OP_shra";
8410 return "DW_OP_skip";
8412 return "DW_OP_lit0";
8414 return "DW_OP_lit1";
8416 return "DW_OP_lit2";
8418 return "DW_OP_lit3";
8420 return "DW_OP_lit4";
8422 return "DW_OP_lit5";
8424 return "DW_OP_lit6";
8426 return "DW_OP_lit7";
8428 return "DW_OP_lit8";
8430 return "DW_OP_lit9";
8432 return "DW_OP_lit10";
8434 return "DW_OP_lit11";
8436 return "DW_OP_lit12";
8438 return "DW_OP_lit13";
8440 return "DW_OP_lit14";
8442 return "DW_OP_lit15";
8444 return "DW_OP_lit16";
8446 return "DW_OP_lit17";
8448 return "DW_OP_lit18";
8450 return "DW_OP_lit19";
8452 return "DW_OP_lit20";
8454 return "DW_OP_lit21";
8456 return "DW_OP_lit22";
8458 return "DW_OP_lit23";
8460 return "DW_OP_lit24";
8462 return "DW_OP_lit25";
8464 return "DW_OP_lit26";
8466 return "DW_OP_lit27";
8468 return "DW_OP_lit28";
8470 return "DW_OP_lit29";
8472 return "DW_OP_lit30";
8474 return "DW_OP_lit31";
8476 return "DW_OP_reg0";
8478 return "DW_OP_reg1";
8480 return "DW_OP_reg2";
8482 return "DW_OP_reg3";
8484 return "DW_OP_reg4";
8486 return "DW_OP_reg5";
8488 return "DW_OP_reg6";
8490 return "DW_OP_reg7";
8492 return "DW_OP_reg8";
8494 return "DW_OP_reg9";
8496 return "DW_OP_reg10";
8498 return "DW_OP_reg11";
8500 return "DW_OP_reg12";
8502 return "DW_OP_reg13";
8504 return "DW_OP_reg14";
8506 return "DW_OP_reg15";
8508 return "DW_OP_reg16";
8510 return "DW_OP_reg17";
8512 return "DW_OP_reg18";
8514 return "DW_OP_reg19";
8516 return "DW_OP_reg20";
8518 return "DW_OP_reg21";
8520 return "DW_OP_reg22";
8522 return "DW_OP_reg23";
8524 return "DW_OP_reg24";
8526 return "DW_OP_reg25";
8528 return "DW_OP_reg26";
8530 return "DW_OP_reg27";
8532 return "DW_OP_reg28";
8534 return "DW_OP_reg29";
8536 return "DW_OP_reg30";
8538 return "DW_OP_reg31";
8540 return "DW_OP_breg0";
8542 return "DW_OP_breg1";
8544 return "DW_OP_breg2";
8546 return "DW_OP_breg3";
8548 return "DW_OP_breg4";
8550 return "DW_OP_breg5";
8552 return "DW_OP_breg6";
8554 return "DW_OP_breg7";
8556 return "DW_OP_breg8";
8558 return "DW_OP_breg9";
8560 return "DW_OP_breg10";
8562 return "DW_OP_breg11";
8564 return "DW_OP_breg12";
8566 return "DW_OP_breg13";
8568 return "DW_OP_breg14";
8570 return "DW_OP_breg15";
8572 return "DW_OP_breg16";
8574 return "DW_OP_breg17";
8576 return "DW_OP_breg18";
8578 return "DW_OP_breg19";
8580 return "DW_OP_breg20";
8582 return "DW_OP_breg21";
8584 return "DW_OP_breg22";
8586 return "DW_OP_breg23";
8588 return "DW_OP_breg24";
8590 return "DW_OP_breg25";
8592 return "DW_OP_breg26";
8594 return "DW_OP_breg27";
8596 return "DW_OP_breg28";
8598 return "DW_OP_breg29";
8600 return "DW_OP_breg30";
8602 return "DW_OP_breg31";
8604 return "DW_OP_regx";
8606 return "DW_OP_fbreg";
8608 return "DW_OP_bregx";
8610 return "DW_OP_piece";
8611 case DW_OP_deref_size
:
8612 return "DW_OP_deref_size";
8613 case DW_OP_xderef_size
:
8614 return "DW_OP_xderef_size";
8617 /* DWARF 3 extensions. */
8618 case DW_OP_push_object_address
:
8619 return "DW_OP_push_object_address";
8621 return "DW_OP_call2";
8623 return "DW_OP_call4";
8624 case DW_OP_call_ref
:
8625 return "DW_OP_call_ref";
8626 /* GNU extensions. */
8627 case DW_OP_form_tls_address
:
8628 return "DW_OP_form_tls_address";
8629 case DW_OP_call_frame_cfa
:
8630 return "DW_OP_call_frame_cfa";
8631 case DW_OP_bit_piece
:
8632 return "DW_OP_bit_piece";
8633 case DW_OP_GNU_push_tls_address
:
8634 return "DW_OP_GNU_push_tls_address";
8635 /* HP extensions. */
8636 case DW_OP_HP_is_value
:
8637 return "DW_OP_HP_is_value";
8638 case DW_OP_HP_fltconst4
:
8639 return "DW_OP_HP_fltconst4";
8640 case DW_OP_HP_fltconst8
:
8641 return "DW_OP_HP_fltconst8";
8642 case DW_OP_HP_mod_range
:
8643 return "DW_OP_HP_mod_range";
8644 case DW_OP_HP_unmod_range
:
8645 return "DW_OP_HP_unmod_range";
8647 return "DW_OP_HP_tls";
8649 return "OP_<unknown>";
8654 dwarf_bool_name (unsigned mybool
)
8662 /* Convert a DWARF type code into its string name. */
8665 dwarf_type_encoding_name (unsigned enc
)
8670 return "DW_ATE_void";
8671 case DW_ATE_address
:
8672 return "DW_ATE_address";
8673 case DW_ATE_boolean
:
8674 return "DW_ATE_boolean";
8675 case DW_ATE_complex_float
:
8676 return "DW_ATE_complex_float";
8678 return "DW_ATE_float";
8680 return "DW_ATE_signed";
8681 case DW_ATE_signed_char
:
8682 return "DW_ATE_signed_char";
8683 case DW_ATE_unsigned
:
8684 return "DW_ATE_unsigned";
8685 case DW_ATE_unsigned_char
:
8686 return "DW_ATE_unsigned_char";
8688 case DW_ATE_imaginary_float
:
8689 return "DW_ATE_imaginary_float";
8690 case DW_ATE_packed_decimal
:
8691 return "DW_ATE_packed_decimal";
8692 case DW_ATE_numeric_string
:
8693 return "DW_ATE_numeric_string";
8695 return "DW_ATE_edited";
8696 case DW_ATE_signed_fixed
:
8697 return "DW_ATE_signed_fixed";
8698 case DW_ATE_unsigned_fixed
:
8699 return "DW_ATE_unsigned_fixed";
8700 case DW_ATE_decimal_float
:
8701 return "DW_ATE_decimal_float";
8702 /* HP extensions. */
8703 case DW_ATE_HP_float80
:
8704 return "DW_ATE_HP_float80";
8705 case DW_ATE_HP_complex_float80
:
8706 return "DW_ATE_HP_complex_float80";
8707 case DW_ATE_HP_float128
:
8708 return "DW_ATE_HP_float128";
8709 case DW_ATE_HP_complex_float128
:
8710 return "DW_ATE_HP_complex_float128";
8711 case DW_ATE_HP_floathpintel
:
8712 return "DW_ATE_HP_floathpintel";
8713 case DW_ATE_HP_imaginary_float80
:
8714 return "DW_ATE_HP_imaginary_float80";
8715 case DW_ATE_HP_imaginary_float128
:
8716 return "DW_ATE_HP_imaginary_float128";
8718 return "DW_ATE_<unknown>";
8722 /* Convert a DWARF call frame info operation to its string name. */
8726 dwarf_cfi_name (unsigned cfi_opc
)
8730 case DW_CFA_advance_loc
:
8731 return "DW_CFA_advance_loc";
8733 return "DW_CFA_offset";
8734 case DW_CFA_restore
:
8735 return "DW_CFA_restore";
8737 return "DW_CFA_nop";
8738 case DW_CFA_set_loc
:
8739 return "DW_CFA_set_loc";
8740 case DW_CFA_advance_loc1
:
8741 return "DW_CFA_advance_loc1";
8742 case DW_CFA_advance_loc2
:
8743 return "DW_CFA_advance_loc2";
8744 case DW_CFA_advance_loc4
:
8745 return "DW_CFA_advance_loc4";
8746 case DW_CFA_offset_extended
:
8747 return "DW_CFA_offset_extended";
8748 case DW_CFA_restore_extended
:
8749 return "DW_CFA_restore_extended";
8750 case DW_CFA_undefined
:
8751 return "DW_CFA_undefined";
8752 case DW_CFA_same_value
:
8753 return "DW_CFA_same_value";
8754 case DW_CFA_register
:
8755 return "DW_CFA_register";
8756 case DW_CFA_remember_state
:
8757 return "DW_CFA_remember_state";
8758 case DW_CFA_restore_state
:
8759 return "DW_CFA_restore_state";
8760 case DW_CFA_def_cfa
:
8761 return "DW_CFA_def_cfa";
8762 case DW_CFA_def_cfa_register
:
8763 return "DW_CFA_def_cfa_register";
8764 case DW_CFA_def_cfa_offset
:
8765 return "DW_CFA_def_cfa_offset";
8767 case DW_CFA_def_cfa_expression
:
8768 return "DW_CFA_def_cfa_expression";
8769 case DW_CFA_expression
:
8770 return "DW_CFA_expression";
8771 case DW_CFA_offset_extended_sf
:
8772 return "DW_CFA_offset_extended_sf";
8773 case DW_CFA_def_cfa_sf
:
8774 return "DW_CFA_def_cfa_sf";
8775 case DW_CFA_def_cfa_offset_sf
:
8776 return "DW_CFA_def_cfa_offset_sf";
8777 case DW_CFA_val_offset
:
8778 return "DW_CFA_val_offset";
8779 case DW_CFA_val_offset_sf
:
8780 return "DW_CFA_val_offset_sf";
8781 case DW_CFA_val_expression
:
8782 return "DW_CFA_val_expression";
8783 /* SGI/MIPS specific. */
8784 case DW_CFA_MIPS_advance_loc8
:
8785 return "DW_CFA_MIPS_advance_loc8";
8786 /* GNU extensions. */
8787 case DW_CFA_GNU_window_save
:
8788 return "DW_CFA_GNU_window_save";
8789 case DW_CFA_GNU_args_size
:
8790 return "DW_CFA_GNU_args_size";
8791 case DW_CFA_GNU_negative_offset_extended
:
8792 return "DW_CFA_GNU_negative_offset_extended";
8794 return "DW_CFA_<unknown>";
8800 dump_die (struct die_info
*die
)
8804 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8805 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8806 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8807 dwarf_bool_name (die
->child
!= NULL
));
8809 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8810 for (i
= 0; i
< die
->num_attrs
; ++i
)
8812 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8813 dwarf_attr_name (die
->attrs
[i
].name
),
8814 dwarf_form_name (die
->attrs
[i
].form
));
8815 switch (die
->attrs
[i
].form
)
8817 case DW_FORM_ref_addr
:
8819 fprintf_unfiltered (gdb_stderr
, "address: ");
8820 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8822 case DW_FORM_block2
:
8823 case DW_FORM_block4
:
8825 case DW_FORM_block1
:
8826 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8831 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8832 (long) (DW_ADDR (&die
->attrs
[i
])));
8840 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8842 case DW_FORM_string
:
8844 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8845 DW_STRING (&die
->attrs
[i
])
8846 ? DW_STRING (&die
->attrs
[i
]) : "");
8849 if (DW_UNSND (&die
->attrs
[i
]))
8850 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8852 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8854 case DW_FORM_indirect
:
8855 /* the reader will have reduced the indirect form to
8856 the "base form" so this form should not occur */
8857 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8860 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8861 die
->attrs
[i
].form
);
8863 fprintf_unfiltered (gdb_stderr
, "\n");
8868 dump_die_list (struct die_info
*die
)
8873 if (die
->child
!= NULL
)
8874 dump_die_list (die
->child
);
8875 if (die
->sibling
!= NULL
)
8876 dump_die_list (die
->sibling
);
8881 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8882 struct dwarf2_cu
*cu
)
8885 struct die_info
*old
;
8887 h
= (offset
% REF_HASH_SIZE
);
8888 old
= cu
->die_ref_table
[h
];
8889 die
->next_ref
= old
;
8890 cu
->die_ref_table
[h
] = die
;
8894 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8896 unsigned int result
= 0;
8900 case DW_FORM_ref_addr
:
8905 case DW_FORM_ref_udata
:
8906 result
= DW_ADDR (attr
);
8909 complaint (&symfile_complaints
,
8910 _("unsupported die ref attribute form: '%s'"),
8911 dwarf_form_name (attr
->form
));
8916 /* Return the constant value held by the given attribute. Return -1
8917 if the value held by the attribute is not constant. */
8920 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8922 if (attr
->form
== DW_FORM_sdata
)
8923 return DW_SND (attr
);
8924 else if (attr
->form
== DW_FORM_udata
8925 || attr
->form
== DW_FORM_data1
8926 || attr
->form
== DW_FORM_data2
8927 || attr
->form
== DW_FORM_data4
8928 || attr
->form
== DW_FORM_data8
)
8929 return DW_UNSND (attr
);
8932 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8933 dwarf_form_name (attr
->form
));
8934 return default_value
;
8938 static struct die_info
*
8939 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8940 struct dwarf2_cu
*cu
)
8942 struct die_info
*die
;
8943 unsigned int offset
;
8945 struct die_info temp_die
;
8946 struct dwarf2_cu
*target_cu
;
8948 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8950 if (DW_ADDR (attr
) < cu
->header
.offset
8951 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8953 struct dwarf2_per_cu_data
*per_cu
;
8954 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8956 target_cu
= per_cu
->cu
;
8961 h
= (offset
% REF_HASH_SIZE
);
8962 die
= target_cu
->die_ref_table
[h
];
8965 if (die
->offset
== offset
)
8967 die
= die
->next_ref
;
8970 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8971 "at 0x%lx [in module %s]"),
8972 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8977 static struct type
*
8978 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8979 struct dwarf2_cu
*cu
)
8981 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8983 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8984 typeid, objfile
->name
);
8987 /* Look for this particular type in the fundamental type vector. If
8988 one is not found, create and install one appropriate for the
8989 current language and the current target machine. */
8991 if (cu
->ftypes
[typeid] == NULL
)
8993 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8996 return (cu
->ftypes
[typeid]);
8999 /* Decode simple location descriptions.
9000 Given a pointer to a dwarf block that defines a location, compute
9001 the location and return the value.
9003 NOTE drow/2003-11-18: This function is called in two situations
9004 now: for the address of static or global variables (partial symbols
9005 only) and for offsets into structures which are expected to be
9006 (more or less) constant. The partial symbol case should go away,
9007 and only the constant case should remain. That will let this
9008 function complain more accurately. A few special modes are allowed
9009 without complaint for global variables (for instance, global
9010 register values and thread-local values).
9012 A location description containing no operations indicates that the
9013 object is optimized out. The return value is 0 for that case.
9014 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9015 callers will only want a very basic result and this can become a
9018 Note that stack[0] is unused except as a default error return.
9019 Note that stack overflow is not yet handled. */
9022 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9024 struct objfile
*objfile
= cu
->objfile
;
9025 struct comp_unit_head
*cu_header
= &cu
->header
;
9027 int size
= blk
->size
;
9028 gdb_byte
*data
= blk
->data
;
9029 CORE_ADDR stack
[64];
9031 unsigned int bytes_read
, unsnd
;
9075 stack
[++stacki
] = op
- DW_OP_lit0
;
9110 stack
[++stacki
] = op
- DW_OP_reg0
;
9112 dwarf2_complex_location_expr_complaint ();
9116 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9118 stack
[++stacki
] = unsnd
;
9120 dwarf2_complex_location_expr_complaint ();
9124 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9130 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9135 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9140 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9145 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9150 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9155 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9160 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9166 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9171 stack
[stacki
+ 1] = stack
[stacki
];
9176 stack
[stacki
- 1] += stack
[stacki
];
9180 case DW_OP_plus_uconst
:
9181 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9186 stack
[stacki
- 1] -= stack
[stacki
];
9191 /* If we're not the last op, then we definitely can't encode
9192 this using GDB's address_class enum. This is valid for partial
9193 global symbols, although the variable's address will be bogus
9196 dwarf2_complex_location_expr_complaint ();
9199 case DW_OP_GNU_push_tls_address
:
9200 /* The top of the stack has the offset from the beginning
9201 of the thread control block at which the variable is located. */
9202 /* Nothing should follow this operator, so the top of stack would
9204 /* This is valid for partial global symbols, but the variable's
9205 address will be bogus in the psymtab. */
9207 dwarf2_complex_location_expr_complaint ();
9211 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9212 dwarf_stack_op_name (op
));
9213 return (stack
[stacki
]);
9216 return (stack
[stacki
]);
9219 /* memory allocation interface */
9221 static struct dwarf_block
*
9222 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9224 struct dwarf_block
*blk
;
9226 blk
= (struct dwarf_block
*)
9227 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9231 static struct abbrev_info
*
9232 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9234 struct abbrev_info
*abbrev
;
9236 abbrev
= (struct abbrev_info
*)
9237 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9238 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9242 static struct die_info
*
9243 dwarf_alloc_die (void)
9245 struct die_info
*die
;
9247 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9248 memset (die
, 0, sizeof (struct die_info
));
9253 /* Macro support. */
9256 /* Return the full name of file number I in *LH's file name table.
9257 Use COMP_DIR as the name of the current directory of the
9258 compilation. The result is allocated using xmalloc; the caller is
9259 responsible for freeing it. */
9261 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9263 /* Is the file number a valid index into the line header's file name
9264 table? Remember that file numbers start with one, not zero. */
9265 if (1 <= file
&& file
<= lh
->num_file_names
)
9267 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9269 if (IS_ABSOLUTE_PATH (fe
->name
))
9270 return xstrdup (fe
->name
);
9278 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9284 dir_len
= strlen (dir
);
9285 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9286 strcpy (full_name
, dir
);
9287 full_name
[dir_len
] = '/';
9288 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9292 return xstrdup (fe
->name
);
9297 /* The compiler produced a bogus file number. We can at least
9298 record the macro definitions made in the file, even if we
9299 won't be able to find the file by name. */
9301 sprintf (fake_name
, "<bad macro file number %d>", file
);
9303 complaint (&symfile_complaints
,
9304 _("bad file number in macro information (%d)"),
9307 return xstrdup (fake_name
);
9312 static struct macro_source_file
*
9313 macro_start_file (int file
, int line
,
9314 struct macro_source_file
*current_file
,
9315 const char *comp_dir
,
9316 struct line_header
*lh
, struct objfile
*objfile
)
9318 /* The full name of this source file. */
9319 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9321 /* We don't create a macro table for this compilation unit
9322 at all until we actually get a filename. */
9323 if (! pending_macros
)
9324 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9325 objfile
->macro_cache
);
9328 /* If we have no current file, then this must be the start_file
9329 directive for the compilation unit's main source file. */
9330 current_file
= macro_set_main (pending_macros
, full_name
);
9332 current_file
= macro_include (current_file
, line
, full_name
);
9336 return current_file
;
9340 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9341 followed by a null byte. */
9343 copy_string (const char *buf
, int len
)
9345 char *s
= xmalloc (len
+ 1);
9346 memcpy (s
, buf
, len
);
9354 consume_improper_spaces (const char *p
, const char *body
)
9358 complaint (&symfile_complaints
,
9359 _("macro definition contains spaces in formal argument list:\n`%s'"),
9371 parse_macro_definition (struct macro_source_file
*file
, int line
,
9376 /* The body string takes one of two forms. For object-like macro
9377 definitions, it should be:
9379 <macro name> " " <definition>
9381 For function-like macro definitions, it should be:
9383 <macro name> "() " <definition>
9385 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9387 Spaces may appear only where explicitly indicated, and in the
9390 The Dwarf 2 spec says that an object-like macro's name is always
9391 followed by a space, but versions of GCC around March 2002 omit
9392 the space when the macro's definition is the empty string.
9394 The Dwarf 2 spec says that there should be no spaces between the
9395 formal arguments in a function-like macro's formal argument list,
9396 but versions of GCC around March 2002 include spaces after the
9400 /* Find the extent of the macro name. The macro name is terminated
9401 by either a space or null character (for an object-like macro) or
9402 an opening paren (for a function-like macro). */
9403 for (p
= body
; *p
; p
++)
9404 if (*p
== ' ' || *p
== '(')
9407 if (*p
== ' ' || *p
== '\0')
9409 /* It's an object-like macro. */
9410 int name_len
= p
- body
;
9411 char *name
= copy_string (body
, name_len
);
9412 const char *replacement
;
9415 replacement
= body
+ name_len
+ 1;
9418 dwarf2_macro_malformed_definition_complaint (body
);
9419 replacement
= body
+ name_len
;
9422 macro_define_object (file
, line
, name
, replacement
);
9428 /* It's a function-like macro. */
9429 char *name
= copy_string (body
, p
- body
);
9432 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9436 p
= consume_improper_spaces (p
, body
);
9438 /* Parse the formal argument list. */
9439 while (*p
&& *p
!= ')')
9441 /* Find the extent of the current argument name. */
9442 const char *arg_start
= p
;
9444 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9447 if (! *p
|| p
== arg_start
)
9448 dwarf2_macro_malformed_definition_complaint (body
);
9451 /* Make sure argv has room for the new argument. */
9452 if (argc
>= argv_size
)
9455 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9458 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9461 p
= consume_improper_spaces (p
, body
);
9463 /* Consume the comma, if present. */
9468 p
= consume_improper_spaces (p
, body
);
9477 /* Perfectly formed definition, no complaints. */
9478 macro_define_function (file
, line
, name
,
9479 argc
, (const char **) argv
,
9481 else if (*p
== '\0')
9483 /* Complain, but do define it. */
9484 dwarf2_macro_malformed_definition_complaint (body
);
9485 macro_define_function (file
, line
, name
,
9486 argc
, (const char **) argv
,
9490 /* Just complain. */
9491 dwarf2_macro_malformed_definition_complaint (body
);
9494 /* Just complain. */
9495 dwarf2_macro_malformed_definition_complaint (body
);
9501 for (i
= 0; i
< argc
; i
++)
9507 dwarf2_macro_malformed_definition_complaint (body
);
9512 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9513 char *comp_dir
, bfd
*abfd
,
9514 struct dwarf2_cu
*cu
)
9516 gdb_byte
*mac_ptr
, *mac_end
;
9517 struct macro_source_file
*current_file
= 0;
9519 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9521 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9525 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9526 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9527 + dwarf2_per_objfile
->macinfo_size
;
9531 enum dwarf_macinfo_record_type macinfo_type
;
9533 /* Do we at least have room for a macinfo type byte? */
9534 if (mac_ptr
>= mac_end
)
9536 dwarf2_macros_too_long_complaint ();
9540 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9543 switch (macinfo_type
)
9545 /* A zero macinfo type indicates the end of the macro
9550 case DW_MACINFO_define
:
9551 case DW_MACINFO_undef
:
9553 unsigned int bytes_read
;
9557 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9558 mac_ptr
+= bytes_read
;
9559 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9560 mac_ptr
+= bytes_read
;
9563 complaint (&symfile_complaints
,
9564 _("debug info gives macro %s outside of any file: %s"),
9566 DW_MACINFO_define
? "definition" : macinfo_type
==
9567 DW_MACINFO_undef
? "undefinition" :
9568 "something-or-other", body
);
9571 if (macinfo_type
== DW_MACINFO_define
)
9572 parse_macro_definition (current_file
, line
, body
);
9573 else if (macinfo_type
== DW_MACINFO_undef
)
9574 macro_undef (current_file
, line
, body
);
9579 case DW_MACINFO_start_file
:
9581 unsigned int bytes_read
;
9584 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9585 mac_ptr
+= bytes_read
;
9586 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9587 mac_ptr
+= bytes_read
;
9589 current_file
= macro_start_file (file
, line
,
9590 current_file
, comp_dir
,
9595 case DW_MACINFO_end_file
:
9597 complaint (&symfile_complaints
,
9598 _("macro debug info has an unmatched `close_file' directive"));
9601 current_file
= current_file
->included_by
;
9604 enum dwarf_macinfo_record_type next_type
;
9606 /* GCC circa March 2002 doesn't produce the zero
9607 type byte marking the end of the compilation
9608 unit. Complain if it's not there, but exit no
9611 /* Do we at least have room for a macinfo type byte? */
9612 if (mac_ptr
>= mac_end
)
9614 dwarf2_macros_too_long_complaint ();
9618 /* We don't increment mac_ptr here, so this is just
9620 next_type
= read_1_byte (abfd
, mac_ptr
);
9622 complaint (&symfile_complaints
,
9623 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9630 case DW_MACINFO_vendor_ext
:
9632 unsigned int bytes_read
;
9636 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9637 mac_ptr
+= bytes_read
;
9638 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9639 mac_ptr
+= bytes_read
;
9641 /* We don't recognize any vendor extensions. */
9648 /* Check if the attribute's form is a DW_FORM_block*
9649 if so return true else false. */
9651 attr_form_is_block (struct attribute
*attr
)
9653 return (attr
== NULL
? 0 :
9654 attr
->form
== DW_FORM_block1
9655 || attr
->form
== DW_FORM_block2
9656 || attr
->form
== DW_FORM_block4
9657 || attr
->form
== DW_FORM_block
);
9661 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9662 struct dwarf2_cu
*cu
)
9664 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9665 /* ".debug_loc" may not exist at all, or the offset may be outside
9666 the section. If so, fall through to the complaint in the
9668 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9670 struct dwarf2_loclist_baton
*baton
;
9672 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9673 sizeof (struct dwarf2_loclist_baton
));
9674 baton
->objfile
= cu
->objfile
;
9676 /* We don't know how long the location list is, but make sure we
9677 don't run off the edge of the section. */
9678 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9679 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9680 baton
->base_address
= cu
->header
.base_address
;
9681 if (cu
->header
.base_known
== 0)
9682 complaint (&symfile_complaints
,
9683 _("Location list used without specifying the CU base address."));
9685 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9686 SYMBOL_LOCATION_BATON (sym
) = baton
;
9690 struct dwarf2_locexpr_baton
*baton
;
9692 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9693 sizeof (struct dwarf2_locexpr_baton
));
9694 baton
->objfile
= cu
->objfile
;
9696 if (attr_form_is_block (attr
))
9698 /* Note that we're just copying the block's data pointer
9699 here, not the actual data. We're still pointing into the
9700 info_buffer for SYM's objfile; right now we never release
9701 that buffer, but when we do clean up properly this may
9703 baton
->size
= DW_BLOCK (attr
)->size
;
9704 baton
->data
= DW_BLOCK (attr
)->data
;
9708 dwarf2_invalid_attrib_class_complaint ("location description",
9709 SYMBOL_NATURAL_NAME (sym
));
9714 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9715 SYMBOL_LOCATION_BATON (sym
) = baton
;
9719 /* Locate the compilation unit from CU's objfile which contains the
9720 DIE at OFFSET. Raises an error on failure. */
9722 static struct dwarf2_per_cu_data
*
9723 dwarf2_find_containing_comp_unit (unsigned long offset
,
9724 struct objfile
*objfile
)
9726 struct dwarf2_per_cu_data
*this_cu
;
9730 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9733 int mid
= low
+ (high
- low
) / 2;
9734 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9739 gdb_assert (low
== high
);
9740 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9743 error (_("Dwarf Error: could not find partial DIE containing "
9744 "offset 0x%lx [in module %s]"),
9745 (long) offset
, bfd_get_filename (objfile
->obfd
));
9747 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9748 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9752 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9753 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9754 && offset
>= this_cu
->offset
+ this_cu
->length
)
9755 error (_("invalid dwarf2 offset %ld"), offset
);
9756 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9761 /* Locate the compilation unit from OBJFILE which is located at exactly
9762 OFFSET. Raises an error on failure. */
9764 static struct dwarf2_per_cu_data
*
9765 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9767 struct dwarf2_per_cu_data
*this_cu
;
9768 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9769 if (this_cu
->offset
!= offset
)
9770 error (_("no compilation unit with offset %ld."), offset
);
9774 /* Release one cached compilation unit, CU. We unlink it from the tree
9775 of compilation units, but we don't remove it from the read_in_chain;
9776 the caller is responsible for that. */
9779 free_one_comp_unit (void *data
)
9781 struct dwarf2_cu
*cu
= data
;
9783 if (cu
->per_cu
!= NULL
)
9784 cu
->per_cu
->cu
= NULL
;
9787 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9789 free_die_list (cu
->dies
);
9794 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9795 when we're finished with it. We can't free the pointer itself, but be
9796 sure to unlink it from the cache. Also release any associated storage
9797 and perform cache maintenance.
9799 Only used during partial symbol parsing. */
9802 free_stack_comp_unit (void *data
)
9804 struct dwarf2_cu
*cu
= data
;
9806 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9807 cu
->partial_dies
= NULL
;
9809 if (cu
->per_cu
!= NULL
)
9811 /* This compilation unit is on the stack in our caller, so we
9812 should not xfree it. Just unlink it. */
9813 cu
->per_cu
->cu
= NULL
;
9816 /* If we had a per-cu pointer, then we may have other compilation
9817 units loaded, so age them now. */
9818 age_cached_comp_units ();
9822 /* Free all cached compilation units. */
9825 free_cached_comp_units (void *data
)
9827 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9829 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9830 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9831 while (per_cu
!= NULL
)
9833 struct dwarf2_per_cu_data
*next_cu
;
9835 next_cu
= per_cu
->cu
->read_in_chain
;
9837 free_one_comp_unit (per_cu
->cu
);
9838 *last_chain
= next_cu
;
9844 /* Increase the age counter on each cached compilation unit, and free
9845 any that are too old. */
9848 age_cached_comp_units (void)
9850 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9852 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9853 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9854 while (per_cu
!= NULL
)
9856 per_cu
->cu
->last_used
++;
9857 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9858 dwarf2_mark (per_cu
->cu
);
9859 per_cu
= per_cu
->cu
->read_in_chain
;
9862 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9863 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9864 while (per_cu
!= NULL
)
9866 struct dwarf2_per_cu_data
*next_cu
;
9868 next_cu
= per_cu
->cu
->read_in_chain
;
9870 if (!per_cu
->cu
->mark
)
9872 free_one_comp_unit (per_cu
->cu
);
9873 *last_chain
= next_cu
;
9876 last_chain
= &per_cu
->cu
->read_in_chain
;
9882 /* Remove a single compilation unit from the cache. */
9885 free_one_cached_comp_unit (void *target_cu
)
9887 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9889 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9890 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9891 while (per_cu
!= NULL
)
9893 struct dwarf2_per_cu_data
*next_cu
;
9895 next_cu
= per_cu
->cu
->read_in_chain
;
9897 if (per_cu
->cu
== target_cu
)
9899 free_one_comp_unit (per_cu
->cu
);
9900 *last_chain
= next_cu
;
9904 last_chain
= &per_cu
->cu
->read_in_chain
;
9910 /* A pair of DIE offset and GDB type pointer. We store these
9911 in a hash table separate from the DIEs, and preserve them
9912 when the DIEs are flushed out of cache. */
9914 struct dwarf2_offset_and_type
9916 unsigned int offset
;
9920 /* Hash function for a dwarf2_offset_and_type. */
9923 offset_and_type_hash (const void *item
)
9925 const struct dwarf2_offset_and_type
*ofs
= item
;
9929 /* Equality function for a dwarf2_offset_and_type. */
9932 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9934 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9935 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9936 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9939 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9940 table if necessary. */
9943 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9945 struct dwarf2_offset_and_type
**slot
, ofs
;
9949 if (cu
->per_cu
== NULL
)
9952 if (cu
->per_cu
->type_hash
== NULL
)
9953 cu
->per_cu
->type_hash
9954 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9955 offset_and_type_hash
,
9958 &cu
->objfile
->objfile_obstack
,
9959 hashtab_obstack_allocate
,
9960 dummy_obstack_deallocate
);
9962 ofs
.offset
= die
->offset
;
9964 slot
= (struct dwarf2_offset_and_type
**)
9965 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9966 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9970 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9971 have a saved type. */
9973 static struct type
*
9974 get_die_type (struct die_info
*die
, htab_t type_hash
)
9976 struct dwarf2_offset_and_type
*slot
, ofs
;
9978 ofs
.offset
= die
->offset
;
9979 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9986 /* Restore the types of the DIE tree starting at START_DIE from the hash
9987 table saved in CU. */
9990 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9992 struct die_info
*die
;
9994 if (cu
->per_cu
->type_hash
== NULL
)
9997 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9999 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
10000 if (die
->child
!= NULL
)
10001 reset_die_and_siblings_types (die
->child
, cu
);
10005 /* Set the mark field in CU and in every other compilation unit in the
10006 cache that we must keep because we are keeping CU. */
10008 /* Add a dependence relationship from CU to REF_PER_CU. */
10011 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10012 struct dwarf2_per_cu_data
*ref_per_cu
)
10016 if (cu
->dependencies
== NULL
)
10018 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10019 NULL
, &cu
->comp_unit_obstack
,
10020 hashtab_obstack_allocate
,
10021 dummy_obstack_deallocate
);
10023 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10025 *slot
= ref_per_cu
;
10028 /* Set the mark field in CU and in every other compilation unit in the
10029 cache that we must keep because we are keeping CU. */
10032 dwarf2_mark_helper (void **slot
, void *data
)
10034 struct dwarf2_per_cu_data
*per_cu
;
10036 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10037 if (per_cu
->cu
->mark
)
10039 per_cu
->cu
->mark
= 1;
10041 if (per_cu
->cu
->dependencies
!= NULL
)
10042 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10048 dwarf2_mark (struct dwarf2_cu
*cu
)
10053 if (cu
->dependencies
!= NULL
)
10054 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10058 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10062 per_cu
->cu
->mark
= 0;
10063 per_cu
= per_cu
->cu
->read_in_chain
;
10067 /* Trivial hash function for partial_die_info: the hash value of a DIE
10068 is its offset in .debug_info for this objfile. */
10071 partial_die_hash (const void *item
)
10073 const struct partial_die_info
*part_die
= item
;
10074 return part_die
->offset
;
10077 /* Trivial comparison function for partial_die_info structures: two DIEs
10078 are equal if they have the same offset. */
10081 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10083 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10084 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10085 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10088 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10089 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10092 set_dwarf2_cmd (char *args
, int from_tty
)
10094 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10098 show_dwarf2_cmd (char *args
, int from_tty
)
10100 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10103 void _initialize_dwarf2_read (void);
10106 _initialize_dwarf2_read (void)
10108 dwarf2_objfile_data_key
= register_objfile_data ();
10110 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10111 Set DWARF 2 specific variables.\n\
10112 Configure DWARF 2 variables such as the cache size"),
10113 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10114 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10116 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10117 Show DWARF 2 specific variables\n\
10118 Show DWARF 2 variables such as the cache size"),
10119 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10120 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10122 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10123 &dwarf2_max_cache_age
, _("\
10124 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10125 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10126 A higher limit means that cached compilation units will be stored\n\
10127 in memory longer, and more total memory will be used. Zero disables\n\
10128 caching, which can slow down startup."),
10130 show_dwarf2_max_cache_age
,
10131 &set_dwarf2_cmdlist
,
10132 &show_dwarf2_cmdlist
);