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
11 support in dwarfread.c
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
)
2009 /* For C++ and Java, these implicitly act as typedefs as well. */
2010 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2011 VAR_DOMAIN
, LOC_TYPEDEF
,
2012 &objfile
->global_psymbols
,
2013 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2016 case DW_TAG_enumerator
:
2017 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2018 VAR_DOMAIN
, LOC_CONST
,
2019 (cu
->language
== language_cplus
2020 || cu
->language
== language_java
)
2021 ? &objfile
->global_psymbols
2022 : &objfile
->static_psymbols
,
2023 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2029 /* Check to see if we should scan the name for possible namespace
2030 info. Only do this if this is C++, if we don't have namespace
2031 debugging info in the file, if the psym is of an appropriate type
2032 (otherwise we'll have psym == NULL), and if we actually had a
2033 mangled name to begin with. */
2035 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2036 cases which do not set PSYM above? */
2038 if (cu
->language
== language_cplus
2039 && cu
->has_namespace_info
== 0
2041 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2042 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2045 if (built_actual_name
)
2046 xfree (actual_name
);
2049 /* Determine whether a die of type TAG living in a C++ class or
2050 namespace needs to have the name of the scope prepended to the
2051 name listed in the die. */
2054 pdi_needs_namespace (enum dwarf_tag tag
)
2058 case DW_TAG_namespace
:
2059 case DW_TAG_typedef
:
2060 case DW_TAG_class_type
:
2061 case DW_TAG_structure_type
:
2062 case DW_TAG_union_type
:
2063 case DW_TAG_enumeration_type
:
2064 case DW_TAG_enumerator
:
2071 /* Read a partial die corresponding to a namespace; also, add a symbol
2072 corresponding to that namespace to the symbol table. NAMESPACE is
2073 the name of the enclosing namespace. */
2076 add_partial_namespace (struct partial_die_info
*pdi
,
2077 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2078 struct dwarf2_cu
*cu
)
2080 struct objfile
*objfile
= cu
->objfile
;
2082 /* Add a symbol for the namespace. */
2084 add_partial_symbol (pdi
, cu
);
2086 /* Now scan partial symbols in that namespace. */
2088 if (pdi
->has_children
)
2089 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2092 /* See if we can figure out if the class lives in a namespace. We do
2093 this by looking for a member function; its demangled name will
2094 contain namespace info, if there is any. */
2097 guess_structure_name (struct partial_die_info
*struct_pdi
,
2098 struct dwarf2_cu
*cu
)
2100 if ((cu
->language
== language_cplus
2101 || cu
->language
== language_java
)
2102 && cu
->has_namespace_info
== 0
2103 && struct_pdi
->has_children
)
2105 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2106 what template types look like, because the demangler
2107 frequently doesn't give the same name as the debug info. We
2108 could fix this by only using the demangled name to get the
2109 prefix (but see comment in read_structure_type). */
2111 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2112 struct partial_die_info
*real_pdi
;
2114 /* If this DIE (this DIE's specification, if any) has a parent, then
2115 we should not do this. We'll prepend the parent's fully qualified
2116 name when we create the partial symbol. */
2118 real_pdi
= struct_pdi
;
2119 while (real_pdi
->has_specification
)
2120 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2122 if (real_pdi
->die_parent
!= NULL
)
2125 while (child_pdi
!= NULL
)
2127 if (child_pdi
->tag
== DW_TAG_subprogram
)
2129 char *actual_class_name
2130 = language_class_name_from_physname (cu
->language_defn
,
2132 if (actual_class_name
!= NULL
)
2135 = obsavestring (actual_class_name
,
2136 strlen (actual_class_name
),
2137 &cu
->comp_unit_obstack
);
2138 xfree (actual_class_name
);
2143 child_pdi
= child_pdi
->die_sibling
;
2148 /* Read a partial die corresponding to an enumeration type. */
2151 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2152 struct dwarf2_cu
*cu
)
2154 struct objfile
*objfile
= cu
->objfile
;
2155 bfd
*abfd
= objfile
->obfd
;
2156 struct partial_die_info
*pdi
;
2158 if (enum_pdi
->name
!= NULL
)
2159 add_partial_symbol (enum_pdi
, cu
);
2161 pdi
= enum_pdi
->die_child
;
2164 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2165 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2167 add_partial_symbol (pdi
, cu
);
2168 pdi
= pdi
->die_sibling
;
2172 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2173 Return the corresponding abbrev, or NULL if the number is zero (indicating
2174 an empty DIE). In either case *BYTES_READ will be set to the length of
2175 the initial number. */
2177 static struct abbrev_info
*
2178 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2179 struct dwarf2_cu
*cu
)
2181 bfd
*abfd
= cu
->objfile
->obfd
;
2182 unsigned int abbrev_number
;
2183 struct abbrev_info
*abbrev
;
2185 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2187 if (abbrev_number
== 0)
2190 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2193 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2194 bfd_get_filename (abfd
));
2200 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2201 pointer to the end of a series of DIEs, terminated by an empty
2202 DIE. Any children of the skipped DIEs will also be skipped. */
2205 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2207 struct abbrev_info
*abbrev
;
2208 unsigned int bytes_read
;
2212 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2214 return info_ptr
+ bytes_read
;
2216 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2220 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2221 should point just after the initial uleb128 of a DIE, and the
2222 abbrev corresponding to that skipped uleb128 should be passed in
2223 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2227 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2228 struct dwarf2_cu
*cu
)
2230 unsigned int bytes_read
;
2231 struct attribute attr
;
2232 bfd
*abfd
= cu
->objfile
->obfd
;
2233 unsigned int form
, i
;
2235 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2237 /* The only abbrev we care about is DW_AT_sibling. */
2238 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2240 read_attribute (&attr
, &abbrev
->attrs
[i
],
2241 abfd
, info_ptr
, cu
);
2242 if (attr
.form
== DW_FORM_ref_addr
)
2243 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2245 return dwarf2_per_objfile
->info_buffer
2246 + dwarf2_get_ref_die_offset (&attr
, cu
);
2249 /* If it isn't DW_AT_sibling, skip this attribute. */
2250 form
= abbrev
->attrs
[i
].form
;
2255 case DW_FORM_ref_addr
:
2256 info_ptr
+= cu
->header
.addr_size
;
2275 case DW_FORM_string
:
2276 read_string (abfd
, info_ptr
, &bytes_read
);
2277 info_ptr
+= bytes_read
;
2280 info_ptr
+= cu
->header
.offset_size
;
2283 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2284 info_ptr
+= bytes_read
;
2286 case DW_FORM_block1
:
2287 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2289 case DW_FORM_block2
:
2290 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2292 case DW_FORM_block4
:
2293 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2297 case DW_FORM_ref_udata
:
2298 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2300 case DW_FORM_indirect
:
2301 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2302 info_ptr
+= bytes_read
;
2303 /* We need to continue parsing from here, so just go back to
2305 goto skip_attribute
;
2308 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2309 dwarf_form_name (form
),
2310 bfd_get_filename (abfd
));
2314 if (abbrev
->has_children
)
2315 return skip_children (info_ptr
, cu
);
2320 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2321 the next DIE after ORIG_PDI. */
2324 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2325 bfd
*abfd
, struct dwarf2_cu
*cu
)
2327 /* Do we know the sibling already? */
2329 if (orig_pdi
->sibling
)
2330 return orig_pdi
->sibling
;
2332 /* Are there any children to deal with? */
2334 if (!orig_pdi
->has_children
)
2337 /* Skip the children the long way. */
2339 return skip_children (info_ptr
, cu
);
2342 /* Expand this partial symbol table into a full symbol table. */
2345 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2347 /* FIXME: This is barely more than a stub. */
2352 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2358 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2359 gdb_flush (gdb_stdout
);
2362 /* Restore our global data. */
2363 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2364 dwarf2_objfile_data_key
);
2366 psymtab_to_symtab_1 (pst
);
2368 /* Finish up the debug error message. */
2370 printf_filtered (_("done.\n"));
2375 /* Add PER_CU to the queue. */
2378 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2380 struct dwarf2_queue_item
*item
;
2383 item
= xmalloc (sizeof (*item
));
2384 item
->per_cu
= per_cu
;
2387 if (dwarf2_queue
== NULL
)
2388 dwarf2_queue
= item
;
2390 dwarf2_queue_tail
->next
= item
;
2392 dwarf2_queue_tail
= item
;
2395 /* Process the queue. */
2398 process_queue (struct objfile
*objfile
)
2400 struct dwarf2_queue_item
*item
, *next_item
;
2402 /* Initially, there is just one item on the queue. Load its DIEs,
2403 and the DIEs of any other compilation units it requires,
2406 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2408 /* Read in this compilation unit. This may add new items to
2409 the end of the queue. */
2410 load_full_comp_unit (item
->per_cu
, objfile
);
2412 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2413 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2415 /* If this compilation unit has already had full symbols created,
2416 reset the TYPE fields in each DIE. */
2417 if (item
->per_cu
->type_hash
)
2418 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2422 /* Now everything left on the queue needs to be read in. Process
2423 them, one at a time, removing from the queue as we finish. */
2424 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2426 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2427 process_full_comp_unit (item
->per_cu
);
2429 item
->per_cu
->queued
= 0;
2430 next_item
= item
->next
;
2434 dwarf2_queue_tail
= NULL
;
2437 /* Free all allocated queue entries. This function only releases anything if
2438 an error was thrown; if the queue was processed then it would have been
2439 freed as we went along. */
2442 dwarf2_release_queue (void *dummy
)
2444 struct dwarf2_queue_item
*item
, *last
;
2446 item
= dwarf2_queue
;
2449 /* Anything still marked queued is likely to be in an
2450 inconsistent state, so discard it. */
2451 if (item
->per_cu
->queued
)
2453 if (item
->per_cu
->cu
!= NULL
)
2454 free_one_cached_comp_unit (item
->per_cu
->cu
);
2455 item
->per_cu
->queued
= 0;
2463 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2466 /* Read in full symbols for PST, and anything it depends on. */
2469 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2471 struct dwarf2_per_cu_data
*per_cu
;
2472 struct cleanup
*back_to
;
2475 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2476 if (!pst
->dependencies
[i
]->readin
)
2478 /* Inform about additional files that need to be read in. */
2481 /* FIXME: i18n: Need to make this a single string. */
2482 fputs_filtered (" ", gdb_stdout
);
2484 fputs_filtered ("and ", gdb_stdout
);
2486 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2487 wrap_here (""); /* Flush output */
2488 gdb_flush (gdb_stdout
);
2490 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2493 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2497 /* It's an include file, no symbols to read for it.
2498 Everything is in the parent symtab. */
2503 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2505 queue_comp_unit (per_cu
);
2507 process_queue (pst
->objfile
);
2509 /* Age the cache, releasing compilation units that have not
2510 been used recently. */
2511 age_cached_comp_units ();
2513 do_cleanups (back_to
);
2516 /* Load the DIEs associated with PST and PER_CU into memory. */
2518 static struct dwarf2_cu
*
2519 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2521 bfd
*abfd
= objfile
->obfd
;
2522 struct dwarf2_cu
*cu
;
2523 unsigned long offset
;
2525 struct cleanup
*back_to
, *free_cu_cleanup
;
2526 struct attribute
*attr
;
2529 /* Set local variables from the partial symbol table info. */
2530 offset
= per_cu
->offset
;
2532 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2534 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2535 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2537 /* If an error occurs while loading, release our storage. */
2538 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2540 cu
->objfile
= objfile
;
2542 /* read in the comp_unit header */
2543 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2545 /* Read the abbrevs for this compilation unit */
2546 dwarf2_read_abbrevs (abfd
, cu
);
2547 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2549 cu
->header
.offset
= offset
;
2551 cu
->per_cu
= per_cu
;
2554 /* We use this obstack for block values in dwarf_alloc_block. */
2555 obstack_init (&cu
->comp_unit_obstack
);
2557 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2559 /* We try not to read any attributes in this function, because not
2560 all objfiles needed for references have been loaded yet, and symbol
2561 table processing isn't initialized. But we have to set the CU language,
2562 or we won't be able to build types correctly. */
2563 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2565 set_cu_language (DW_UNSND (attr
), cu
);
2567 set_cu_language (language_minimal
, cu
);
2569 do_cleanups (back_to
);
2571 /* We've successfully allocated this compilation unit. Let our caller
2572 clean it up when finished with it. */
2573 discard_cleanups (free_cu_cleanup
);
2578 /* Generate full symbol information for PST and CU, whose DIEs have
2579 already been loaded into memory. */
2582 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2584 struct partial_symtab
*pst
= per_cu
->psymtab
;
2585 struct dwarf2_cu
*cu
= per_cu
->cu
;
2586 struct objfile
*objfile
= pst
->objfile
;
2587 bfd
*abfd
= objfile
->obfd
;
2588 CORE_ADDR lowpc
, highpc
;
2589 struct symtab
*symtab
;
2590 struct cleanup
*back_to
;
2591 struct attribute
*attr
;
2594 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2596 /* We're in the global namespace. */
2597 processing_current_prefix
= "";
2600 back_to
= make_cleanup (really_free_pendings
, NULL
);
2602 cu
->list_in_scope
= &file_symbols
;
2604 /* Find the base address of the compilation unit for range lists and
2605 location lists. It will normally be specified by DW_AT_low_pc.
2606 In DWARF-3 draft 4, the base address could be overridden by
2607 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2608 compilation units with discontinuous ranges. */
2610 cu
->header
.base_known
= 0;
2611 cu
->header
.base_address
= 0;
2613 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2616 cu
->header
.base_address
= DW_ADDR (attr
);
2617 cu
->header
.base_known
= 1;
2621 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2624 cu
->header
.base_address
= DW_ADDR (attr
);
2625 cu
->header
.base_known
= 1;
2629 /* Do line number decoding in read_file_scope () */
2630 process_die (cu
->dies
, cu
);
2632 /* Some compilers don't define a DW_AT_high_pc attribute for the
2633 compilation unit. If the DW_AT_high_pc is missing, synthesize
2634 it, by scanning the DIE's below the compilation unit. */
2635 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2637 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2639 /* Set symtab language to language from DW_AT_language.
2640 If the compilation is from a C file generated by language preprocessors,
2641 do not set the language if it was already deduced by start_subfile. */
2643 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2645 symtab
->language
= cu
->language
;
2647 pst
->symtab
= symtab
;
2650 do_cleanups (back_to
);
2653 /* Process a die and its children. */
2656 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2660 case DW_TAG_padding
:
2662 case DW_TAG_compile_unit
:
2663 read_file_scope (die
, cu
);
2665 case DW_TAG_subprogram
:
2666 read_subroutine_type (die
, cu
);
2667 read_func_scope (die
, cu
);
2669 case DW_TAG_inlined_subroutine
:
2670 /* FIXME: These are ignored for now.
2671 They could be used to set breakpoints on all inlined instances
2672 of a function and make GDB `next' properly over inlined functions. */
2674 case DW_TAG_lexical_block
:
2675 case DW_TAG_try_block
:
2676 case DW_TAG_catch_block
:
2677 read_lexical_block_scope (die
, cu
);
2679 case DW_TAG_class_type
:
2680 case DW_TAG_structure_type
:
2681 case DW_TAG_union_type
:
2682 read_structure_type (die
, cu
);
2683 process_structure_scope (die
, cu
);
2685 case DW_TAG_enumeration_type
:
2686 read_enumeration_type (die
, cu
);
2687 process_enumeration_scope (die
, cu
);
2690 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2691 a symbol or process any children. Therefore it doesn't do anything
2692 that won't be done on-demand by read_type_die. */
2693 case DW_TAG_subroutine_type
:
2694 read_subroutine_type (die
, cu
);
2696 case DW_TAG_set_type
:
2697 read_set_type (die
, cu
);
2699 case DW_TAG_array_type
:
2700 read_array_type (die
, cu
);
2702 case DW_TAG_pointer_type
:
2703 read_tag_pointer_type (die
, cu
);
2705 case DW_TAG_ptr_to_member_type
:
2706 read_tag_ptr_to_member_type (die
, cu
);
2708 case DW_TAG_reference_type
:
2709 read_tag_reference_type (die
, cu
);
2711 case DW_TAG_string_type
:
2712 read_tag_string_type (die
, cu
);
2716 case DW_TAG_base_type
:
2717 read_base_type (die
, cu
);
2718 /* Add a typedef symbol for the type definition, if it has a
2720 new_symbol (die
, die
->type
, cu
);
2722 case DW_TAG_subrange_type
:
2723 read_subrange_type (die
, cu
);
2724 /* Add a typedef symbol for the type definition, if it has a
2726 new_symbol (die
, die
->type
, cu
);
2728 case DW_TAG_common_block
:
2729 read_common_block (die
, cu
);
2731 case DW_TAG_common_inclusion
:
2733 case DW_TAG_namespace
:
2734 processing_has_namespace_info
= 1;
2735 read_namespace (die
, cu
);
2737 case DW_TAG_imported_declaration
:
2738 case DW_TAG_imported_module
:
2739 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2740 information contained in these. DW_TAG_imported_declaration
2741 dies shouldn't have children; DW_TAG_imported_module dies
2742 shouldn't in the C++ case, but conceivably could in the
2743 Fortran case, so we'll have to replace this gdb_assert if
2744 Fortran compilers start generating that info. */
2745 processing_has_namespace_info
= 1;
2746 gdb_assert (die
->child
== NULL
);
2749 new_symbol (die
, NULL
, cu
);
2755 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2757 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2761 free_cu_line_header (void *arg
)
2763 struct dwarf2_cu
*cu
= arg
;
2765 free_line_header (cu
->line_header
);
2766 cu
->line_header
= NULL
;
2770 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2772 struct objfile
*objfile
= cu
->objfile
;
2773 struct comp_unit_head
*cu_header
= &cu
->header
;
2774 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2775 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2776 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2777 struct attribute
*attr
;
2778 char *name
= "<unknown>";
2779 char *comp_dir
= NULL
;
2780 struct die_info
*child_die
;
2781 bfd
*abfd
= objfile
->obfd
;
2782 struct line_header
*line_header
= 0;
2785 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2787 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2789 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2790 from finish_block. */
2791 if (lowpc
== ((CORE_ADDR
) -1))
2796 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2799 name
= DW_STRING (attr
);
2801 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2804 comp_dir
= DW_STRING (attr
);
2807 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2808 directory, get rid of it. */
2809 char *cp
= strchr (comp_dir
, ':');
2811 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2816 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2819 set_cu_language (DW_UNSND (attr
), cu
);
2822 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2824 cu
->producer
= DW_STRING (attr
);
2826 /* We assume that we're processing GCC output. */
2827 processing_gcc_compilation
= 2;
2829 /* The compilation unit may be in a different language or objfile,
2830 zero out all remembered fundamental types. */
2831 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2833 start_symtab (name
, comp_dir
, lowpc
);
2834 record_debugformat ("DWARF 2");
2835 record_producer (cu
->producer
);
2837 initialize_cu_func_list (cu
);
2839 /* Decode line number information if present. We do this before
2840 processing child DIEs, so that the line header table is available
2841 for DW_AT_decl_file. */
2842 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2845 unsigned int line_offset
= DW_UNSND (attr
);
2846 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2849 cu
->line_header
= line_header
;
2850 make_cleanup (free_cu_line_header
, cu
);
2851 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2855 /* Process all dies in compilation unit. */
2856 if (die
->child
!= NULL
)
2858 child_die
= die
->child
;
2859 while (child_die
&& child_die
->tag
)
2861 process_die (child_die
, cu
);
2862 child_die
= sibling_die (child_die
);
2866 /* Decode macro information, if present. Dwarf 2 macro information
2867 refers to information in the line number info statement program
2868 header, so we can only read it if we've read the header
2870 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2871 if (attr
&& line_header
)
2873 unsigned int macro_offset
= DW_UNSND (attr
);
2874 dwarf_decode_macros (line_header
, macro_offset
,
2875 comp_dir
, abfd
, cu
);
2877 do_cleanups (back_to
);
2881 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2882 struct dwarf2_cu
*cu
)
2884 struct function_range
*thisfn
;
2886 thisfn
= (struct function_range
*)
2887 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2888 thisfn
->name
= name
;
2889 thisfn
->lowpc
= lowpc
;
2890 thisfn
->highpc
= highpc
;
2891 thisfn
->seen_line
= 0;
2892 thisfn
->next
= NULL
;
2894 if (cu
->last_fn
== NULL
)
2895 cu
->first_fn
= thisfn
;
2897 cu
->last_fn
->next
= thisfn
;
2899 cu
->last_fn
= thisfn
;
2903 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2905 struct objfile
*objfile
= cu
->objfile
;
2906 struct context_stack
*new;
2909 struct die_info
*child_die
;
2910 struct attribute
*attr
;
2912 const char *previous_prefix
= processing_current_prefix
;
2913 struct cleanup
*back_to
= NULL
;
2916 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2918 name
= dwarf2_linkage_name (die
, cu
);
2920 /* Ignore functions with missing or empty names and functions with
2921 missing or invalid low and high pc attributes. */
2922 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2925 if (cu
->language
== language_cplus
2926 || cu
->language
== language_java
)
2928 struct die_info
*spec_die
= die_specification (die
, cu
);
2930 /* NOTE: carlton/2004-01-23: We have to be careful in the
2931 presence of DW_AT_specification. For example, with GCC 3.4,
2936 // Definition of N::foo.
2940 then we'll have a tree of DIEs like this:
2942 1: DW_TAG_compile_unit
2943 2: DW_TAG_namespace // N
2944 3: DW_TAG_subprogram // declaration of N::foo
2945 4: DW_TAG_subprogram // definition of N::foo
2946 DW_AT_specification // refers to die #3
2948 Thus, when processing die #4, we have to pretend that we're
2949 in the context of its DW_AT_specification, namely the contex
2952 if (spec_die
!= NULL
)
2954 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2955 processing_current_prefix
= specification_prefix
;
2956 back_to
= make_cleanup (xfree
, specification_prefix
);
2963 /* Record the function range for dwarf_decode_lines. */
2964 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2966 new = push_context (0, lowpc
);
2967 new->name
= new_symbol (die
, die
->type
, cu
);
2969 /* If there is a location expression for DW_AT_frame_base, record
2971 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2973 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2974 expression is being recorded directly in the function's symbol
2975 and not in a separate frame-base object. I guess this hack is
2976 to avoid adding some sort of frame-base adjunct/annex to the
2977 function's symbol :-(. The problem with doing this is that it
2978 results in a function symbol with a location expression that
2979 has nothing to do with the location of the function, ouch! The
2980 relationship should be: a function's symbol has-a frame base; a
2981 frame-base has-a location expression. */
2982 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2984 cu
->list_in_scope
= &local_symbols
;
2986 if (die
->child
!= NULL
)
2988 child_die
= die
->child
;
2989 while (child_die
&& child_die
->tag
)
2991 process_die (child_die
, cu
);
2992 child_die
= sibling_die (child_die
);
2996 new = pop_context ();
2997 /* Make a block for the local symbols within. */
2998 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2999 lowpc
, highpc
, objfile
);
3001 /* In C++, we can have functions nested inside functions (e.g., when
3002 a function declares a class that has methods). This means that
3003 when we finish processing a function scope, we may need to go
3004 back to building a containing block's symbol lists. */
3005 local_symbols
= new->locals
;
3006 param_symbols
= new->params
;
3008 /* If we've finished processing a top-level function, subsequent
3009 symbols go in the file symbol list. */
3010 if (outermost_context_p ())
3011 cu
->list_in_scope
= &file_symbols
;
3013 processing_current_prefix
= previous_prefix
;
3014 if (back_to
!= NULL
)
3015 do_cleanups (back_to
);
3018 /* Process all the DIES contained within a lexical block scope. Start
3019 a new scope, process the dies, and then close the scope. */
3022 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3024 struct objfile
*objfile
= cu
->objfile
;
3025 struct context_stack
*new;
3026 CORE_ADDR lowpc
, highpc
;
3027 struct die_info
*child_die
;
3030 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3032 /* Ignore blocks with missing or invalid low and high pc attributes. */
3033 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3034 as multiple lexical blocks? Handling children in a sane way would
3035 be nasty. Might be easier to properly extend generic blocks to
3037 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3042 push_context (0, lowpc
);
3043 if (die
->child
!= NULL
)
3045 child_die
= die
->child
;
3046 while (child_die
&& child_die
->tag
)
3048 process_die (child_die
, cu
);
3049 child_die
= sibling_die (child_die
);
3052 new = pop_context ();
3054 if (local_symbols
!= NULL
)
3056 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3059 local_symbols
= new->locals
;
3062 /* Get low and high pc attributes from a die. Return 1 if the attributes
3063 are present and valid, otherwise, return 0. Return -1 if the range is
3064 discontinuous, i.e. derived from DW_AT_ranges information. */
3066 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3067 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3069 struct objfile
*objfile
= cu
->objfile
;
3070 struct comp_unit_head
*cu_header
= &cu
->header
;
3071 struct attribute
*attr
;
3072 bfd
*obfd
= objfile
->obfd
;
3077 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3080 high
= DW_ADDR (attr
);
3081 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3083 low
= DW_ADDR (attr
);
3085 /* Found high w/o low attribute. */
3088 /* Found consecutive range of addresses. */
3093 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3096 unsigned int addr_size
= cu_header
->addr_size
;
3097 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3098 /* Value of the DW_AT_ranges attribute is the offset in the
3099 .debug_ranges section. */
3100 unsigned int offset
= DW_UNSND (attr
);
3101 /* Base address selection entry. */
3109 found_base
= cu_header
->base_known
;
3110 base
= cu_header
->base_address
;
3112 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3114 complaint (&symfile_complaints
,
3115 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3119 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3121 /* Read in the largest possible address. */
3122 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3123 if ((marker
& mask
) == mask
)
3125 /* If we found the largest possible address, then
3126 read the base address. */
3127 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3128 buffer
+= 2 * addr_size
;
3129 offset
+= 2 * addr_size
;
3137 CORE_ADDR range_beginning
, range_end
;
3139 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3140 buffer
+= addr_size
;
3141 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3142 buffer
+= addr_size
;
3143 offset
+= 2 * addr_size
;
3145 /* An end of list marker is a pair of zero addresses. */
3146 if (range_beginning
== 0 && range_end
== 0)
3147 /* Found the end of list entry. */
3150 /* Each base address selection entry is a pair of 2 values.
3151 The first is the largest possible address, the second is
3152 the base address. Check for a base address here. */
3153 if ((range_beginning
& mask
) == mask
)
3155 /* If we found the largest possible address, then
3156 read the base address. */
3157 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3164 /* We have no valid base address for the ranges
3166 complaint (&symfile_complaints
,
3167 _("Invalid .debug_ranges data (no base address)"));
3171 range_beginning
+= base
;
3174 /* FIXME: This is recording everything as a low-high
3175 segment of consecutive addresses. We should have a
3176 data structure for discontiguous block ranges
3180 low
= range_beginning
;
3186 if (range_beginning
< low
)
3187 low
= range_beginning
;
3188 if (range_end
> high
)
3194 /* If the first entry is an end-of-list marker, the range
3195 describes an empty scope, i.e. no instructions. */
3205 /* When using the GNU linker, .gnu.linkonce. sections are used to
3206 eliminate duplicate copies of functions and vtables and such.
3207 The linker will arbitrarily choose one and discard the others.
3208 The AT_*_pc values for such functions refer to local labels in
3209 these sections. If the section from that file was discarded, the
3210 labels are not in the output, so the relocs get a value of 0.
3211 If this is a discarded function, mark the pc bounds as invalid,
3212 so that GDB will ignore it. */
3213 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3221 /* Get the low and high pc's represented by the scope DIE, and store
3222 them in *LOWPC and *HIGHPC. If the correct values can't be
3223 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3226 get_scope_pc_bounds (struct die_info
*die
,
3227 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3228 struct dwarf2_cu
*cu
)
3230 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3231 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3232 CORE_ADDR current_low
, current_high
;
3234 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3236 best_low
= current_low
;
3237 best_high
= current_high
;
3241 struct die_info
*child
= die
->child
;
3243 while (child
&& child
->tag
)
3245 switch (child
->tag
) {
3246 case DW_TAG_subprogram
:
3247 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3249 best_low
= min (best_low
, current_low
);
3250 best_high
= max (best_high
, current_high
);
3253 case DW_TAG_namespace
:
3254 /* FIXME: carlton/2004-01-16: Should we do this for
3255 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3256 that current GCC's always emit the DIEs corresponding
3257 to definitions of methods of classes as children of a
3258 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3259 the DIEs giving the declarations, which could be
3260 anywhere). But I don't see any reason why the
3261 standards says that they have to be there. */
3262 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3264 if (current_low
!= ((CORE_ADDR
) -1))
3266 best_low
= min (best_low
, current_low
);
3267 best_high
= max (best_high
, current_high
);
3275 child
= sibling_die (child
);
3280 *highpc
= best_high
;
3283 /* Add an aggregate field to the field list. */
3286 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3287 struct dwarf2_cu
*cu
)
3289 struct objfile
*objfile
= cu
->objfile
;
3290 struct nextfield
*new_field
;
3291 struct attribute
*attr
;
3293 char *fieldname
= "";
3295 /* Allocate a new field list entry and link it in. */
3296 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3297 make_cleanup (xfree
, new_field
);
3298 memset (new_field
, 0, sizeof (struct nextfield
));
3299 new_field
->next
= fip
->fields
;
3300 fip
->fields
= new_field
;
3303 /* Handle accessibility and virtuality of field.
3304 The default accessibility for members is public, the default
3305 accessibility for inheritance is private. */
3306 if (die
->tag
!= DW_TAG_inheritance
)
3307 new_field
->accessibility
= DW_ACCESS_public
;
3309 new_field
->accessibility
= DW_ACCESS_private
;
3310 new_field
->virtuality
= DW_VIRTUALITY_none
;
3312 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3314 new_field
->accessibility
= DW_UNSND (attr
);
3315 if (new_field
->accessibility
!= DW_ACCESS_public
)
3316 fip
->non_public_fields
= 1;
3317 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3319 new_field
->virtuality
= DW_UNSND (attr
);
3321 fp
= &new_field
->field
;
3323 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3325 /* Data member other than a C++ static data member. */
3327 /* Get type of field. */
3328 fp
->type
= die_type (die
, cu
);
3330 FIELD_STATIC_KIND (*fp
) = 0;
3332 /* Get bit size of field (zero if none). */
3333 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3336 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3340 FIELD_BITSIZE (*fp
) = 0;
3343 /* Get bit offset of field. */
3344 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3347 FIELD_BITPOS (*fp
) =
3348 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3351 FIELD_BITPOS (*fp
) = 0;
3352 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3355 if (BITS_BIG_ENDIAN
)
3357 /* For big endian bits, the DW_AT_bit_offset gives the
3358 additional bit offset from the MSB of the containing
3359 anonymous object to the MSB of the field. We don't
3360 have to do anything special since we don't need to
3361 know the size of the anonymous object. */
3362 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3366 /* For little endian bits, compute the bit offset to the
3367 MSB of the anonymous object, subtract off the number of
3368 bits from the MSB of the field to the MSB of the
3369 object, and then subtract off the number of bits of
3370 the field itself. The result is the bit offset of
3371 the LSB of the field. */
3373 int bit_offset
= DW_UNSND (attr
);
3375 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3378 /* The size of the anonymous object containing
3379 the bit field is explicit, so use the
3380 indicated size (in bytes). */
3381 anonymous_size
= DW_UNSND (attr
);
3385 /* The size of the anonymous object containing
3386 the bit field must be inferred from the type
3387 attribute of the data member containing the
3389 anonymous_size
= TYPE_LENGTH (fp
->type
);
3391 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3392 - bit_offset
- FIELD_BITSIZE (*fp
);
3396 /* Get name of field. */
3397 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3398 if (attr
&& DW_STRING (attr
))
3399 fieldname
= DW_STRING (attr
);
3401 /* The name is already allocated along with this objfile, so we don't
3402 need to duplicate it for the type. */
3403 fp
->name
= fieldname
;
3405 /* Change accessibility for artificial fields (e.g. virtual table
3406 pointer or virtual base class pointer) to private. */
3407 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3409 new_field
->accessibility
= DW_ACCESS_private
;
3410 fip
->non_public_fields
= 1;
3413 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3415 /* C++ static member. */
3417 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3418 is a declaration, but all versions of G++ as of this writing
3419 (so through at least 3.2.1) incorrectly generate
3420 DW_TAG_variable tags. */
3424 /* Get name of field. */
3425 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3426 if (attr
&& DW_STRING (attr
))
3427 fieldname
= DW_STRING (attr
);
3431 /* Get physical name. */
3432 physname
= dwarf2_linkage_name (die
, cu
);
3434 /* The name is already allocated along with this objfile, so we don't
3435 need to duplicate it for the type. */
3436 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3437 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3438 FIELD_NAME (*fp
) = fieldname
;
3440 else if (die
->tag
== DW_TAG_inheritance
)
3442 /* C++ base class field. */
3443 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3445 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3447 FIELD_BITSIZE (*fp
) = 0;
3448 FIELD_STATIC_KIND (*fp
) = 0;
3449 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3450 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3451 fip
->nbaseclasses
++;
3455 /* Create the vector of fields, and attach it to the type. */
3458 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3459 struct dwarf2_cu
*cu
)
3461 int nfields
= fip
->nfields
;
3463 /* Record the field count, allocate space for the array of fields,
3464 and create blank accessibility bitfields if necessary. */
3465 TYPE_NFIELDS (type
) = nfields
;
3466 TYPE_FIELDS (type
) = (struct field
*)
3467 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3468 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3470 if (fip
->non_public_fields
)
3472 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3474 TYPE_FIELD_PRIVATE_BITS (type
) =
3475 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3476 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3478 TYPE_FIELD_PROTECTED_BITS (type
) =
3479 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3480 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3482 TYPE_FIELD_IGNORE_BITS (type
) =
3483 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3484 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3487 /* If the type has baseclasses, allocate and clear a bit vector for
3488 TYPE_FIELD_VIRTUAL_BITS. */
3489 if (fip
->nbaseclasses
)
3491 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3492 unsigned char *pointer
;
3494 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3495 pointer
= TYPE_ALLOC (type
, num_bytes
);
3496 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3497 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3498 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3501 /* Copy the saved-up fields into the field vector. Start from the head
3502 of the list, adding to the tail of the field array, so that they end
3503 up in the same order in the array in which they were added to the list. */
3504 while (nfields
-- > 0)
3506 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3507 switch (fip
->fields
->accessibility
)
3509 case DW_ACCESS_private
:
3510 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3513 case DW_ACCESS_protected
:
3514 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3517 case DW_ACCESS_public
:
3521 /* Unknown accessibility. Complain and treat it as public. */
3523 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3524 fip
->fields
->accessibility
);
3528 if (nfields
< fip
->nbaseclasses
)
3530 switch (fip
->fields
->virtuality
)
3532 case DW_VIRTUALITY_virtual
:
3533 case DW_VIRTUALITY_pure_virtual
:
3534 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3538 fip
->fields
= fip
->fields
->next
;
3542 /* Add a member function to the proper fieldlist. */
3545 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3546 struct type
*type
, struct dwarf2_cu
*cu
)
3548 struct objfile
*objfile
= cu
->objfile
;
3549 struct attribute
*attr
;
3550 struct fnfieldlist
*flp
;
3552 struct fn_field
*fnp
;
3555 struct nextfnfield
*new_fnfield
;
3557 /* Get name of member function. */
3558 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3559 if (attr
&& DW_STRING (attr
))
3560 fieldname
= DW_STRING (attr
);
3564 /* Get the mangled name. */
3565 physname
= dwarf2_linkage_name (die
, cu
);
3567 /* Look up member function name in fieldlist. */
3568 for (i
= 0; i
< fip
->nfnfields
; i
++)
3570 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3574 /* Create new list element if necessary. */
3575 if (i
< fip
->nfnfields
)
3576 flp
= &fip
->fnfieldlists
[i
];
3579 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3581 fip
->fnfieldlists
= (struct fnfieldlist
*)
3582 xrealloc (fip
->fnfieldlists
,
3583 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3584 * sizeof (struct fnfieldlist
));
3585 if (fip
->nfnfields
== 0)
3586 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3588 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3589 flp
->name
= fieldname
;
3595 /* Create a new member function field and chain it to the field list
3597 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3598 make_cleanup (xfree
, new_fnfield
);
3599 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3600 new_fnfield
->next
= flp
->head
;
3601 flp
->head
= new_fnfield
;
3604 /* Fill in the member function field info. */
3605 fnp
= &new_fnfield
->fnfield
;
3606 /* The name is already allocated along with this objfile, so we don't
3607 need to duplicate it for the type. */
3608 fnp
->physname
= physname
? physname
: "";
3609 fnp
->type
= alloc_type (objfile
);
3610 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3612 int nparams
= TYPE_NFIELDS (die
->type
);
3614 /* TYPE is the domain of this method, and DIE->TYPE is the type
3615 of the method itself (TYPE_CODE_METHOD). */
3616 smash_to_method_type (fnp
->type
, type
,
3617 TYPE_TARGET_TYPE (die
->type
),
3618 TYPE_FIELDS (die
->type
),
3619 TYPE_NFIELDS (die
->type
),
3620 TYPE_VARARGS (die
->type
));
3622 /* Handle static member functions.
3623 Dwarf2 has no clean way to discern C++ static and non-static
3624 member functions. G++ helps GDB by marking the first
3625 parameter for non-static member functions (which is the
3626 this pointer) as artificial. We obtain this information
3627 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3628 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3629 fnp
->voffset
= VOFFSET_STATIC
;
3632 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3635 /* Get fcontext from DW_AT_containing_type if present. */
3636 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3637 fnp
->fcontext
= die_containing_type (die
, cu
);
3639 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3640 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3642 /* Get accessibility. */
3643 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3646 switch (DW_UNSND (attr
))
3648 case DW_ACCESS_private
:
3649 fnp
->is_private
= 1;
3651 case DW_ACCESS_protected
:
3652 fnp
->is_protected
= 1;
3657 /* Check for artificial methods. */
3658 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3659 if (attr
&& DW_UNSND (attr
) != 0)
3660 fnp
->is_artificial
= 1;
3662 /* Get index in virtual function table if it is a virtual member function. */
3663 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3666 /* Support the .debug_loc offsets */
3667 if (attr_form_is_block (attr
))
3669 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3671 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3673 dwarf2_complex_location_expr_complaint ();
3677 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3683 /* Create the vector of member function fields, and attach it to the type. */
3686 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3687 struct dwarf2_cu
*cu
)
3689 struct fnfieldlist
*flp
;
3690 int total_length
= 0;
3693 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3694 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3695 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3697 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3699 struct nextfnfield
*nfp
= flp
->head
;
3700 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3703 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3704 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3705 fn_flp
->fn_fields
= (struct fn_field
*)
3706 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3707 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3708 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3710 total_length
+= flp
->length
;
3713 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3714 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3717 /* Returns non-zero if NAME is the name of a vtable member in CU's
3718 language, zero otherwise. */
3720 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3722 static const char vptr
[] = "_vptr";
3723 static const char vtable
[] = "vtable";
3725 /* Look for the C++ and Java forms of the vtable. */
3726 if ((cu
->language
== language_java
3727 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3728 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3729 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3735 /* GCC outputs unnamed structures that are really pointers to member
3736 functions, with the ABI-specified layout. If DIE (from CU) describes
3737 such a structure, set its type, and return nonzero. Otherwise return
3740 GCC shouldn't do this; it should just output pointer to member DIEs.
3741 This is GCC PR debug/28767. */
3744 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3746 struct objfile
*objfile
= cu
->objfile
;
3748 struct die_info
*pfn_die
, *delta_die
;
3749 struct attribute
*pfn_name
, *delta_name
;
3750 struct type
*pfn_type
, *domain_type
;
3752 /* Check for a structure with no name and two children. */
3753 if (die
->tag
!= DW_TAG_structure_type
3754 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3755 || die
->child
== NULL
3756 || die
->child
->sibling
== NULL
3757 || (die
->child
->sibling
->sibling
!= NULL
3758 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3761 /* Check for __pfn and __delta members. */
3762 pfn_die
= die
->child
;
3763 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3764 if (pfn_die
->tag
!= DW_TAG_member
3766 || DW_STRING (pfn_name
) == NULL
3767 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3770 delta_die
= pfn_die
->sibling
;
3771 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3772 if (delta_die
->tag
!= DW_TAG_member
3773 || delta_name
== NULL
3774 || DW_STRING (delta_name
) == NULL
3775 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3778 /* Find the type of the method. */
3779 pfn_type
= die_type (pfn_die
, cu
);
3780 if (pfn_type
== NULL
3781 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3782 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3785 /* Look for the "this" argument. */
3786 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3787 if (TYPE_NFIELDS (pfn_type
) == 0
3788 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3791 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3792 type
= alloc_type (objfile
);
3793 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3794 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3795 TYPE_VARARGS (pfn_type
));
3796 type
= lookup_methodptr_type (type
);
3797 set_die_type (die
, type
, cu
);
3802 /* Called when we find the DIE that starts a structure or union scope
3803 (definition) to process all dies that define the members of the
3806 NOTE: we need to call struct_type regardless of whether or not the
3807 DIE has an at_name attribute, since it might be an anonymous
3808 structure or union. This gets the type entered into our set of
3811 However, if the structure is incomplete (an opaque struct/union)
3812 then suppress creating a symbol table entry for it since gdb only
3813 wants to find the one with the complete definition. Note that if
3814 it is complete, we just call new_symbol, which does it's own
3815 checking about whether the struct/union is anonymous or not (and
3816 suppresses creating a symbol table entry itself). */
3819 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3821 struct objfile
*objfile
= cu
->objfile
;
3823 struct attribute
*attr
;
3824 const char *previous_prefix
= processing_current_prefix
;
3825 struct cleanup
*back_to
= NULL
;
3830 if (quirk_gcc_member_function_pointer (die
, cu
))
3833 type
= alloc_type (objfile
);
3834 INIT_CPLUS_SPECIFIC (type
);
3835 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3836 if (attr
&& DW_STRING (attr
))
3838 if (cu
->language
== language_cplus
3839 || cu
->language
== language_java
)
3841 char *new_prefix
= determine_class_name (die
, cu
);
3842 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3843 strlen (new_prefix
),
3844 &objfile
->objfile_obstack
);
3845 back_to
= make_cleanup (xfree
, new_prefix
);
3846 processing_current_prefix
= new_prefix
;
3850 /* The name is already allocated along with this objfile, so
3851 we don't need to duplicate it for the type. */
3852 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3856 if (die
->tag
== DW_TAG_structure_type
)
3858 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3860 else if (die
->tag
== DW_TAG_union_type
)
3862 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3866 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3868 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3871 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3874 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3878 TYPE_LENGTH (type
) = 0;
3881 if (die_is_declaration (die
, cu
))
3882 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3884 /* We need to add the type field to the die immediately so we don't
3885 infinitely recurse when dealing with pointers to the structure
3886 type within the structure itself. */
3887 set_die_type (die
, type
, cu
);
3889 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3891 struct field_info fi
;
3892 struct die_info
*child_die
;
3893 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3895 memset (&fi
, 0, sizeof (struct field_info
));
3897 child_die
= die
->child
;
3899 while (child_die
&& child_die
->tag
)
3901 if (child_die
->tag
== DW_TAG_member
3902 || child_die
->tag
== DW_TAG_variable
)
3904 /* NOTE: carlton/2002-11-05: A C++ static data member
3905 should be a DW_TAG_member that is a declaration, but
3906 all versions of G++ as of this writing (so through at
3907 least 3.2.1) incorrectly generate DW_TAG_variable
3908 tags for them instead. */
3909 dwarf2_add_field (&fi
, child_die
, cu
);
3911 else if (child_die
->tag
== DW_TAG_subprogram
)
3913 /* C++ member function. */
3914 read_type_die (child_die
, cu
);
3915 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3917 else if (child_die
->tag
== DW_TAG_inheritance
)
3919 /* C++ base class field. */
3920 dwarf2_add_field (&fi
, child_die
, cu
);
3922 child_die
= sibling_die (child_die
);
3925 /* Attach fields and member functions to the type. */
3927 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3930 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3932 /* Get the type which refers to the base class (possibly this
3933 class itself) which contains the vtable pointer for the current
3934 class from the DW_AT_containing_type attribute. */
3936 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3938 struct type
*t
= die_containing_type (die
, cu
);
3940 TYPE_VPTR_BASETYPE (type
) = t
;
3945 /* Our own class provides vtbl ptr. */
3946 for (i
= TYPE_NFIELDS (t
) - 1;
3947 i
>= TYPE_N_BASECLASSES (t
);
3950 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3952 if (is_vtable_name (fieldname
, cu
))
3954 TYPE_VPTR_FIELDNO (type
) = i
;
3959 /* Complain if virtual function table field not found. */
3960 if (i
< TYPE_N_BASECLASSES (t
))
3961 complaint (&symfile_complaints
,
3962 _("virtual function table pointer not found when defining class '%s'"),
3963 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3968 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3971 else if (cu
->producer
3972 && strncmp (cu
->producer
,
3973 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3975 /* The IBM XLC compiler does not provide direct indication
3976 of the containing type, but the vtable pointer is
3977 always named __vfp. */
3981 for (i
= TYPE_NFIELDS (type
) - 1;
3982 i
>= TYPE_N_BASECLASSES (type
);
3985 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3987 TYPE_VPTR_FIELDNO (type
) = i
;
3988 TYPE_VPTR_BASETYPE (type
) = type
;
3995 do_cleanups (back_to
);
3998 processing_current_prefix
= previous_prefix
;
3999 if (back_to
!= NULL
)
4000 do_cleanups (back_to
);
4004 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4006 struct objfile
*objfile
= cu
->objfile
;
4007 const char *previous_prefix
= processing_current_prefix
;
4008 struct die_info
*child_die
= die
->child
;
4010 if (TYPE_TAG_NAME (die
->type
) != NULL
)
4011 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
4013 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4014 snapshots) has been known to create a die giving a declaration
4015 for a class that has, as a child, a die giving a definition for a
4016 nested class. So we have to process our children even if the
4017 current die is a declaration. Normally, of course, a declaration
4018 won't have any children at all. */
4020 while (child_die
!= NULL
&& child_die
->tag
)
4022 if (child_die
->tag
== DW_TAG_member
4023 || child_die
->tag
== DW_TAG_variable
4024 || child_die
->tag
== DW_TAG_inheritance
)
4029 process_die (child_die
, cu
);
4031 child_die
= sibling_die (child_die
);
4034 /* Do not consider external references. According to the DWARF standard,
4035 these DIEs are identified by the fact that they have no byte_size
4036 attribute, and a declaration attribute. */
4037 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4038 || !die_is_declaration (die
, cu
))
4039 new_symbol (die
, die
->type
, cu
);
4041 processing_current_prefix
= previous_prefix
;
4044 /* Given a DW_AT_enumeration_type die, set its type. We do not
4045 complete the type's fields yet, or create any symbols. */
4048 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4050 struct objfile
*objfile
= cu
->objfile
;
4052 struct attribute
*attr
;
4057 type
= alloc_type (objfile
);
4059 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4060 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4061 if (attr
&& DW_STRING (attr
))
4063 char *name
= DW_STRING (attr
);
4065 if (processing_has_namespace_info
)
4067 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4068 processing_current_prefix
,
4073 /* The name is already allocated along with this objfile, so
4074 we don't need to duplicate it for the type. */
4075 TYPE_TAG_NAME (type
) = name
;
4079 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4082 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4086 TYPE_LENGTH (type
) = 0;
4089 set_die_type (die
, type
, cu
);
4092 /* Determine the name of the type represented by DIE, which should be
4093 a named C++ or Java compound type. Return the name in question; the caller
4094 is responsible for xfree()'ing it. */
4097 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4099 struct cleanup
*back_to
= NULL
;
4100 struct die_info
*spec_die
= die_specification (die
, cu
);
4101 char *new_prefix
= NULL
;
4103 /* If this is the definition of a class that is declared by another
4104 die, then processing_current_prefix may not be accurate; see
4105 read_func_scope for a similar example. */
4106 if (spec_die
!= NULL
)
4108 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4109 processing_current_prefix
= specification_prefix
;
4110 back_to
= make_cleanup (xfree
, specification_prefix
);
4113 /* If we don't have namespace debug info, guess the name by trying
4114 to demangle the names of members, just like we did in
4115 guess_structure_name. */
4116 if (!processing_has_namespace_info
)
4118 struct die_info
*child
;
4120 for (child
= die
->child
;
4121 child
!= NULL
&& child
->tag
!= 0;
4122 child
= sibling_die (child
))
4124 if (child
->tag
== DW_TAG_subprogram
)
4127 = language_class_name_from_physname (cu
->language_defn
,
4131 if (new_prefix
!= NULL
)
4137 if (new_prefix
== NULL
)
4139 const char *name
= dwarf2_name (die
, cu
);
4140 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4141 name
? name
: "<<anonymous>>",
4145 if (back_to
!= NULL
)
4146 do_cleanups (back_to
);
4151 /* Given a pointer to a die which begins an enumeration, process all
4152 the dies that define the members of the enumeration, and create the
4153 symbol for the enumeration type.
4155 NOTE: We reverse the order of the element list. */
4158 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4160 struct objfile
*objfile
= cu
->objfile
;
4161 struct die_info
*child_die
;
4162 struct field
*fields
;
4163 struct attribute
*attr
;
4166 int unsigned_enum
= 1;
4170 if (die
->child
!= NULL
)
4172 child_die
= die
->child
;
4173 while (child_die
&& child_die
->tag
)
4175 if (child_die
->tag
!= DW_TAG_enumerator
)
4177 process_die (child_die
, cu
);
4181 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4184 sym
= new_symbol (child_die
, die
->type
, cu
);
4185 if (SYMBOL_VALUE (sym
) < 0)
4188 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4190 fields
= (struct field
*)
4192 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4193 * sizeof (struct field
));
4196 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4197 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4198 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4199 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4200 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4206 child_die
= sibling_die (child_die
);
4211 TYPE_NFIELDS (die
->type
) = num_fields
;
4212 TYPE_FIELDS (die
->type
) = (struct field
*)
4213 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4214 memcpy (TYPE_FIELDS (die
->type
), fields
,
4215 sizeof (struct field
) * num_fields
);
4219 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4222 new_symbol (die
, die
->type
, cu
);
4225 /* Extract all information from a DW_TAG_array_type DIE and put it in
4226 the DIE's type field. For now, this only handles one dimensional
4230 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4232 struct objfile
*objfile
= cu
->objfile
;
4233 struct die_info
*child_die
;
4234 struct type
*type
= NULL
;
4235 struct type
*element_type
, *range_type
, *index_type
;
4236 struct type
**range_types
= NULL
;
4237 struct attribute
*attr
;
4239 struct cleanup
*back_to
;
4241 /* Return if we've already decoded this type. */
4247 element_type
= die_type (die
, cu
);
4249 /* Irix 6.2 native cc creates array types without children for
4250 arrays with unspecified length. */
4251 if (die
->child
== NULL
)
4253 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4254 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4255 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4260 back_to
= make_cleanup (null_cleanup
, NULL
);
4261 child_die
= die
->child
;
4262 while (child_die
&& child_die
->tag
)
4264 if (child_die
->tag
== DW_TAG_subrange_type
)
4266 read_subrange_type (child_die
, cu
);
4268 if (child_die
->type
!= NULL
)
4270 /* The range type was succesfully read. Save it for
4271 the array type creation. */
4272 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4274 range_types
= (struct type
**)
4275 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4276 * sizeof (struct type
*));
4278 make_cleanup (free_current_contents
, &range_types
);
4280 range_types
[ndim
++] = child_die
->type
;
4283 child_die
= sibling_die (child_die
);
4286 /* Dwarf2 dimensions are output from left to right, create the
4287 necessary array types in backwards order. */
4289 type
= element_type
;
4291 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4295 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4300 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4303 /* Understand Dwarf2 support for vector types (like they occur on
4304 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4305 array type. This is not part of the Dwarf2/3 standard yet, but a
4306 custom vendor extension. The main difference between a regular
4307 array and the vector variant is that vectors are passed by value
4309 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4311 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4313 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4314 if (attr
&& DW_STRING (attr
))
4315 TYPE_NAME (type
) = DW_STRING (attr
);
4317 do_cleanups (back_to
);
4319 /* Install the type in the die. */
4320 set_die_type (die
, type
, cu
);
4323 static enum dwarf_array_dim_ordering
4324 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4326 struct attribute
*attr
;
4328 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4330 if (attr
) return DW_SND (attr
);
4333 GNU F77 is a special case, as at 08/2004 array type info is the
4334 opposite order to the dwarf2 specification, but data is still
4335 laid out as per normal fortran.
4337 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4341 if (cu
->language
== language_fortran
&&
4342 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4344 return DW_ORD_row_major
;
4347 switch (cu
->language_defn
->la_array_ordering
)
4349 case array_column_major
:
4350 return DW_ORD_col_major
;
4351 case array_row_major
:
4353 return DW_ORD_row_major
;
4357 /* Extract all information from a DW_TAG_set_type DIE and put it in
4358 the DIE's type field. */
4361 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4363 if (die
->type
== NULL
)
4364 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4367 /* First cut: install each common block member as a global variable. */
4370 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4372 struct die_info
*child_die
;
4373 struct attribute
*attr
;
4375 CORE_ADDR base
= (CORE_ADDR
) 0;
4377 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4380 /* Support the .debug_loc offsets */
4381 if (attr_form_is_block (attr
))
4383 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4385 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4387 dwarf2_complex_location_expr_complaint ();
4391 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4392 "common block member");
4395 if (die
->child
!= NULL
)
4397 child_die
= die
->child
;
4398 while (child_die
&& child_die
->tag
)
4400 sym
= new_symbol (child_die
, NULL
, cu
);
4401 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4404 SYMBOL_VALUE_ADDRESS (sym
) =
4405 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4406 add_symbol_to_list (sym
, &global_symbols
);
4408 child_die
= sibling_die (child_die
);
4413 /* Read a C++ namespace. */
4416 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4418 struct objfile
*objfile
= cu
->objfile
;
4419 const char *previous_prefix
= processing_current_prefix
;
4422 struct die_info
*current_die
;
4423 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4425 name
= namespace_name (die
, &is_anonymous
, cu
);
4427 /* Now build the name of the current namespace. */
4429 if (previous_prefix
[0] == '\0')
4431 processing_current_prefix
= name
;
4435 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4436 make_cleanup (xfree
, temp_name
);
4437 processing_current_prefix
= temp_name
;
4440 /* Add a symbol associated to this if we haven't seen the namespace
4441 before. Also, add a using directive if it's an anonymous
4444 if (dwarf2_extension (die
, cu
) == NULL
)
4448 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4449 this cast will hopefully become unnecessary. */
4450 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4451 (char *) processing_current_prefix
,
4453 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4455 new_symbol (die
, type
, cu
);
4456 set_die_type (die
, type
, cu
);
4459 cp_add_using_directive (processing_current_prefix
,
4460 strlen (previous_prefix
),
4461 strlen (processing_current_prefix
));
4464 if (die
->child
!= NULL
)
4466 struct die_info
*child_die
= die
->child
;
4468 while (child_die
&& child_die
->tag
)
4470 process_die (child_die
, cu
);
4471 child_die
= sibling_die (child_die
);
4475 processing_current_prefix
= previous_prefix
;
4476 do_cleanups (back_to
);
4479 /* Return the name of the namespace represented by DIE. Set
4480 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4484 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4486 struct die_info
*current_die
;
4487 const char *name
= NULL
;
4489 /* Loop through the extensions until we find a name. */
4491 for (current_die
= die
;
4492 current_die
!= NULL
;
4493 current_die
= dwarf2_extension (die
, cu
))
4495 name
= dwarf2_name (current_die
, cu
);
4500 /* Is it an anonymous namespace? */
4502 *is_anonymous
= (name
== NULL
);
4504 name
= "(anonymous namespace)";
4509 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4510 the user defined type vector. */
4513 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4515 struct comp_unit_head
*cu_header
= &cu
->header
;
4517 struct attribute
*attr_byte_size
;
4518 struct attribute
*attr_address_class
;
4519 int byte_size
, addr_class
;
4526 type
= lookup_pointer_type (die_type (die
, cu
));
4528 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4530 byte_size
= DW_UNSND (attr_byte_size
);
4532 byte_size
= cu_header
->addr_size
;
4534 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4535 if (attr_address_class
)
4536 addr_class
= DW_UNSND (attr_address_class
);
4538 addr_class
= DW_ADDR_none
;
4540 /* If the pointer size or address class is different than the
4541 default, create a type variant marked as such and set the
4542 length accordingly. */
4543 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4545 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4549 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4550 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4551 type
= make_type_with_address_space (type
, type_flags
);
4553 else if (TYPE_LENGTH (type
) != byte_size
)
4555 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4558 /* Should we also complain about unhandled address classes? */
4562 TYPE_LENGTH (type
) = byte_size
;
4563 set_die_type (die
, type
, cu
);
4566 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4567 the user defined type vector. */
4570 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4572 struct objfile
*objfile
= cu
->objfile
;
4574 struct type
*to_type
;
4575 struct type
*domain
;
4582 to_type
= die_type (die
, cu
);
4583 domain
= die_containing_type (die
, cu
);
4585 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4586 type
= lookup_methodptr_type (to_type
);
4588 type
= lookup_memberptr_type (to_type
, domain
);
4590 set_die_type (die
, type
, cu
);
4593 /* Extract all information from a DW_TAG_reference_type DIE and add to
4594 the user defined type vector. */
4597 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4599 struct comp_unit_head
*cu_header
= &cu
->header
;
4601 struct attribute
*attr
;
4608 type
= lookup_reference_type (die_type (die
, cu
));
4609 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4612 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4616 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4618 set_die_type (die
, type
, cu
);
4622 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4624 struct type
*base_type
;
4631 base_type
= die_type (die
, cu
);
4632 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4637 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4639 struct type
*base_type
;
4646 base_type
= die_type (die
, cu
);
4647 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4651 /* Extract all information from a DW_TAG_string_type DIE and add to
4652 the user defined type vector. It isn't really a user defined type,
4653 but it behaves like one, with other DIE's using an AT_user_def_type
4654 attribute to reference it. */
4657 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4659 struct objfile
*objfile
= cu
->objfile
;
4660 struct type
*type
, *range_type
, *index_type
, *char_type
;
4661 struct attribute
*attr
;
4662 unsigned int length
;
4669 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4672 length
= DW_UNSND (attr
);
4676 /* check for the DW_AT_byte_size attribute */
4677 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4680 length
= DW_UNSND (attr
);
4687 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4688 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4689 if (cu
->language
== language_fortran
)
4691 /* Need to create a unique string type for bounds
4693 type
= create_string_type (0, range_type
);
4697 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4698 type
= create_string_type (char_type
, range_type
);
4700 set_die_type (die
, type
, cu
);
4703 /* Handle DIES due to C code like:
4707 int (*funcp)(int a, long l);
4711 ('funcp' generates a DW_TAG_subroutine_type DIE)
4715 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4717 struct type
*type
; /* Type that this function returns */
4718 struct type
*ftype
; /* Function that returns above type */
4719 struct attribute
*attr
;
4721 /* Decode the type that this subroutine returns */
4726 type
= die_type (die
, cu
);
4727 ftype
= make_function_type (type
, (struct type
**) 0);
4729 /* All functions in C++ and Java have prototypes. */
4730 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4731 if ((attr
&& (DW_UNSND (attr
) != 0))
4732 || cu
->language
== language_cplus
4733 || cu
->language
== language_java
)
4734 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4736 if (die
->child
!= NULL
)
4738 struct die_info
*child_die
;
4742 /* Count the number of parameters.
4743 FIXME: GDB currently ignores vararg functions, but knows about
4744 vararg member functions. */
4745 child_die
= die
->child
;
4746 while (child_die
&& child_die
->tag
)
4748 if (child_die
->tag
== DW_TAG_formal_parameter
)
4750 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4751 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4752 child_die
= sibling_die (child_die
);
4755 /* Allocate storage for parameters and fill them in. */
4756 TYPE_NFIELDS (ftype
) = nparams
;
4757 TYPE_FIELDS (ftype
) = (struct field
*)
4758 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4760 child_die
= die
->child
;
4761 while (child_die
&& child_die
->tag
)
4763 if (child_die
->tag
== DW_TAG_formal_parameter
)
4765 /* Dwarf2 has no clean way to discern C++ static and non-static
4766 member functions. G++ helps GDB by marking the first
4767 parameter for non-static member functions (which is the
4768 this pointer) as artificial. We pass this information
4769 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4770 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4772 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4774 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4775 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4778 child_die
= sibling_die (child_die
);
4782 set_die_type (die
, ftype
, cu
);
4786 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4788 struct objfile
*objfile
= cu
->objfile
;
4789 struct attribute
*attr
;
4794 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4795 if (attr
&& DW_STRING (attr
))
4797 name
= DW_STRING (attr
);
4799 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4800 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4802 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4806 /* Find a representation of a given base type and install
4807 it in the TYPE field of the die. */
4810 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4812 struct objfile
*objfile
= cu
->objfile
;
4814 struct attribute
*attr
;
4815 int encoding
= 0, size
= 0;
4817 /* If we've already decoded this die, this is a no-op. */
4823 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4826 encoding
= DW_UNSND (attr
);
4828 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4831 size
= DW_UNSND (attr
);
4833 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4834 if (attr
&& DW_STRING (attr
))
4836 enum type_code code
= TYPE_CODE_INT
;
4841 case DW_ATE_address
:
4842 /* Turn DW_ATE_address into a void * pointer. */
4843 code
= TYPE_CODE_PTR
;
4844 type_flags
|= TYPE_FLAG_UNSIGNED
;
4846 case DW_ATE_boolean
:
4847 code
= TYPE_CODE_BOOL
;
4848 type_flags
|= TYPE_FLAG_UNSIGNED
;
4850 case DW_ATE_complex_float
:
4851 code
= TYPE_CODE_COMPLEX
;
4854 code
= TYPE_CODE_FLT
;
4858 case DW_ATE_unsigned
:
4859 type_flags
|= TYPE_FLAG_UNSIGNED
;
4861 case DW_ATE_signed_char
:
4862 if (cu
->language
== language_m2
)
4863 code
= TYPE_CODE_CHAR
;
4865 case DW_ATE_unsigned_char
:
4866 if (cu
->language
== language_m2
)
4867 code
= TYPE_CODE_CHAR
;
4868 type_flags
|= TYPE_FLAG_UNSIGNED
;
4871 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4872 dwarf_type_encoding_name (encoding
));
4875 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4876 if (encoding
== DW_ATE_address
)
4877 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4879 else if (encoding
== DW_ATE_complex_float
)
4882 TYPE_TARGET_TYPE (type
)
4883 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4884 else if (size
== 16)
4885 TYPE_TARGET_TYPE (type
)
4886 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4888 TYPE_TARGET_TYPE (type
)
4889 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4894 type
= dwarf_base_type (encoding
, size
, cu
);
4896 set_die_type (die
, type
, cu
);
4899 /* Read the given DW_AT_subrange DIE. */
4902 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4904 struct type
*base_type
;
4905 struct type
*range_type
;
4906 struct attribute
*attr
;
4910 /* If we have already decoded this die, then nothing more to do. */
4914 base_type
= die_type (die
, cu
);
4915 if (base_type
== NULL
)
4917 complaint (&symfile_complaints
,
4918 _("DW_AT_type missing from DW_TAG_subrange_type"));
4922 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4923 base_type
= alloc_type (NULL
);
4925 if (cu
->language
== language_fortran
)
4927 /* FORTRAN implies a lower bound of 1, if not given. */
4931 /* FIXME: For variable sized arrays either of these could be
4932 a variable rather than a constant value. We'll allow it,
4933 but we don't know how to handle it. */
4934 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4936 low
= dwarf2_get_attr_constant_value (attr
, 0);
4938 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4941 if (attr
->form
== DW_FORM_block1
)
4943 /* GCC encodes arrays with unspecified or dynamic length
4944 with a DW_FORM_block1 attribute.
4945 FIXME: GDB does not yet know how to handle dynamic
4946 arrays properly, treat them as arrays with unspecified
4949 FIXME: jimb/2003-09-22: GDB does not really know
4950 how to handle arrays of unspecified length
4951 either; we just represent them as zero-length
4952 arrays. Choose an appropriate upper bound given
4953 the lower bound we've computed above. */
4957 high
= dwarf2_get_attr_constant_value (attr
, 1);
4960 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4962 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4963 if (attr
&& DW_STRING (attr
))
4964 TYPE_NAME (range_type
) = DW_STRING (attr
);
4966 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4968 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4970 set_die_type (die
, range_type
, cu
);
4974 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4977 struct attribute
*attr
;
4982 /* For now, we only support the C meaning of an unspecified type: void. */
4984 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4985 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4988 set_die_type (die
, type
, cu
);
4991 /* Read a whole compilation unit into a linked list of dies. */
4993 static struct die_info
*
4994 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4996 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4999 /* Read a single die and all its descendents. Set the die's sibling
5000 field to NULL; set other fields in the die correctly, and set all
5001 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5002 location of the info_ptr after reading all of those dies. PARENT
5003 is the parent of the die in question. */
5005 static struct die_info
*
5006 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5007 struct dwarf2_cu
*cu
,
5008 gdb_byte
**new_info_ptr
,
5009 struct die_info
*parent
)
5011 struct die_info
*die
;
5015 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5016 store_in_ref_table (die
->offset
, die
, cu
);
5020 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5026 *new_info_ptr
= cur_ptr
;
5029 die
->sibling
= NULL
;
5030 die
->parent
= parent
;
5034 /* Read a die, all of its descendents, and all of its siblings; set
5035 all of the fields of all of the dies correctly. Arguments are as
5036 in read_die_and_children. */
5038 static struct die_info
*
5039 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5040 struct dwarf2_cu
*cu
,
5041 gdb_byte
**new_info_ptr
,
5042 struct die_info
*parent
)
5044 struct die_info
*first_die
, *last_sibling
;
5048 first_die
= last_sibling
= NULL
;
5052 struct die_info
*die
5053 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5061 last_sibling
->sibling
= die
;
5066 *new_info_ptr
= cur_ptr
;
5076 /* Free a linked list of dies. */
5079 free_die_list (struct die_info
*dies
)
5081 struct die_info
*die
, *next
;
5086 if (die
->child
!= NULL
)
5087 free_die_list (die
->child
);
5088 next
= die
->sibling
;
5095 /* Read the contents of the section at OFFSET and of size SIZE from the
5096 object file specified by OBJFILE into the objfile_obstack and return it. */
5099 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5101 bfd
*abfd
= objfile
->obfd
;
5102 gdb_byte
*buf
, *retbuf
;
5103 bfd_size_type size
= bfd_get_section_size (sectp
);
5108 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5109 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5113 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5114 || bfd_bread (buf
, size
, abfd
) != size
)
5115 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5116 bfd_get_filename (abfd
));
5121 /* In DWARF version 2, the description of the debugging information is
5122 stored in a separate .debug_abbrev section. Before we read any
5123 dies from a section we read in all abbreviations and install them
5124 in a hash table. This function also sets flags in CU describing
5125 the data found in the abbrev table. */
5128 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5130 struct comp_unit_head
*cu_header
= &cu
->header
;
5131 gdb_byte
*abbrev_ptr
;
5132 struct abbrev_info
*cur_abbrev
;
5133 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5134 unsigned int abbrev_form
, hash_number
;
5135 struct attr_abbrev
*cur_attrs
;
5136 unsigned int allocated_attrs
;
5138 /* Initialize dwarf2 abbrevs */
5139 obstack_init (&cu
->abbrev_obstack
);
5140 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5142 * sizeof (struct abbrev_info
*)));
5143 memset (cu
->dwarf2_abbrevs
, 0,
5144 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5146 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5147 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5148 abbrev_ptr
+= bytes_read
;
5150 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5151 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5153 /* loop until we reach an abbrev number of 0 */
5154 while (abbrev_number
)
5156 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5158 /* read in abbrev header */
5159 cur_abbrev
->number
= abbrev_number
;
5160 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5161 abbrev_ptr
+= bytes_read
;
5162 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5165 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5166 cu
->has_namespace_info
= 1;
5168 /* now read in declarations */
5169 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5170 abbrev_ptr
+= bytes_read
;
5171 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5172 abbrev_ptr
+= bytes_read
;
5175 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5177 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5179 = xrealloc (cur_attrs
, (allocated_attrs
5180 * sizeof (struct attr_abbrev
)));
5183 /* Record whether this compilation unit might have
5184 inter-compilation-unit references. If we don't know what form
5185 this attribute will have, then it might potentially be a
5186 DW_FORM_ref_addr, so we conservatively expect inter-CU
5189 if (abbrev_form
== DW_FORM_ref_addr
5190 || abbrev_form
== DW_FORM_indirect
)
5191 cu
->has_form_ref_addr
= 1;
5193 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5194 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5195 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5196 abbrev_ptr
+= bytes_read
;
5197 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5198 abbrev_ptr
+= bytes_read
;
5201 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5202 (cur_abbrev
->num_attrs
5203 * sizeof (struct attr_abbrev
)));
5204 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5205 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5207 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5208 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5209 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5211 /* Get next abbreviation.
5212 Under Irix6 the abbreviations for a compilation unit are not
5213 always properly terminated with an abbrev number of 0.
5214 Exit loop if we encounter an abbreviation which we have
5215 already read (which means we are about to read the abbreviations
5216 for the next compile unit) or if the end of the abbreviation
5217 table is reached. */
5218 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5219 >= dwarf2_per_objfile
->abbrev_size
)
5221 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5222 abbrev_ptr
+= bytes_read
;
5223 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5230 /* Release the memory used by the abbrev table for a compilation unit. */
5233 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5235 struct dwarf2_cu
*cu
= ptr_to_cu
;
5237 obstack_free (&cu
->abbrev_obstack
, NULL
);
5238 cu
->dwarf2_abbrevs
= NULL
;
5241 /* Lookup an abbrev_info structure in the abbrev hash table. */
5243 static struct abbrev_info
*
5244 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5246 unsigned int hash_number
;
5247 struct abbrev_info
*abbrev
;
5249 hash_number
= number
% ABBREV_HASH_SIZE
;
5250 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5254 if (abbrev
->number
== number
)
5257 abbrev
= abbrev
->next
;
5262 /* Returns nonzero if TAG represents a type that we might generate a partial
5266 is_type_tag_for_partial (int tag
)
5271 /* Some types that would be reasonable to generate partial symbols for,
5272 that we don't at present. */
5273 case DW_TAG_array_type
:
5274 case DW_TAG_file_type
:
5275 case DW_TAG_ptr_to_member_type
:
5276 case DW_TAG_set_type
:
5277 case DW_TAG_string_type
:
5278 case DW_TAG_subroutine_type
:
5280 case DW_TAG_base_type
:
5281 case DW_TAG_class_type
:
5282 case DW_TAG_enumeration_type
:
5283 case DW_TAG_structure_type
:
5284 case DW_TAG_subrange_type
:
5285 case DW_TAG_typedef
:
5286 case DW_TAG_union_type
:
5293 /* Load all DIEs that are interesting for partial symbols into memory. */
5295 static struct partial_die_info
*
5296 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5297 struct dwarf2_cu
*cu
)
5299 struct partial_die_info
*part_die
;
5300 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5301 struct abbrev_info
*abbrev
;
5302 unsigned int bytes_read
;
5303 unsigned int load_all
= 0;
5305 int nesting_level
= 1;
5310 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5314 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5318 &cu
->comp_unit_obstack
,
5319 hashtab_obstack_allocate
,
5320 dummy_obstack_deallocate
);
5322 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5323 sizeof (struct partial_die_info
));
5327 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5329 /* A NULL abbrev means the end of a series of children. */
5332 if (--nesting_level
== 0)
5334 /* PART_DIE was probably the last thing allocated on the
5335 comp_unit_obstack, so we could call obstack_free
5336 here. We don't do that because the waste is small,
5337 and will be cleaned up when we're done with this
5338 compilation unit. This way, we're also more robust
5339 against other users of the comp_unit_obstack. */
5342 info_ptr
+= bytes_read
;
5343 last_die
= parent_die
;
5344 parent_die
= parent_die
->die_parent
;
5348 /* Check whether this DIE is interesting enough to save. Normally
5349 we would not be interested in members here, but there may be
5350 later variables referencing them via DW_AT_specification (for
5353 && !is_type_tag_for_partial (abbrev
->tag
)
5354 && abbrev
->tag
!= DW_TAG_enumerator
5355 && abbrev
->tag
!= DW_TAG_subprogram
5356 && abbrev
->tag
!= DW_TAG_variable
5357 && abbrev
->tag
!= DW_TAG_namespace
5358 && abbrev
->tag
!= DW_TAG_member
)
5360 /* Otherwise we skip to the next sibling, if any. */
5361 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5365 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5366 abfd
, info_ptr
, cu
);
5368 /* This two-pass algorithm for processing partial symbols has a
5369 high cost in cache pressure. Thus, handle some simple cases
5370 here which cover the majority of C partial symbols. DIEs
5371 which neither have specification tags in them, nor could have
5372 specification tags elsewhere pointing at them, can simply be
5373 processed and discarded.
5375 This segment is also optional; scan_partial_symbols and
5376 add_partial_symbol will handle these DIEs if we chain
5377 them in normally. When compilers which do not emit large
5378 quantities of duplicate debug information are more common,
5379 this code can probably be removed. */
5381 /* Any complete simple types at the top level (pretty much all
5382 of them, for a language without namespaces), can be processed
5384 if (parent_die
== NULL
5385 && part_die
->has_specification
== 0
5386 && part_die
->is_declaration
== 0
5387 && (part_die
->tag
== DW_TAG_typedef
5388 || part_die
->tag
== DW_TAG_base_type
5389 || part_die
->tag
== DW_TAG_subrange_type
))
5391 if (building_psymtab
&& part_die
->name
!= NULL
)
5392 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5393 VAR_DOMAIN
, LOC_TYPEDEF
,
5394 &cu
->objfile
->static_psymbols
,
5395 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5396 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5400 /* If we're at the second level, and we're an enumerator, and
5401 our parent has no specification (meaning possibly lives in a
5402 namespace elsewhere), then we can add the partial symbol now
5403 instead of queueing it. */
5404 if (part_die
->tag
== DW_TAG_enumerator
5405 && parent_die
!= NULL
5406 && parent_die
->die_parent
== NULL
5407 && parent_die
->tag
== DW_TAG_enumeration_type
5408 && parent_die
->has_specification
== 0)
5410 if (part_die
->name
== NULL
)
5411 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5412 else if (building_psymtab
)
5413 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5414 VAR_DOMAIN
, LOC_CONST
,
5415 (cu
->language
== language_cplus
5416 || cu
->language
== language_java
)
5417 ? &cu
->objfile
->global_psymbols
5418 : &cu
->objfile
->static_psymbols
,
5419 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5421 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5425 /* We'll save this DIE so link it in. */
5426 part_die
->die_parent
= parent_die
;
5427 part_die
->die_sibling
= NULL
;
5428 part_die
->die_child
= NULL
;
5430 if (last_die
&& last_die
== parent_die
)
5431 last_die
->die_child
= part_die
;
5433 last_die
->die_sibling
= part_die
;
5435 last_die
= part_die
;
5437 if (first_die
== NULL
)
5438 first_die
= part_die
;
5440 /* Maybe add the DIE to the hash table. Not all DIEs that we
5441 find interesting need to be in the hash table, because we
5442 also have the parent/sibling/child chains; only those that we
5443 might refer to by offset later during partial symbol reading.
5445 For now this means things that might have be the target of a
5446 DW_AT_specification, DW_AT_abstract_origin, or
5447 DW_AT_extension. DW_AT_extension will refer only to
5448 namespaces; DW_AT_abstract_origin refers to functions (and
5449 many things under the function DIE, but we do not recurse
5450 into function DIEs during partial symbol reading) and
5451 possibly variables as well; DW_AT_specification refers to
5452 declarations. Declarations ought to have the DW_AT_declaration
5453 flag. It happens that GCC forgets to put it in sometimes, but
5454 only for functions, not for types.
5456 Adding more things than necessary to the hash table is harmless
5457 except for the performance cost. Adding too few will result in
5458 wasted time in find_partial_die, when we reread the compilation
5459 unit with load_all_dies set. */
5462 || abbrev
->tag
== DW_TAG_subprogram
5463 || abbrev
->tag
== DW_TAG_variable
5464 || abbrev
->tag
== DW_TAG_namespace
5465 || part_die
->is_declaration
)
5469 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5470 part_die
->offset
, INSERT
);
5474 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5475 sizeof (struct partial_die_info
));
5477 /* For some DIEs we want to follow their children (if any). For C
5478 we have no reason to follow the children of structures; for other
5479 languages we have to, both so that we can get at method physnames
5480 to infer fully qualified class names, and for DW_AT_specification. */
5481 if (last_die
->has_children
5483 || last_die
->tag
== DW_TAG_namespace
5484 || last_die
->tag
== DW_TAG_enumeration_type
5485 || (cu
->language
!= language_c
5486 && (last_die
->tag
== DW_TAG_class_type
5487 || last_die
->tag
== DW_TAG_structure_type
5488 || last_die
->tag
== DW_TAG_union_type
))))
5491 parent_die
= last_die
;
5495 /* Otherwise we skip to the next sibling, if any. */
5496 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5498 /* Back to the top, do it again. */
5502 /* Read a minimal amount of information into the minimal die structure. */
5505 read_partial_die (struct partial_die_info
*part_die
,
5506 struct abbrev_info
*abbrev
,
5507 unsigned int abbrev_len
, bfd
*abfd
,
5508 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5510 unsigned int bytes_read
, i
;
5511 struct attribute attr
;
5512 int has_low_pc_attr
= 0;
5513 int has_high_pc_attr
= 0;
5515 memset (part_die
, 0, sizeof (struct partial_die_info
));
5517 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5519 info_ptr
+= abbrev_len
;
5524 part_die
->tag
= abbrev
->tag
;
5525 part_die
->has_children
= abbrev
->has_children
;
5527 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5529 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5531 /* Store the data if it is of an attribute we want to keep in a
5532 partial symbol table. */
5537 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5538 if (part_die
->name
== NULL
)
5539 part_die
->name
= DW_STRING (&attr
);
5541 case DW_AT_comp_dir
:
5542 if (part_die
->dirname
== NULL
)
5543 part_die
->dirname
= DW_STRING (&attr
);
5545 case DW_AT_MIPS_linkage_name
:
5546 part_die
->name
= DW_STRING (&attr
);
5549 has_low_pc_attr
= 1;
5550 part_die
->lowpc
= DW_ADDR (&attr
);
5553 has_high_pc_attr
= 1;
5554 part_die
->highpc
= DW_ADDR (&attr
);
5556 case DW_AT_location
:
5557 /* Support the .debug_loc offsets */
5558 if (attr_form_is_block (&attr
))
5560 part_die
->locdesc
= DW_BLOCK (&attr
);
5562 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5564 dwarf2_complex_location_expr_complaint ();
5568 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5569 "partial symbol information");
5572 case DW_AT_language
:
5573 part_die
->language
= DW_UNSND (&attr
);
5575 case DW_AT_external
:
5576 part_die
->is_external
= DW_UNSND (&attr
);
5578 case DW_AT_declaration
:
5579 part_die
->is_declaration
= DW_UNSND (&attr
);
5582 part_die
->has_type
= 1;
5584 case DW_AT_abstract_origin
:
5585 case DW_AT_specification
:
5586 case DW_AT_extension
:
5587 part_die
->has_specification
= 1;
5588 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5591 /* Ignore absolute siblings, they might point outside of
5592 the current compile unit. */
5593 if (attr
.form
== DW_FORM_ref_addr
)
5594 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5596 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5597 + dwarf2_get_ref_die_offset (&attr
, cu
);
5599 case DW_AT_stmt_list
:
5600 part_die
->has_stmt_list
= 1;
5601 part_die
->line_offset
= DW_UNSND (&attr
);
5603 case DW_AT_byte_size
:
5604 part_die
->has_byte_size
= 1;
5611 /* When using the GNU linker, .gnu.linkonce. sections are used to
5612 eliminate duplicate copies of functions and vtables and such.
5613 The linker will arbitrarily choose one and discard the others.
5614 The AT_*_pc values for such functions refer to local labels in
5615 these sections. If the section from that file was discarded, the
5616 labels are not in the output, so the relocs get a value of 0.
5617 If this is a discarded function, mark the pc bounds as invalid,
5618 so that GDB will ignore it. */
5619 if (has_low_pc_attr
&& has_high_pc_attr
5620 && part_die
->lowpc
< part_die
->highpc
5621 && (part_die
->lowpc
!= 0
5622 || dwarf2_per_objfile
->has_section_at_zero
))
5623 part_die
->has_pc_info
= 1;
5627 /* Find a cached partial DIE at OFFSET in CU. */
5629 static struct partial_die_info
*
5630 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5632 struct partial_die_info
*lookup_die
= NULL
;
5633 struct partial_die_info part_die
;
5635 part_die
.offset
= offset
;
5636 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5641 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5643 static struct partial_die_info
*
5644 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5646 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5647 struct partial_die_info
*pd
= NULL
;
5649 if (offset
>= cu
->header
.offset
5650 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5652 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5657 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5659 if (per_cu
->cu
== NULL
)
5661 load_comp_unit (per_cu
, cu
->objfile
);
5662 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5663 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5666 per_cu
->cu
->last_used
= 0;
5667 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5669 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5671 struct cleanup
*back_to
;
5672 struct partial_die_info comp_unit_die
;
5673 struct abbrev_info
*abbrev
;
5674 unsigned int bytes_read
;
5677 per_cu
->load_all_dies
= 1;
5679 /* Re-read the DIEs. */
5680 back_to
= make_cleanup (null_cleanup
, 0);
5681 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5683 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5684 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5686 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5687 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5688 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5689 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5691 if (comp_unit_die
.has_children
)
5692 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5693 do_cleanups (back_to
);
5695 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5699 internal_error (__FILE__
, __LINE__
,
5700 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5701 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5705 /* Adjust PART_DIE before generating a symbol for it. This function
5706 may set the is_external flag or change the DIE's name. */
5709 fixup_partial_die (struct partial_die_info
*part_die
,
5710 struct dwarf2_cu
*cu
)
5712 /* If we found a reference attribute and the DIE has no name, try
5713 to find a name in the referred to DIE. */
5715 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5717 struct partial_die_info
*spec_die
;
5719 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5721 fixup_partial_die (spec_die
, cu
);
5725 part_die
->name
= spec_die
->name
;
5727 /* Copy DW_AT_external attribute if it is set. */
5728 if (spec_die
->is_external
)
5729 part_die
->is_external
= spec_die
->is_external
;
5733 /* Set default names for some unnamed DIEs. */
5734 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5735 || part_die
->tag
== DW_TAG_class_type
))
5736 part_die
->name
= "(anonymous class)";
5738 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5739 part_die
->name
= "(anonymous namespace)";
5741 if (part_die
->tag
== DW_TAG_structure_type
5742 || part_die
->tag
== DW_TAG_class_type
5743 || part_die
->tag
== DW_TAG_union_type
)
5744 guess_structure_name (part_die
, cu
);
5747 /* Read the die from the .debug_info section buffer. Set DIEP to
5748 point to a newly allocated die with its information, except for its
5749 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5750 whether the die has children or not. */
5753 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5754 struct dwarf2_cu
*cu
, int *has_children
)
5756 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5757 struct abbrev_info
*abbrev
;
5758 struct die_info
*die
;
5760 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5761 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5762 info_ptr
+= bytes_read
;
5765 die
= dwarf_alloc_die ();
5767 die
->abbrev
= abbrev_number
;
5774 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5777 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5779 bfd_get_filename (abfd
));
5781 die
= dwarf_alloc_die ();
5782 die
->offset
= offset
;
5783 die
->tag
= abbrev
->tag
;
5784 die
->abbrev
= abbrev_number
;
5787 die
->num_attrs
= abbrev
->num_attrs
;
5788 die
->attrs
= (struct attribute
*)
5789 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5791 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5793 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5794 abfd
, info_ptr
, cu
);
5796 /* If this attribute is an absolute reference to a different
5797 compilation unit, make sure that compilation unit is loaded
5799 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5800 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5801 || (DW_ADDR (&die
->attrs
[i
])
5802 >= cu
->header
.offset
+ cu
->header
.length
)))
5804 struct dwarf2_per_cu_data
*per_cu
;
5805 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5808 /* Mark the dependence relation so that we don't flush PER_CU
5810 dwarf2_add_dependence (cu
, per_cu
);
5812 /* If it's already on the queue, we have nothing to do. */
5816 /* If the compilation unit is already loaded, just mark it as
5818 if (per_cu
->cu
!= NULL
)
5820 per_cu
->cu
->last_used
= 0;
5824 /* Add it to the queue. */
5825 queue_comp_unit (per_cu
);
5830 *has_children
= abbrev
->has_children
;
5834 /* Read an attribute value described by an attribute form. */
5837 read_attribute_value (struct attribute
*attr
, unsigned form
,
5838 bfd
*abfd
, gdb_byte
*info_ptr
,
5839 struct dwarf2_cu
*cu
)
5841 struct comp_unit_head
*cu_header
= &cu
->header
;
5842 unsigned int bytes_read
;
5843 struct dwarf_block
*blk
;
5849 case DW_FORM_ref_addr
:
5850 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5851 info_ptr
+= bytes_read
;
5853 case DW_FORM_block2
:
5854 blk
= dwarf_alloc_block (cu
);
5855 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5857 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5858 info_ptr
+= blk
->size
;
5859 DW_BLOCK (attr
) = blk
;
5861 case DW_FORM_block4
:
5862 blk
= dwarf_alloc_block (cu
);
5863 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5865 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5866 info_ptr
+= blk
->size
;
5867 DW_BLOCK (attr
) = blk
;
5870 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5874 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5878 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5881 case DW_FORM_string
:
5882 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5883 info_ptr
+= bytes_read
;
5886 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5888 info_ptr
+= bytes_read
;
5891 blk
= dwarf_alloc_block (cu
);
5892 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5893 info_ptr
+= bytes_read
;
5894 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5895 info_ptr
+= blk
->size
;
5896 DW_BLOCK (attr
) = blk
;
5898 case DW_FORM_block1
:
5899 blk
= dwarf_alloc_block (cu
);
5900 blk
->size
= read_1_byte (abfd
, info_ptr
);
5902 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5903 info_ptr
+= blk
->size
;
5904 DW_BLOCK (attr
) = blk
;
5907 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5911 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5915 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5916 info_ptr
+= bytes_read
;
5919 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5920 info_ptr
+= bytes_read
;
5923 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5927 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5931 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5935 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5938 case DW_FORM_ref_udata
:
5939 DW_ADDR (attr
) = (cu
->header
.offset
5940 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5941 info_ptr
+= bytes_read
;
5943 case DW_FORM_indirect
:
5944 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5945 info_ptr
+= bytes_read
;
5946 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5949 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5950 dwarf_form_name (form
),
5951 bfd_get_filename (abfd
));
5956 /* Read an attribute described by an abbreviated attribute. */
5959 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5960 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5962 attr
->name
= abbrev
->name
;
5963 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5966 /* read dwarf information from a buffer */
5969 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5971 return bfd_get_8 (abfd
, buf
);
5975 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5977 return bfd_get_signed_8 (abfd
, buf
);
5981 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5983 return bfd_get_16 (abfd
, buf
);
5987 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5989 return bfd_get_signed_16 (abfd
, buf
);
5993 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5995 return bfd_get_32 (abfd
, buf
);
5999 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6001 return bfd_get_signed_32 (abfd
, buf
);
6004 static unsigned long
6005 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6007 return bfd_get_64 (abfd
, buf
);
6011 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6012 unsigned int *bytes_read
)
6014 struct comp_unit_head
*cu_header
= &cu
->header
;
6015 CORE_ADDR retval
= 0;
6017 if (cu_header
->signed_addr_p
)
6019 switch (cu_header
->addr_size
)
6022 retval
= bfd_get_signed_16 (abfd
, buf
);
6025 retval
= bfd_get_signed_32 (abfd
, buf
);
6028 retval
= bfd_get_signed_64 (abfd
, buf
);
6031 internal_error (__FILE__
, __LINE__
,
6032 _("read_address: bad switch, signed [in module %s]"),
6033 bfd_get_filename (abfd
));
6038 switch (cu_header
->addr_size
)
6041 retval
= bfd_get_16 (abfd
, buf
);
6044 retval
= bfd_get_32 (abfd
, buf
);
6047 retval
= bfd_get_64 (abfd
, buf
);
6050 internal_error (__FILE__
, __LINE__
,
6051 _("read_address: bad switch, unsigned [in module %s]"),
6052 bfd_get_filename (abfd
));
6056 *bytes_read
= cu_header
->addr_size
;
6060 /* Read the initial length from a section. The (draft) DWARF 3
6061 specification allows the initial length to take up either 4 bytes
6062 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6063 bytes describe the length and all offsets will be 8 bytes in length
6066 An older, non-standard 64-bit format is also handled by this
6067 function. The older format in question stores the initial length
6068 as an 8-byte quantity without an escape value. Lengths greater
6069 than 2^32 aren't very common which means that the initial 4 bytes
6070 is almost always zero. Since a length value of zero doesn't make
6071 sense for the 32-bit format, this initial zero can be considered to
6072 be an escape value which indicates the presence of the older 64-bit
6073 format. As written, the code can't detect (old format) lengths
6074 greater than 4GB. If it becomes necessary to handle lengths
6075 somewhat larger than 4GB, we could allow other small values (such
6076 as the non-sensical values of 1, 2, and 3) to also be used as
6077 escape values indicating the presence of the old format.
6079 The value returned via bytes_read should be used to increment the
6080 relevant pointer after calling read_initial_length().
6082 As a side effect, this function sets the fields initial_length_size
6083 and offset_size in cu_header to the values appropriate for the
6084 length field. (The format of the initial length field determines
6085 the width of file offsets to be fetched later with read_offset().)
6087 [ Note: read_initial_length() and read_offset() are based on the
6088 document entitled "DWARF Debugging Information Format", revision
6089 3, draft 8, dated November 19, 2001. This document was obtained
6092 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6094 This document is only a draft and is subject to change. (So beware.)
6096 Details regarding the older, non-standard 64-bit format were
6097 determined empirically by examining 64-bit ELF files produced by
6098 the SGI toolchain on an IRIX 6.5 machine.
6100 - Kevin, July 16, 2002
6104 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6105 unsigned int *bytes_read
)
6107 LONGEST length
= bfd_get_32 (abfd
, buf
);
6109 if (length
== 0xffffffff)
6111 length
= bfd_get_64 (abfd
, buf
+ 4);
6114 else if (length
== 0)
6116 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6117 length
= bfd_get_64 (abfd
, buf
);
6127 gdb_assert (cu_header
->initial_length_size
== 0
6128 || cu_header
->initial_length_size
== 4
6129 || cu_header
->initial_length_size
== 8
6130 || cu_header
->initial_length_size
== 12);
6132 if (cu_header
->initial_length_size
!= 0
6133 && cu_header
->initial_length_size
!= *bytes_read
)
6134 complaint (&symfile_complaints
,
6135 _("intermixed 32-bit and 64-bit DWARF sections"));
6137 cu_header
->initial_length_size
= *bytes_read
;
6138 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6144 /* Read an offset from the data stream. The size of the offset is
6145 given by cu_header->offset_size. */
6148 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6149 unsigned int *bytes_read
)
6153 switch (cu_header
->offset_size
)
6156 retval
= bfd_get_32 (abfd
, buf
);
6160 retval
= bfd_get_64 (abfd
, buf
);
6164 internal_error (__FILE__
, __LINE__
,
6165 _("read_offset: bad switch [in module %s]"),
6166 bfd_get_filename (abfd
));
6173 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6175 /* If the size of a host char is 8 bits, we can return a pointer
6176 to the buffer, otherwise we have to copy the data to a buffer
6177 allocated on the temporary obstack. */
6178 gdb_assert (HOST_CHAR_BIT
== 8);
6183 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6185 /* If the size of a host char is 8 bits, we can return a pointer
6186 to the string, otherwise we have to copy the string to a buffer
6187 allocated on the temporary obstack. */
6188 gdb_assert (HOST_CHAR_BIT
== 8);
6191 *bytes_read_ptr
= 1;
6194 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6195 return (char *) buf
;
6199 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6200 const struct comp_unit_head
*cu_header
,
6201 unsigned int *bytes_read_ptr
)
6203 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6206 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6208 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6209 bfd_get_filename (abfd
));
6212 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6214 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6215 bfd_get_filename (abfd
));
6218 gdb_assert (HOST_CHAR_BIT
== 8);
6219 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6221 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6224 static unsigned long
6225 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6227 unsigned long result
;
6228 unsigned int num_read
;
6238 byte
= bfd_get_8 (abfd
, buf
);
6241 result
|= ((unsigned long)(byte
& 127) << shift
);
6242 if ((byte
& 128) == 0)
6248 *bytes_read_ptr
= num_read
;
6253 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6256 int i
, shift
, num_read
;
6265 byte
= bfd_get_8 (abfd
, buf
);
6268 result
|= ((long)(byte
& 127) << shift
);
6270 if ((byte
& 128) == 0)
6275 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6276 result
|= -(((long)1) << shift
);
6277 *bytes_read_ptr
= num_read
;
6281 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6284 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6290 byte
= bfd_get_8 (abfd
, buf
);
6292 if ((byte
& 128) == 0)
6298 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6304 cu
->language
= language_c
;
6306 case DW_LANG_C_plus_plus
:
6307 cu
->language
= language_cplus
;
6309 case DW_LANG_Fortran77
:
6310 case DW_LANG_Fortran90
:
6311 case DW_LANG_Fortran95
:
6312 cu
->language
= language_fortran
;
6314 case DW_LANG_Mips_Assembler
:
6315 cu
->language
= language_asm
;
6318 cu
->language
= language_java
;
6322 cu
->language
= language_ada
;
6324 case DW_LANG_Modula2
:
6325 cu
->language
= language_m2
;
6327 case DW_LANG_Cobol74
:
6328 case DW_LANG_Cobol85
:
6329 case DW_LANG_Pascal83
:
6331 cu
->language
= language_minimal
;
6334 cu
->language_defn
= language_def (cu
->language
);
6337 /* Return the named attribute or NULL if not there. */
6339 static struct attribute
*
6340 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6343 struct attribute
*spec
= NULL
;
6345 for (i
= 0; i
< die
->num_attrs
; ++i
)
6347 if (die
->attrs
[i
].name
== name
)
6348 return &die
->attrs
[i
];
6349 if (die
->attrs
[i
].name
== DW_AT_specification
6350 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6351 spec
= &die
->attrs
[i
];
6355 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6360 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6361 and holds a non-zero value. This function should only be used for
6362 DW_FORM_flag attributes. */
6365 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6367 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6369 return (attr
&& DW_UNSND (attr
));
6373 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6375 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6376 which value is non-zero. However, we have to be careful with
6377 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6378 (via dwarf2_flag_true_p) follows this attribute. So we may
6379 end up accidently finding a declaration attribute that belongs
6380 to a different DIE referenced by the specification attribute,
6381 even though the given DIE does not have a declaration attribute. */
6382 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6383 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6386 /* Return the die giving the specification for DIE, if there is
6389 static struct die_info
*
6390 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6392 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6394 if (spec_attr
== NULL
)
6397 return follow_die_ref (die
, spec_attr
, cu
);
6400 /* Free the line_header structure *LH, and any arrays and strings it
6403 free_line_header (struct line_header
*lh
)
6405 if (lh
->standard_opcode_lengths
)
6406 xfree (lh
->standard_opcode_lengths
);
6408 /* Remember that all the lh->file_names[i].name pointers are
6409 pointers into debug_line_buffer, and don't need to be freed. */
6411 xfree (lh
->file_names
);
6413 /* Similarly for the include directory names. */
6414 if (lh
->include_dirs
)
6415 xfree (lh
->include_dirs
);
6421 /* Add an entry to LH's include directory table. */
6423 add_include_dir (struct line_header
*lh
, char *include_dir
)
6425 /* Grow the array if necessary. */
6426 if (lh
->include_dirs_size
== 0)
6428 lh
->include_dirs_size
= 1; /* for testing */
6429 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6430 * sizeof (*lh
->include_dirs
));
6432 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6434 lh
->include_dirs_size
*= 2;
6435 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6436 (lh
->include_dirs_size
6437 * sizeof (*lh
->include_dirs
)));
6440 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6444 /* Add an entry to LH's file name table. */
6446 add_file_name (struct line_header
*lh
,
6448 unsigned int dir_index
,
6449 unsigned int mod_time
,
6450 unsigned int length
)
6452 struct file_entry
*fe
;
6454 /* Grow the array if necessary. */
6455 if (lh
->file_names_size
== 0)
6457 lh
->file_names_size
= 1; /* for testing */
6458 lh
->file_names
= xmalloc (lh
->file_names_size
6459 * sizeof (*lh
->file_names
));
6461 else if (lh
->num_file_names
>= lh
->file_names_size
)
6463 lh
->file_names_size
*= 2;
6464 lh
->file_names
= xrealloc (lh
->file_names
,
6465 (lh
->file_names_size
6466 * sizeof (*lh
->file_names
)));
6469 fe
= &lh
->file_names
[lh
->num_file_names
++];
6471 fe
->dir_index
= dir_index
;
6472 fe
->mod_time
= mod_time
;
6473 fe
->length
= length
;
6479 /* Read the statement program header starting at OFFSET in
6480 .debug_line, according to the endianness of ABFD. Return a pointer
6481 to a struct line_header, allocated using xmalloc.
6483 NOTE: the strings in the include directory and file name tables of
6484 the returned object point into debug_line_buffer, and must not be
6486 static struct line_header
*
6487 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6488 struct dwarf2_cu
*cu
)
6490 struct cleanup
*back_to
;
6491 struct line_header
*lh
;
6493 unsigned int bytes_read
;
6495 char *cur_dir
, *cur_file
;
6497 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6499 complaint (&symfile_complaints
, _("missing .debug_line section"));
6503 /* Make sure that at least there's room for the total_length field.
6504 That could be 12 bytes long, but we're just going to fudge that. */
6505 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6507 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6511 lh
= xmalloc (sizeof (*lh
));
6512 memset (lh
, 0, sizeof (*lh
));
6513 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6516 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6518 /* Read in the header. */
6520 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6521 line_ptr
+= bytes_read
;
6522 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6523 + dwarf2_per_objfile
->line_size
))
6525 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6528 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6529 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6531 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6532 line_ptr
+= bytes_read
;
6533 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6535 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6537 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6539 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6541 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6543 lh
->standard_opcode_lengths
6544 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6546 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6547 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6549 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6553 /* Read directory table. */
6554 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6556 line_ptr
+= bytes_read
;
6557 add_include_dir (lh
, cur_dir
);
6559 line_ptr
+= bytes_read
;
6561 /* Read file name table. */
6562 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6564 unsigned int dir_index
, mod_time
, length
;
6566 line_ptr
+= bytes_read
;
6567 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6568 line_ptr
+= bytes_read
;
6569 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6570 line_ptr
+= bytes_read
;
6571 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6572 line_ptr
+= bytes_read
;
6574 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6576 line_ptr
+= bytes_read
;
6577 lh
->statement_program_start
= line_ptr
;
6579 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6580 + dwarf2_per_objfile
->line_size
))
6581 complaint (&symfile_complaints
,
6582 _("line number info header doesn't fit in `.debug_line' section"));
6584 discard_cleanups (back_to
);
6588 /* This function exists to work around a bug in certain compilers
6589 (particularly GCC 2.95), in which the first line number marker of a
6590 function does not show up until after the prologue, right before
6591 the second line number marker. This function shifts ADDRESS down
6592 to the beginning of the function if necessary, and is called on
6593 addresses passed to record_line. */
6596 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6598 struct function_range
*fn
;
6600 /* Find the function_range containing address. */
6605 cu
->cached_fn
= cu
->first_fn
;
6609 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6615 while (fn
&& fn
!= cu
->cached_fn
)
6616 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6626 if (address
!= fn
->lowpc
)
6627 complaint (&symfile_complaints
,
6628 _("misplaced first line number at 0x%lx for '%s'"),
6629 (unsigned long) address
, fn
->name
);
6634 /* Decode the Line Number Program (LNP) for the given line_header
6635 structure and CU. The actual information extracted and the type
6636 of structures created from the LNP depends on the value of PST.
6638 1. If PST is NULL, then this procedure uses the data from the program
6639 to create all necessary symbol tables, and their linetables.
6640 The compilation directory of the file is passed in COMP_DIR,
6641 and must not be NULL.
6643 2. If PST is not NULL, this procedure reads the program to determine
6644 the list of files included by the unit represented by PST, and
6645 builds all the associated partial symbol tables. In this case,
6646 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6647 is not used to compute the full name of the symtab, and therefore
6648 omitting it when building the partial symtab does not introduce
6649 the potential for inconsistency - a partial symtab and its associated
6650 symbtab having a different fullname -). */
6653 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6654 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6658 unsigned int bytes_read
;
6659 unsigned char op_code
, extended_op
, adj_opcode
;
6661 struct objfile
*objfile
= cu
->objfile
;
6662 const int decode_for_pst_p
= (pst
!= NULL
);
6663 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6665 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6667 line_ptr
= lh
->statement_program_start
;
6668 line_end
= lh
->statement_program_end
;
6670 /* Read the statement sequences until there's nothing left. */
6671 while (line_ptr
< line_end
)
6673 /* state machine registers */
6674 CORE_ADDR address
= 0;
6675 unsigned int file
= 1;
6676 unsigned int line
= 1;
6677 unsigned int column
= 0;
6678 int is_stmt
= lh
->default_is_stmt
;
6679 int basic_block
= 0;
6680 int end_sequence
= 0;
6682 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6684 /* Start a subfile for the current file of the state machine. */
6685 /* lh->include_dirs and lh->file_names are 0-based, but the
6686 directory and file name numbers in the statement program
6688 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6692 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6694 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6697 /* Decode the table. */
6698 while (!end_sequence
)
6700 op_code
= read_1_byte (abfd
, line_ptr
);
6703 if (op_code
>= lh
->opcode_base
)
6705 /* Special operand. */
6706 adj_opcode
= op_code
- lh
->opcode_base
;
6707 address
+= (adj_opcode
/ lh
->line_range
)
6708 * lh
->minimum_instruction_length
;
6709 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6710 lh
->file_names
[file
- 1].included_p
= 1;
6711 if (!decode_for_pst_p
)
6713 if (last_subfile
!= current_subfile
)
6716 record_line (last_subfile
, 0, address
);
6717 last_subfile
= current_subfile
;
6719 /* Append row to matrix using current values. */
6720 record_line (current_subfile
, line
,
6721 check_cu_functions (address
, cu
));
6725 else switch (op_code
)
6727 case DW_LNS_extended_op
:
6728 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6729 line_ptr
+= bytes_read
;
6730 extended_op
= read_1_byte (abfd
, line_ptr
);
6732 switch (extended_op
)
6734 case DW_LNE_end_sequence
:
6736 lh
->file_names
[file
- 1].included_p
= 1;
6737 if (!decode_for_pst_p
)
6738 record_line (current_subfile
, 0, address
);
6740 case DW_LNE_set_address
:
6741 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6742 line_ptr
+= bytes_read
;
6743 address
+= baseaddr
;
6745 case DW_LNE_define_file
:
6748 unsigned int dir_index
, mod_time
, length
;
6750 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6751 line_ptr
+= bytes_read
;
6753 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6754 line_ptr
+= bytes_read
;
6756 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6757 line_ptr
+= bytes_read
;
6759 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6760 line_ptr
+= bytes_read
;
6761 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6765 complaint (&symfile_complaints
,
6766 _("mangled .debug_line section"));
6771 lh
->file_names
[file
- 1].included_p
= 1;
6772 if (!decode_for_pst_p
)
6774 if (last_subfile
!= current_subfile
)
6777 record_line (last_subfile
, 0, address
);
6778 last_subfile
= current_subfile
;
6780 record_line (current_subfile
, line
,
6781 check_cu_functions (address
, cu
));
6785 case DW_LNS_advance_pc
:
6786 address
+= lh
->minimum_instruction_length
6787 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6788 line_ptr
+= bytes_read
;
6790 case DW_LNS_advance_line
:
6791 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6792 line_ptr
+= bytes_read
;
6794 case DW_LNS_set_file
:
6796 /* The arrays lh->include_dirs and lh->file_names are
6797 0-based, but the directory and file name numbers in
6798 the statement program are 1-based. */
6799 struct file_entry
*fe
;
6802 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6803 line_ptr
+= bytes_read
;
6804 fe
= &lh
->file_names
[file
- 1];
6806 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6808 if (!decode_for_pst_p
)
6810 last_subfile
= current_subfile
;
6811 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6815 case DW_LNS_set_column
:
6816 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6817 line_ptr
+= bytes_read
;
6819 case DW_LNS_negate_stmt
:
6820 is_stmt
= (!is_stmt
);
6822 case DW_LNS_set_basic_block
:
6825 /* Add to the address register of the state machine the
6826 address increment value corresponding to special opcode
6827 255. I.e., this value is scaled by the minimum
6828 instruction length since special opcode 255 would have
6829 scaled the the increment. */
6830 case DW_LNS_const_add_pc
:
6831 address
+= (lh
->minimum_instruction_length
6832 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6834 case DW_LNS_fixed_advance_pc
:
6835 address
+= read_2_bytes (abfd
, line_ptr
);
6840 /* Unknown standard opcode, ignore it. */
6843 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6845 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6846 line_ptr
+= bytes_read
;
6853 if (decode_for_pst_p
)
6857 /* Now that we're done scanning the Line Header Program, we can
6858 create the psymtab of each included file. */
6859 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6860 if (lh
->file_names
[file_index
].included_p
== 1)
6862 const struct file_entry fe
= lh
->file_names
[file_index
];
6863 char *include_name
= fe
.name
;
6864 char *dir_name
= NULL
;
6865 char *pst_filename
= pst
->filename
;
6868 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6870 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6872 include_name
= concat (dir_name
, SLASH_STRING
,
6873 include_name
, (char *)NULL
);
6874 make_cleanup (xfree
, include_name
);
6877 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6879 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6880 pst_filename
, (char *)NULL
);
6881 make_cleanup (xfree
, pst_filename
);
6884 if (strcmp (include_name
, pst_filename
) != 0)
6885 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6890 /* Make sure a symtab is created for every file, even files
6891 which contain only variables (i.e. no code with associated
6895 struct file_entry
*fe
;
6897 for (i
= 0; i
< lh
->num_file_names
; i
++)
6900 fe
= &lh
->file_names
[i
];
6902 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6903 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6905 /* Skip the main file; we don't need it, and it must be
6906 allocated last, so that it will show up before the
6907 non-primary symtabs in the objfile's symtab list. */
6908 if (current_subfile
== first_subfile
)
6911 if (current_subfile
->symtab
== NULL
)
6912 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
6914 fe
->symtab
= current_subfile
->symtab
;
6919 /* Start a subfile for DWARF. FILENAME is the name of the file and
6920 DIRNAME the name of the source directory which contains FILENAME
6921 or NULL if not known. COMP_DIR is the compilation directory for the
6922 linetable's compilation unit or NULL if not known.
6923 This routine tries to keep line numbers from identical absolute and
6924 relative file names in a common subfile.
6926 Using the `list' example from the GDB testsuite, which resides in
6927 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6928 of /srcdir/list0.c yields the following debugging information for list0.c:
6930 DW_AT_name: /srcdir/list0.c
6931 DW_AT_comp_dir: /compdir
6932 files.files[0].name: list0.h
6933 files.files[0].dir: /srcdir
6934 files.files[1].name: list0.c
6935 files.files[1].dir: /srcdir
6937 The line number information for list0.c has to end up in a single
6938 subfile, so that `break /srcdir/list0.c:1' works as expected.
6939 start_subfile will ensure that this happens provided that we pass the
6940 concatenation of files.files[1].dir and files.files[1].name as the
6944 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6948 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6949 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6950 second argument to start_subfile. To be consistent, we do the
6951 same here. In order not to lose the line information directory,
6952 we concatenate it to the filename when it makes sense.
6953 Note that the Dwarf3 standard says (speaking of filenames in line
6954 information): ``The directory index is ignored for file names
6955 that represent full path names''. Thus ignoring dirname in the
6956 `else' branch below isn't an issue. */
6958 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6959 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6961 fullname
= filename
;
6963 start_subfile (fullname
, comp_dir
);
6965 if (fullname
!= filename
)
6970 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6971 struct dwarf2_cu
*cu
)
6973 struct objfile
*objfile
= cu
->objfile
;
6974 struct comp_unit_head
*cu_header
= &cu
->header
;
6976 /* NOTE drow/2003-01-30: There used to be a comment and some special
6977 code here to turn a symbol with DW_AT_external and a
6978 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6979 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6980 with some versions of binutils) where shared libraries could have
6981 relocations against symbols in their debug information - the
6982 minimal symbol would have the right address, but the debug info
6983 would not. It's no longer necessary, because we will explicitly
6984 apply relocations when we read in the debug information now. */
6986 /* A DW_AT_location attribute with no contents indicates that a
6987 variable has been optimized away. */
6988 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6990 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6994 /* Handle one degenerate form of location expression specially, to
6995 preserve GDB's previous behavior when section offsets are
6996 specified. If this is just a DW_OP_addr then mark this symbol
6999 if (attr_form_is_block (attr
)
7000 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7001 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7005 SYMBOL_VALUE_ADDRESS (sym
) =
7006 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7007 fixup_symbol_section (sym
, objfile
);
7008 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7009 SYMBOL_SECTION (sym
));
7010 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7014 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7015 expression evaluator, and use LOC_COMPUTED only when necessary
7016 (i.e. when the value of a register or memory location is
7017 referenced, or a thread-local block, etc.). Then again, it might
7018 not be worthwhile. I'm assuming that it isn't unless performance
7019 or memory numbers show me otherwise. */
7021 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7022 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7025 /* Given a pointer to a DWARF information entry, figure out if we need
7026 to make a symbol table entry for it, and if so, create a new entry
7027 and return a pointer to it.
7028 If TYPE is NULL, determine symbol type from the die, otherwise
7029 used the passed type. */
7031 static struct symbol
*
7032 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7034 struct objfile
*objfile
= cu
->objfile
;
7035 struct symbol
*sym
= NULL
;
7037 struct attribute
*attr
= NULL
;
7038 struct attribute
*attr2
= NULL
;
7041 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7043 if (die
->tag
!= DW_TAG_namespace
)
7044 name
= dwarf2_linkage_name (die
, cu
);
7046 name
= TYPE_NAME (type
);
7050 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7051 sizeof (struct symbol
));
7052 OBJSTAT (objfile
, n_syms
++);
7053 memset (sym
, 0, sizeof (struct symbol
));
7055 /* Cache this symbol's name and the name's demangled form (if any). */
7056 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7057 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7059 /* Default assumptions.
7060 Use the passed type or decode it from the die. */
7061 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7062 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7064 SYMBOL_TYPE (sym
) = type
;
7066 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7067 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7070 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7073 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7076 int file_index
= DW_UNSND (attr
);
7077 if (cu
->line_header
== NULL
7078 || file_index
> cu
->line_header
->num_file_names
)
7079 complaint (&symfile_complaints
,
7080 _("file index out of range"));
7083 struct file_entry
*fe
;
7084 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7085 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7092 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7095 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7097 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7099 case DW_TAG_subprogram
:
7100 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7102 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7103 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7104 if (attr2
&& (DW_UNSND (attr2
) != 0))
7106 add_symbol_to_list (sym
, &global_symbols
);
7110 add_symbol_to_list (sym
, cu
->list_in_scope
);
7113 case DW_TAG_variable
:
7114 /* Compilation with minimal debug info may result in variables
7115 with missing type entries. Change the misleading `void' type
7116 to something sensible. */
7117 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7118 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
7119 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
7120 "<variable, no debug info>",
7122 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7125 dwarf2_const_value (attr
, sym
, cu
);
7126 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7127 if (attr2
&& (DW_UNSND (attr2
) != 0))
7128 add_symbol_to_list (sym
, &global_symbols
);
7130 add_symbol_to_list (sym
, cu
->list_in_scope
);
7133 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7136 var_decode_location (attr
, sym
, cu
);
7137 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7138 if (attr2
&& (DW_UNSND (attr2
) != 0))
7139 add_symbol_to_list (sym
, &global_symbols
);
7141 add_symbol_to_list (sym
, cu
->list_in_scope
);
7145 /* We do not know the address of this symbol.
7146 If it is an external symbol and we have type information
7147 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7148 The address of the variable will then be determined from
7149 the minimal symbol table whenever the variable is
7151 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7152 if (attr2
&& (DW_UNSND (attr2
) != 0)
7153 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7155 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7156 add_symbol_to_list (sym
, &global_symbols
);
7160 case DW_TAG_formal_parameter
:
7161 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7164 var_decode_location (attr
, sym
, cu
);
7165 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7166 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7167 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7169 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7172 dwarf2_const_value (attr
, sym
, cu
);
7174 add_symbol_to_list (sym
, cu
->list_in_scope
);
7176 case DW_TAG_unspecified_parameters
:
7177 /* From varargs functions; gdb doesn't seem to have any
7178 interest in this information, so just ignore it for now.
7181 case DW_TAG_class_type
:
7182 case DW_TAG_structure_type
:
7183 case DW_TAG_union_type
:
7184 case DW_TAG_set_type
:
7185 case DW_TAG_enumeration_type
:
7186 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7187 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7189 /* Make sure that the symbol includes appropriate enclosing
7190 classes/namespaces in its name. These are calculated in
7191 read_structure_type, and the correct name is saved in
7194 if (cu
->language
== language_cplus
7195 || cu
->language
== language_java
)
7197 struct type
*type
= SYMBOL_TYPE (sym
);
7199 if (TYPE_TAG_NAME (type
) != NULL
)
7201 /* FIXME: carlton/2003-11-10: Should this use
7202 SYMBOL_SET_NAMES instead? (The same problem also
7203 arises further down in this function.) */
7204 /* The type's name is already allocated along with
7205 this objfile, so we don't need to duplicate it
7207 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7212 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7213 really ever be static objects: otherwise, if you try
7214 to, say, break of a class's method and you're in a file
7215 which doesn't mention that class, it won't work unless
7216 the check for all static symbols in lookup_symbol_aux
7217 saves you. See the OtherFileClass tests in
7218 gdb.c++/namespace.exp. */
7220 struct pending
**list_to_add
;
7222 list_to_add
= (cu
->list_in_scope
== &file_symbols
7223 && (cu
->language
== language_cplus
7224 || cu
->language
== language_java
)
7225 ? &global_symbols
: cu
->list_in_scope
);
7227 add_symbol_to_list (sym
, list_to_add
);
7229 /* The semantics of C++ state that "struct foo { ... }" also
7230 defines a typedef for "foo". A Java class declaration also
7231 defines a typedef for the class. Synthesize a typedef symbol
7232 so that "ptype foo" works as expected. */
7233 if (cu
->language
== language_cplus
7234 || cu
->language
== language_java
)
7236 struct symbol
*typedef_sym
= (struct symbol
*)
7237 obstack_alloc (&objfile
->objfile_obstack
,
7238 sizeof (struct symbol
));
7239 *typedef_sym
= *sym
;
7240 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7241 /* The symbol's name is already allocated along with
7242 this objfile, so we don't need to duplicate it for
7244 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7245 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7246 add_symbol_to_list (typedef_sym
, list_to_add
);
7250 case DW_TAG_typedef
:
7251 if (processing_has_namespace_info
7252 && processing_current_prefix
[0] != '\0')
7254 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7255 processing_current_prefix
,
7258 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7259 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7260 add_symbol_to_list (sym
, cu
->list_in_scope
);
7262 case DW_TAG_base_type
:
7263 case DW_TAG_subrange_type
:
7264 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7265 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7266 add_symbol_to_list (sym
, cu
->list_in_scope
);
7268 case DW_TAG_enumerator
:
7269 if (processing_has_namespace_info
7270 && processing_current_prefix
[0] != '\0')
7272 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7273 processing_current_prefix
,
7276 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7279 dwarf2_const_value (attr
, sym
, cu
);
7282 /* NOTE: carlton/2003-11-10: See comment above in the
7283 DW_TAG_class_type, etc. block. */
7285 struct pending
**list_to_add
;
7287 list_to_add
= (cu
->list_in_scope
== &file_symbols
7288 && (cu
->language
== language_cplus
7289 || cu
->language
== language_java
)
7290 ? &global_symbols
: cu
->list_in_scope
);
7292 add_symbol_to_list (sym
, list_to_add
);
7295 case DW_TAG_namespace
:
7296 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7297 add_symbol_to_list (sym
, &global_symbols
);
7300 /* Not a tag we recognize. Hopefully we aren't processing
7301 trash data, but since we must specifically ignore things
7302 we don't recognize, there is nothing else we should do at
7304 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7305 dwarf_tag_name (die
->tag
));
7312 /* Copy constant value from an attribute to a symbol. */
7315 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7316 struct dwarf2_cu
*cu
)
7318 struct objfile
*objfile
= cu
->objfile
;
7319 struct comp_unit_head
*cu_header
= &cu
->header
;
7320 struct dwarf_block
*blk
;
7325 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7326 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7327 cu_header
->addr_size
,
7328 TYPE_LENGTH (SYMBOL_TYPE
7330 SYMBOL_VALUE_BYTES (sym
) =
7331 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7332 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7333 it's body - store_unsigned_integer. */
7334 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7336 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7338 case DW_FORM_block1
:
7339 case DW_FORM_block2
:
7340 case DW_FORM_block4
:
7342 blk
= DW_BLOCK (attr
);
7343 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7344 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7346 TYPE_LENGTH (SYMBOL_TYPE
7348 SYMBOL_VALUE_BYTES (sym
) =
7349 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7350 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7351 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7354 /* The DW_AT_const_value attributes are supposed to carry the
7355 symbol's value "represented as it would be on the target
7356 architecture." By the time we get here, it's already been
7357 converted to host endianness, so we just need to sign- or
7358 zero-extend it as appropriate. */
7360 dwarf2_const_value_data (attr
, sym
, 8);
7363 dwarf2_const_value_data (attr
, sym
, 16);
7366 dwarf2_const_value_data (attr
, sym
, 32);
7369 dwarf2_const_value_data (attr
, sym
, 64);
7373 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7374 SYMBOL_CLASS (sym
) = LOC_CONST
;
7378 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7379 SYMBOL_CLASS (sym
) = LOC_CONST
;
7383 complaint (&symfile_complaints
,
7384 _("unsupported const value attribute form: '%s'"),
7385 dwarf_form_name (attr
->form
));
7386 SYMBOL_VALUE (sym
) = 0;
7387 SYMBOL_CLASS (sym
) = LOC_CONST
;
7393 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7394 or zero-extend it as appropriate for the symbol's type. */
7396 dwarf2_const_value_data (struct attribute
*attr
,
7400 LONGEST l
= DW_UNSND (attr
);
7402 if (bits
< sizeof (l
) * 8)
7404 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7405 l
&= ((LONGEST
) 1 << bits
) - 1;
7407 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7410 SYMBOL_VALUE (sym
) = l
;
7411 SYMBOL_CLASS (sym
) = LOC_CONST
;
7415 /* Return the type of the die in question using its DW_AT_type attribute. */
7417 static struct type
*
7418 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7421 struct attribute
*type_attr
;
7422 struct die_info
*type_die
;
7424 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7427 /* A missing DW_AT_type represents a void type. */
7428 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7431 type_die
= follow_die_ref (die
, type_attr
, cu
);
7433 type
= tag_type_to_type (type_die
, cu
);
7436 dump_die (type_die
);
7437 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7443 /* Return the containing type of the die in question using its
7444 DW_AT_containing_type attribute. */
7446 static struct type
*
7447 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7449 struct type
*type
= NULL
;
7450 struct attribute
*type_attr
;
7451 struct die_info
*type_die
= NULL
;
7453 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7456 type_die
= follow_die_ref (die
, type_attr
, cu
);
7457 type
= tag_type_to_type (type_die
, cu
);
7462 dump_die (type_die
);
7463 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7469 static struct type
*
7470 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7478 read_type_die (die
, cu
);
7482 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7490 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7492 char *prefix
= determine_prefix (die
, cu
);
7493 const char *old_prefix
= processing_current_prefix
;
7494 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7495 processing_current_prefix
= prefix
;
7499 case DW_TAG_class_type
:
7500 case DW_TAG_structure_type
:
7501 case DW_TAG_union_type
:
7502 read_structure_type (die
, cu
);
7504 case DW_TAG_enumeration_type
:
7505 read_enumeration_type (die
, cu
);
7507 case DW_TAG_subprogram
:
7508 case DW_TAG_subroutine_type
:
7509 read_subroutine_type (die
, cu
);
7511 case DW_TAG_array_type
:
7512 read_array_type (die
, cu
);
7514 case DW_TAG_set_type
:
7515 read_set_type (die
, cu
);
7517 case DW_TAG_pointer_type
:
7518 read_tag_pointer_type (die
, cu
);
7520 case DW_TAG_ptr_to_member_type
:
7521 read_tag_ptr_to_member_type (die
, cu
);
7523 case DW_TAG_reference_type
:
7524 read_tag_reference_type (die
, cu
);
7526 case DW_TAG_const_type
:
7527 read_tag_const_type (die
, cu
);
7529 case DW_TAG_volatile_type
:
7530 read_tag_volatile_type (die
, cu
);
7532 case DW_TAG_string_type
:
7533 read_tag_string_type (die
, cu
);
7535 case DW_TAG_typedef
:
7536 read_typedef (die
, cu
);
7538 case DW_TAG_subrange_type
:
7539 read_subrange_type (die
, cu
);
7541 case DW_TAG_base_type
:
7542 read_base_type (die
, cu
);
7544 case DW_TAG_unspecified_type
:
7545 read_unspecified_type (die
, cu
);
7548 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7549 dwarf_tag_name (die
->tag
));
7553 processing_current_prefix
= old_prefix
;
7554 do_cleanups (back_to
);
7557 /* Return the name of the namespace/class that DIE is defined within,
7558 or "" if we can't tell. The caller should xfree the result. */
7560 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7561 therein) for an example of how to use this function to deal with
7562 DW_AT_specification. */
7565 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7567 struct die_info
*parent
;
7569 if (cu
->language
!= language_cplus
7570 && cu
->language
!= language_java
)
7573 parent
= die
->parent
;
7577 return xstrdup ("");
7581 switch (parent
->tag
) {
7582 case DW_TAG_namespace
:
7584 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7585 before doing this check? */
7586 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7588 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7593 char *parent_prefix
= determine_prefix (parent
, cu
);
7594 char *retval
= typename_concat (NULL
, parent_prefix
,
7595 namespace_name (parent
, &dummy
,
7598 xfree (parent_prefix
);
7603 case DW_TAG_class_type
:
7604 case DW_TAG_structure_type
:
7606 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7608 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7612 const char *old_prefix
= processing_current_prefix
;
7613 char *new_prefix
= determine_prefix (parent
, cu
);
7616 processing_current_prefix
= new_prefix
;
7617 retval
= determine_class_name (parent
, cu
);
7618 processing_current_prefix
= old_prefix
;
7625 return determine_prefix (parent
, cu
);
7630 /* Return a newly-allocated string formed by concatenating PREFIX and
7631 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7632 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7633 perform an obconcat, otherwise allocate storage for the result. The CU argument
7634 is used to determine the language and hence, the appropriate separator. */
7636 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7639 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7640 struct dwarf2_cu
*cu
)
7644 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7646 else if (cu
->language
== language_java
)
7653 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7658 strcpy (retval
, prefix
);
7659 strcat (retval
, sep
);
7662 strcat (retval
, suffix
);
7668 /* We have an obstack. */
7669 return obconcat (obs
, prefix
, sep
, suffix
);
7673 static struct type
*
7674 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7676 struct objfile
*objfile
= cu
->objfile
;
7678 /* FIXME - this should not produce a new (struct type *)
7679 every time. It should cache base types. */
7683 case DW_ATE_address
:
7684 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7686 case DW_ATE_boolean
:
7687 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7689 case DW_ATE_complex_float
:
7692 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7696 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7702 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7706 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7713 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7716 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7720 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7724 case DW_ATE_signed_char
:
7725 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7727 case DW_ATE_unsigned
:
7731 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7734 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7738 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7742 case DW_ATE_unsigned_char
:
7743 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7746 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7753 copy_die (struct die_info
*old_die
)
7755 struct die_info
*new_die
;
7758 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7759 memset (new_die
, 0, sizeof (struct die_info
));
7761 new_die
->tag
= old_die
->tag
;
7762 new_die
->has_children
= old_die
->has_children
;
7763 new_die
->abbrev
= old_die
->abbrev
;
7764 new_die
->offset
= old_die
->offset
;
7765 new_die
->type
= NULL
;
7767 num_attrs
= old_die
->num_attrs
;
7768 new_die
->num_attrs
= num_attrs
;
7769 new_die
->attrs
= (struct attribute
*)
7770 xmalloc (num_attrs
* sizeof (struct attribute
));
7772 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7774 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7775 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7776 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7779 new_die
->next
= NULL
;
7784 /* Return sibling of die, NULL if no sibling. */
7786 static struct die_info
*
7787 sibling_die (struct die_info
*die
)
7789 return die
->sibling
;
7792 /* Get linkage name of a die, return NULL if not found. */
7795 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7797 struct attribute
*attr
;
7799 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7800 if (attr
&& DW_STRING (attr
))
7801 return DW_STRING (attr
);
7802 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7803 if (attr
&& DW_STRING (attr
))
7804 return DW_STRING (attr
);
7808 /* Get name of a die, return NULL if not found. */
7811 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7813 struct attribute
*attr
;
7815 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7816 if (attr
&& DW_STRING (attr
))
7817 return DW_STRING (attr
);
7821 /* Return the die that this die in an extension of, or NULL if there
7824 static struct die_info
*
7825 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7827 struct attribute
*attr
;
7829 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7833 return follow_die_ref (die
, attr
, cu
);
7836 /* Convert a DIE tag into its string name. */
7839 dwarf_tag_name (unsigned tag
)
7843 case DW_TAG_padding
:
7844 return "DW_TAG_padding";
7845 case DW_TAG_array_type
:
7846 return "DW_TAG_array_type";
7847 case DW_TAG_class_type
:
7848 return "DW_TAG_class_type";
7849 case DW_TAG_entry_point
:
7850 return "DW_TAG_entry_point";
7851 case DW_TAG_enumeration_type
:
7852 return "DW_TAG_enumeration_type";
7853 case DW_TAG_formal_parameter
:
7854 return "DW_TAG_formal_parameter";
7855 case DW_TAG_imported_declaration
:
7856 return "DW_TAG_imported_declaration";
7858 return "DW_TAG_label";
7859 case DW_TAG_lexical_block
:
7860 return "DW_TAG_lexical_block";
7862 return "DW_TAG_member";
7863 case DW_TAG_pointer_type
:
7864 return "DW_TAG_pointer_type";
7865 case DW_TAG_reference_type
:
7866 return "DW_TAG_reference_type";
7867 case DW_TAG_compile_unit
:
7868 return "DW_TAG_compile_unit";
7869 case DW_TAG_string_type
:
7870 return "DW_TAG_string_type";
7871 case DW_TAG_structure_type
:
7872 return "DW_TAG_structure_type";
7873 case DW_TAG_subroutine_type
:
7874 return "DW_TAG_subroutine_type";
7875 case DW_TAG_typedef
:
7876 return "DW_TAG_typedef";
7877 case DW_TAG_union_type
:
7878 return "DW_TAG_union_type";
7879 case DW_TAG_unspecified_parameters
:
7880 return "DW_TAG_unspecified_parameters";
7881 case DW_TAG_variant
:
7882 return "DW_TAG_variant";
7883 case DW_TAG_common_block
:
7884 return "DW_TAG_common_block";
7885 case DW_TAG_common_inclusion
:
7886 return "DW_TAG_common_inclusion";
7887 case DW_TAG_inheritance
:
7888 return "DW_TAG_inheritance";
7889 case DW_TAG_inlined_subroutine
:
7890 return "DW_TAG_inlined_subroutine";
7892 return "DW_TAG_module";
7893 case DW_TAG_ptr_to_member_type
:
7894 return "DW_TAG_ptr_to_member_type";
7895 case DW_TAG_set_type
:
7896 return "DW_TAG_set_type";
7897 case DW_TAG_subrange_type
:
7898 return "DW_TAG_subrange_type";
7899 case DW_TAG_with_stmt
:
7900 return "DW_TAG_with_stmt";
7901 case DW_TAG_access_declaration
:
7902 return "DW_TAG_access_declaration";
7903 case DW_TAG_base_type
:
7904 return "DW_TAG_base_type";
7905 case DW_TAG_catch_block
:
7906 return "DW_TAG_catch_block";
7907 case DW_TAG_const_type
:
7908 return "DW_TAG_const_type";
7909 case DW_TAG_constant
:
7910 return "DW_TAG_constant";
7911 case DW_TAG_enumerator
:
7912 return "DW_TAG_enumerator";
7913 case DW_TAG_file_type
:
7914 return "DW_TAG_file_type";
7916 return "DW_TAG_friend";
7917 case DW_TAG_namelist
:
7918 return "DW_TAG_namelist";
7919 case DW_TAG_namelist_item
:
7920 return "DW_TAG_namelist_item";
7921 case DW_TAG_packed_type
:
7922 return "DW_TAG_packed_type";
7923 case DW_TAG_subprogram
:
7924 return "DW_TAG_subprogram";
7925 case DW_TAG_template_type_param
:
7926 return "DW_TAG_template_type_param";
7927 case DW_TAG_template_value_param
:
7928 return "DW_TAG_template_value_param";
7929 case DW_TAG_thrown_type
:
7930 return "DW_TAG_thrown_type";
7931 case DW_TAG_try_block
:
7932 return "DW_TAG_try_block";
7933 case DW_TAG_variant_part
:
7934 return "DW_TAG_variant_part";
7935 case DW_TAG_variable
:
7936 return "DW_TAG_variable";
7937 case DW_TAG_volatile_type
:
7938 return "DW_TAG_volatile_type";
7939 case DW_TAG_dwarf_procedure
:
7940 return "DW_TAG_dwarf_procedure";
7941 case DW_TAG_restrict_type
:
7942 return "DW_TAG_restrict_type";
7943 case DW_TAG_interface_type
:
7944 return "DW_TAG_interface_type";
7945 case DW_TAG_namespace
:
7946 return "DW_TAG_namespace";
7947 case DW_TAG_imported_module
:
7948 return "DW_TAG_imported_module";
7949 case DW_TAG_unspecified_type
:
7950 return "DW_TAG_unspecified_type";
7951 case DW_TAG_partial_unit
:
7952 return "DW_TAG_partial_unit";
7953 case DW_TAG_imported_unit
:
7954 return "DW_TAG_imported_unit";
7955 case DW_TAG_condition
:
7956 return "DW_TAG_condition";
7957 case DW_TAG_shared_type
:
7958 return "DW_TAG_shared_type";
7959 case DW_TAG_MIPS_loop
:
7960 return "DW_TAG_MIPS_loop";
7961 case DW_TAG_HP_array_descriptor
:
7962 return "DW_TAG_HP_array_descriptor";
7963 case DW_TAG_format_label
:
7964 return "DW_TAG_format_label";
7965 case DW_TAG_function_template
:
7966 return "DW_TAG_function_template";
7967 case DW_TAG_class_template
:
7968 return "DW_TAG_class_template";
7969 case DW_TAG_GNU_BINCL
:
7970 return "DW_TAG_GNU_BINCL";
7971 case DW_TAG_GNU_EINCL
:
7972 return "DW_TAG_GNU_EINCL";
7973 case DW_TAG_upc_shared_type
:
7974 return "DW_TAG_upc_shared_type";
7975 case DW_TAG_upc_strict_type
:
7976 return "DW_TAG_upc_strict_type";
7977 case DW_TAG_upc_relaxed_type
:
7978 return "DW_TAG_upc_relaxed_type";
7979 case DW_TAG_PGI_kanji_type
:
7980 return "DW_TAG_PGI_kanji_type";
7981 case DW_TAG_PGI_interface_block
:
7982 return "DW_TAG_PGI_interface_block";
7984 return "DW_TAG_<unknown>";
7988 /* Convert a DWARF attribute code into its string name. */
7991 dwarf_attr_name (unsigned attr
)
7996 return "DW_AT_sibling";
7997 case DW_AT_location
:
7998 return "DW_AT_location";
8000 return "DW_AT_name";
8001 case DW_AT_ordering
:
8002 return "DW_AT_ordering";
8003 case DW_AT_subscr_data
:
8004 return "DW_AT_subscr_data";
8005 case DW_AT_byte_size
:
8006 return "DW_AT_byte_size";
8007 case DW_AT_bit_offset
:
8008 return "DW_AT_bit_offset";
8009 case DW_AT_bit_size
:
8010 return "DW_AT_bit_size";
8011 case DW_AT_element_list
:
8012 return "DW_AT_element_list";
8013 case DW_AT_stmt_list
:
8014 return "DW_AT_stmt_list";
8016 return "DW_AT_low_pc";
8018 return "DW_AT_high_pc";
8019 case DW_AT_language
:
8020 return "DW_AT_language";
8022 return "DW_AT_member";
8024 return "DW_AT_discr";
8025 case DW_AT_discr_value
:
8026 return "DW_AT_discr_value";
8027 case DW_AT_visibility
:
8028 return "DW_AT_visibility";
8030 return "DW_AT_import";
8031 case DW_AT_string_length
:
8032 return "DW_AT_string_length";
8033 case DW_AT_common_reference
:
8034 return "DW_AT_common_reference";
8035 case DW_AT_comp_dir
:
8036 return "DW_AT_comp_dir";
8037 case DW_AT_const_value
:
8038 return "DW_AT_const_value";
8039 case DW_AT_containing_type
:
8040 return "DW_AT_containing_type";
8041 case DW_AT_default_value
:
8042 return "DW_AT_default_value";
8044 return "DW_AT_inline";
8045 case DW_AT_is_optional
:
8046 return "DW_AT_is_optional";
8047 case DW_AT_lower_bound
:
8048 return "DW_AT_lower_bound";
8049 case DW_AT_producer
:
8050 return "DW_AT_producer";
8051 case DW_AT_prototyped
:
8052 return "DW_AT_prototyped";
8053 case DW_AT_return_addr
:
8054 return "DW_AT_return_addr";
8055 case DW_AT_start_scope
:
8056 return "DW_AT_start_scope";
8057 case DW_AT_stride_size
:
8058 return "DW_AT_stride_size";
8059 case DW_AT_upper_bound
:
8060 return "DW_AT_upper_bound";
8061 case DW_AT_abstract_origin
:
8062 return "DW_AT_abstract_origin";
8063 case DW_AT_accessibility
:
8064 return "DW_AT_accessibility";
8065 case DW_AT_address_class
:
8066 return "DW_AT_address_class";
8067 case DW_AT_artificial
:
8068 return "DW_AT_artificial";
8069 case DW_AT_base_types
:
8070 return "DW_AT_base_types";
8071 case DW_AT_calling_convention
:
8072 return "DW_AT_calling_convention";
8074 return "DW_AT_count";
8075 case DW_AT_data_member_location
:
8076 return "DW_AT_data_member_location";
8077 case DW_AT_decl_column
:
8078 return "DW_AT_decl_column";
8079 case DW_AT_decl_file
:
8080 return "DW_AT_decl_file";
8081 case DW_AT_decl_line
:
8082 return "DW_AT_decl_line";
8083 case DW_AT_declaration
:
8084 return "DW_AT_declaration";
8085 case DW_AT_discr_list
:
8086 return "DW_AT_discr_list";
8087 case DW_AT_encoding
:
8088 return "DW_AT_encoding";
8089 case DW_AT_external
:
8090 return "DW_AT_external";
8091 case DW_AT_frame_base
:
8092 return "DW_AT_frame_base";
8094 return "DW_AT_friend";
8095 case DW_AT_identifier_case
:
8096 return "DW_AT_identifier_case";
8097 case DW_AT_macro_info
:
8098 return "DW_AT_macro_info";
8099 case DW_AT_namelist_items
:
8100 return "DW_AT_namelist_items";
8101 case DW_AT_priority
:
8102 return "DW_AT_priority";
8104 return "DW_AT_segment";
8105 case DW_AT_specification
:
8106 return "DW_AT_specification";
8107 case DW_AT_static_link
:
8108 return "DW_AT_static_link";
8110 return "DW_AT_type";
8111 case DW_AT_use_location
:
8112 return "DW_AT_use_location";
8113 case DW_AT_variable_parameter
:
8114 return "DW_AT_variable_parameter";
8115 case DW_AT_virtuality
:
8116 return "DW_AT_virtuality";
8117 case DW_AT_vtable_elem_location
:
8118 return "DW_AT_vtable_elem_location";
8119 /* DWARF 3 values. */
8120 case DW_AT_allocated
:
8121 return "DW_AT_allocated";
8122 case DW_AT_associated
:
8123 return "DW_AT_associated";
8124 case DW_AT_data_location
:
8125 return "DW_AT_data_location";
8127 return "DW_AT_stride";
8128 case DW_AT_entry_pc
:
8129 return "DW_AT_entry_pc";
8130 case DW_AT_use_UTF8
:
8131 return "DW_AT_use_UTF8";
8132 case DW_AT_extension
:
8133 return "DW_AT_extension";
8135 return "DW_AT_ranges";
8136 case DW_AT_trampoline
:
8137 return "DW_AT_trampoline";
8138 case DW_AT_call_column
:
8139 return "DW_AT_call_column";
8140 case DW_AT_call_file
:
8141 return "DW_AT_call_file";
8142 case DW_AT_call_line
:
8143 return "DW_AT_call_line";
8144 case DW_AT_description
:
8145 return "DW_AT_description";
8146 case DW_AT_binary_scale
:
8147 return "DW_AT_binary_scale";
8148 case DW_AT_decimal_scale
:
8149 return "DW_AT_decimal_scale";
8151 return "DW_AT_small";
8152 case DW_AT_decimal_sign
:
8153 return "DW_AT_decimal_sign";
8154 case DW_AT_digit_count
:
8155 return "DW_AT_digit_count";
8156 case DW_AT_picture_string
:
8157 return "DW_AT_picture_string";
8159 return "DW_AT_mutable";
8160 case DW_AT_threads_scaled
:
8161 return "DW_AT_threads_scaled";
8162 case DW_AT_explicit
:
8163 return "DW_AT_explicit";
8164 case DW_AT_object_pointer
:
8165 return "DW_AT_object_pointer";
8166 case DW_AT_endianity
:
8167 return "DW_AT_endianity";
8168 case DW_AT_elemental
:
8169 return "DW_AT_elemental";
8171 return "DW_AT_pure";
8172 case DW_AT_recursive
:
8173 return "DW_AT_recursive";
8175 /* SGI/MIPS extensions. */
8176 case DW_AT_MIPS_fde
:
8177 return "DW_AT_MIPS_fde";
8178 case DW_AT_MIPS_loop_begin
:
8179 return "DW_AT_MIPS_loop_begin";
8180 case DW_AT_MIPS_tail_loop_begin
:
8181 return "DW_AT_MIPS_tail_loop_begin";
8182 case DW_AT_MIPS_epilog_begin
:
8183 return "DW_AT_MIPS_epilog_begin";
8184 case DW_AT_MIPS_loop_unroll_factor
:
8185 return "DW_AT_MIPS_loop_unroll_factor";
8186 case DW_AT_MIPS_software_pipeline_depth
:
8187 return "DW_AT_MIPS_software_pipeline_depth";
8188 case DW_AT_MIPS_linkage_name
:
8189 return "DW_AT_MIPS_linkage_name";
8190 case DW_AT_MIPS_stride
:
8191 return "DW_AT_MIPS_stride";
8192 case DW_AT_MIPS_abstract_name
:
8193 return "DW_AT_MIPS_abstract_name";
8194 case DW_AT_MIPS_clone_origin
:
8195 return "DW_AT_MIPS_clone_origin";
8196 case DW_AT_MIPS_has_inlines
:
8197 return "DW_AT_MIPS_has_inlines";
8199 /* HP extensions. */
8200 case DW_AT_HP_block_index
:
8201 return "DW_AT_HP_block_index";
8202 case DW_AT_HP_unmodifiable
:
8203 return "DW_AT_HP_unmodifiable";
8204 case DW_AT_HP_actuals_stmt_list
:
8205 return "DW_AT_HP_actuals_stmt_list";
8206 case DW_AT_HP_proc_per_section
:
8207 return "DW_AT_HP_proc_per_section";
8208 case DW_AT_HP_raw_data_ptr
:
8209 return "DW_AT_HP_raw_data_ptr";
8210 case DW_AT_HP_pass_by_reference
:
8211 return "DW_AT_HP_pass_by_reference";
8212 case DW_AT_HP_opt_level
:
8213 return "DW_AT_HP_opt_level";
8214 case DW_AT_HP_prof_version_id
:
8215 return "DW_AT_HP_prof_version_id";
8216 case DW_AT_HP_opt_flags
:
8217 return "DW_AT_HP_opt_flags";
8218 case DW_AT_HP_cold_region_low_pc
:
8219 return "DW_AT_HP_cold_region_low_pc";
8220 case DW_AT_HP_cold_region_high_pc
:
8221 return "DW_AT_HP_cold_region_high_pc";
8222 case DW_AT_HP_all_variables_modifiable
:
8223 return "DW_AT_HP_all_variables_modifiable";
8224 case DW_AT_HP_linkage_name
:
8225 return "DW_AT_HP_linkage_name";
8226 case DW_AT_HP_prof_flags
:
8227 return "DW_AT_HP_prof_flags";
8228 /* GNU extensions. */
8229 case DW_AT_sf_names
:
8230 return "DW_AT_sf_names";
8231 case DW_AT_src_info
:
8232 return "DW_AT_src_info";
8233 case DW_AT_mac_info
:
8234 return "DW_AT_mac_info";
8235 case DW_AT_src_coords
:
8236 return "DW_AT_src_coords";
8237 case DW_AT_body_begin
:
8238 return "DW_AT_body_begin";
8239 case DW_AT_body_end
:
8240 return "DW_AT_body_end";
8241 case DW_AT_GNU_vector
:
8242 return "DW_AT_GNU_vector";
8243 /* VMS extensions. */
8244 case DW_AT_VMS_rtnbeg_pd_address
:
8245 return "DW_AT_VMS_rtnbeg_pd_address";
8246 /* UPC extension. */
8247 case DW_AT_upc_threads_scaled
:
8248 return "DW_AT_upc_threads_scaled";
8249 /* PGI (STMicroelectronics) extensions. */
8250 case DW_AT_PGI_lbase
:
8251 return "DW_AT_PGI_lbase";
8252 case DW_AT_PGI_soffset
:
8253 return "DW_AT_PGI_soffset";
8254 case DW_AT_PGI_lstride
:
8255 return "DW_AT_PGI_lstride";
8257 return "DW_AT_<unknown>";
8261 /* Convert a DWARF value form code into its string name. */
8264 dwarf_form_name (unsigned form
)
8269 return "DW_FORM_addr";
8270 case DW_FORM_block2
:
8271 return "DW_FORM_block2";
8272 case DW_FORM_block4
:
8273 return "DW_FORM_block4";
8275 return "DW_FORM_data2";
8277 return "DW_FORM_data4";
8279 return "DW_FORM_data8";
8280 case DW_FORM_string
:
8281 return "DW_FORM_string";
8283 return "DW_FORM_block";
8284 case DW_FORM_block1
:
8285 return "DW_FORM_block1";
8287 return "DW_FORM_data1";
8289 return "DW_FORM_flag";
8291 return "DW_FORM_sdata";
8293 return "DW_FORM_strp";
8295 return "DW_FORM_udata";
8296 case DW_FORM_ref_addr
:
8297 return "DW_FORM_ref_addr";
8299 return "DW_FORM_ref1";
8301 return "DW_FORM_ref2";
8303 return "DW_FORM_ref4";
8305 return "DW_FORM_ref8";
8306 case DW_FORM_ref_udata
:
8307 return "DW_FORM_ref_udata";
8308 case DW_FORM_indirect
:
8309 return "DW_FORM_indirect";
8311 return "DW_FORM_<unknown>";
8315 /* Convert a DWARF stack opcode into its string name. */
8318 dwarf_stack_op_name (unsigned op
)
8323 return "DW_OP_addr";
8325 return "DW_OP_deref";
8327 return "DW_OP_const1u";
8329 return "DW_OP_const1s";
8331 return "DW_OP_const2u";
8333 return "DW_OP_const2s";
8335 return "DW_OP_const4u";
8337 return "DW_OP_const4s";
8339 return "DW_OP_const8u";
8341 return "DW_OP_const8s";
8343 return "DW_OP_constu";
8345 return "DW_OP_consts";
8349 return "DW_OP_drop";
8351 return "DW_OP_over";
8353 return "DW_OP_pick";
8355 return "DW_OP_swap";
8359 return "DW_OP_xderef";
8367 return "DW_OP_minus";
8379 return "DW_OP_plus";
8380 case DW_OP_plus_uconst
:
8381 return "DW_OP_plus_uconst";
8387 return "DW_OP_shra";
8405 return "DW_OP_skip";
8407 return "DW_OP_lit0";
8409 return "DW_OP_lit1";
8411 return "DW_OP_lit2";
8413 return "DW_OP_lit3";
8415 return "DW_OP_lit4";
8417 return "DW_OP_lit5";
8419 return "DW_OP_lit6";
8421 return "DW_OP_lit7";
8423 return "DW_OP_lit8";
8425 return "DW_OP_lit9";
8427 return "DW_OP_lit10";
8429 return "DW_OP_lit11";
8431 return "DW_OP_lit12";
8433 return "DW_OP_lit13";
8435 return "DW_OP_lit14";
8437 return "DW_OP_lit15";
8439 return "DW_OP_lit16";
8441 return "DW_OP_lit17";
8443 return "DW_OP_lit18";
8445 return "DW_OP_lit19";
8447 return "DW_OP_lit20";
8449 return "DW_OP_lit21";
8451 return "DW_OP_lit22";
8453 return "DW_OP_lit23";
8455 return "DW_OP_lit24";
8457 return "DW_OP_lit25";
8459 return "DW_OP_lit26";
8461 return "DW_OP_lit27";
8463 return "DW_OP_lit28";
8465 return "DW_OP_lit29";
8467 return "DW_OP_lit30";
8469 return "DW_OP_lit31";
8471 return "DW_OP_reg0";
8473 return "DW_OP_reg1";
8475 return "DW_OP_reg2";
8477 return "DW_OP_reg3";
8479 return "DW_OP_reg4";
8481 return "DW_OP_reg5";
8483 return "DW_OP_reg6";
8485 return "DW_OP_reg7";
8487 return "DW_OP_reg8";
8489 return "DW_OP_reg9";
8491 return "DW_OP_reg10";
8493 return "DW_OP_reg11";
8495 return "DW_OP_reg12";
8497 return "DW_OP_reg13";
8499 return "DW_OP_reg14";
8501 return "DW_OP_reg15";
8503 return "DW_OP_reg16";
8505 return "DW_OP_reg17";
8507 return "DW_OP_reg18";
8509 return "DW_OP_reg19";
8511 return "DW_OP_reg20";
8513 return "DW_OP_reg21";
8515 return "DW_OP_reg22";
8517 return "DW_OP_reg23";
8519 return "DW_OP_reg24";
8521 return "DW_OP_reg25";
8523 return "DW_OP_reg26";
8525 return "DW_OP_reg27";
8527 return "DW_OP_reg28";
8529 return "DW_OP_reg29";
8531 return "DW_OP_reg30";
8533 return "DW_OP_reg31";
8535 return "DW_OP_breg0";
8537 return "DW_OP_breg1";
8539 return "DW_OP_breg2";
8541 return "DW_OP_breg3";
8543 return "DW_OP_breg4";
8545 return "DW_OP_breg5";
8547 return "DW_OP_breg6";
8549 return "DW_OP_breg7";
8551 return "DW_OP_breg8";
8553 return "DW_OP_breg9";
8555 return "DW_OP_breg10";
8557 return "DW_OP_breg11";
8559 return "DW_OP_breg12";
8561 return "DW_OP_breg13";
8563 return "DW_OP_breg14";
8565 return "DW_OP_breg15";
8567 return "DW_OP_breg16";
8569 return "DW_OP_breg17";
8571 return "DW_OP_breg18";
8573 return "DW_OP_breg19";
8575 return "DW_OP_breg20";
8577 return "DW_OP_breg21";
8579 return "DW_OP_breg22";
8581 return "DW_OP_breg23";
8583 return "DW_OP_breg24";
8585 return "DW_OP_breg25";
8587 return "DW_OP_breg26";
8589 return "DW_OP_breg27";
8591 return "DW_OP_breg28";
8593 return "DW_OP_breg29";
8595 return "DW_OP_breg30";
8597 return "DW_OP_breg31";
8599 return "DW_OP_regx";
8601 return "DW_OP_fbreg";
8603 return "DW_OP_bregx";
8605 return "DW_OP_piece";
8606 case DW_OP_deref_size
:
8607 return "DW_OP_deref_size";
8608 case DW_OP_xderef_size
:
8609 return "DW_OP_xderef_size";
8612 /* DWARF 3 extensions. */
8613 case DW_OP_push_object_address
:
8614 return "DW_OP_push_object_address";
8616 return "DW_OP_call2";
8618 return "DW_OP_call4";
8619 case DW_OP_call_ref
:
8620 return "DW_OP_call_ref";
8621 /* GNU extensions. */
8622 case DW_OP_form_tls_address
:
8623 return "DW_OP_form_tls_address";
8624 case DW_OP_call_frame_cfa
:
8625 return "DW_OP_call_frame_cfa";
8626 case DW_OP_bit_piece
:
8627 return "DW_OP_bit_piece";
8628 case DW_OP_GNU_push_tls_address
:
8629 return "DW_OP_GNU_push_tls_address";
8630 /* HP extensions. */
8631 case DW_OP_HP_is_value
:
8632 return "DW_OP_HP_is_value";
8633 case DW_OP_HP_fltconst4
:
8634 return "DW_OP_HP_fltconst4";
8635 case DW_OP_HP_fltconst8
:
8636 return "DW_OP_HP_fltconst8";
8637 case DW_OP_HP_mod_range
:
8638 return "DW_OP_HP_mod_range";
8639 case DW_OP_HP_unmod_range
:
8640 return "DW_OP_HP_unmod_range";
8642 return "DW_OP_HP_tls";
8644 return "OP_<unknown>";
8649 dwarf_bool_name (unsigned mybool
)
8657 /* Convert a DWARF type code into its string name. */
8660 dwarf_type_encoding_name (unsigned enc
)
8665 return "DW_ATE_void";
8666 case DW_ATE_address
:
8667 return "DW_ATE_address";
8668 case DW_ATE_boolean
:
8669 return "DW_ATE_boolean";
8670 case DW_ATE_complex_float
:
8671 return "DW_ATE_complex_float";
8673 return "DW_ATE_float";
8675 return "DW_ATE_signed";
8676 case DW_ATE_signed_char
:
8677 return "DW_ATE_signed_char";
8678 case DW_ATE_unsigned
:
8679 return "DW_ATE_unsigned";
8680 case DW_ATE_unsigned_char
:
8681 return "DW_ATE_unsigned_char";
8683 case DW_ATE_imaginary_float
:
8684 return "DW_ATE_imaginary_float";
8685 case DW_ATE_packed_decimal
:
8686 return "DW_ATE_packed_decimal";
8687 case DW_ATE_numeric_string
:
8688 return "DW_ATE_numeric_string";
8690 return "DW_ATE_edited";
8691 case DW_ATE_signed_fixed
:
8692 return "DW_ATE_signed_fixed";
8693 case DW_ATE_unsigned_fixed
:
8694 return "DW_ATE_unsigned_fixed";
8695 case DW_ATE_decimal_float
:
8696 return "DW_ATE_decimal_float";
8697 /* HP extensions. */
8698 case DW_ATE_HP_float80
:
8699 return "DW_ATE_HP_float80";
8700 case DW_ATE_HP_complex_float80
:
8701 return "DW_ATE_HP_complex_float80";
8702 case DW_ATE_HP_float128
:
8703 return "DW_ATE_HP_float128";
8704 case DW_ATE_HP_complex_float128
:
8705 return "DW_ATE_HP_complex_float128";
8706 case DW_ATE_HP_floathpintel
:
8707 return "DW_ATE_HP_floathpintel";
8708 case DW_ATE_HP_imaginary_float80
:
8709 return "DW_ATE_HP_imaginary_float80";
8710 case DW_ATE_HP_imaginary_float128
:
8711 return "DW_ATE_HP_imaginary_float128";
8713 return "DW_ATE_<unknown>";
8717 /* Convert a DWARF call frame info operation to its string name. */
8721 dwarf_cfi_name (unsigned cfi_opc
)
8725 case DW_CFA_advance_loc
:
8726 return "DW_CFA_advance_loc";
8728 return "DW_CFA_offset";
8729 case DW_CFA_restore
:
8730 return "DW_CFA_restore";
8732 return "DW_CFA_nop";
8733 case DW_CFA_set_loc
:
8734 return "DW_CFA_set_loc";
8735 case DW_CFA_advance_loc1
:
8736 return "DW_CFA_advance_loc1";
8737 case DW_CFA_advance_loc2
:
8738 return "DW_CFA_advance_loc2";
8739 case DW_CFA_advance_loc4
:
8740 return "DW_CFA_advance_loc4";
8741 case DW_CFA_offset_extended
:
8742 return "DW_CFA_offset_extended";
8743 case DW_CFA_restore_extended
:
8744 return "DW_CFA_restore_extended";
8745 case DW_CFA_undefined
:
8746 return "DW_CFA_undefined";
8747 case DW_CFA_same_value
:
8748 return "DW_CFA_same_value";
8749 case DW_CFA_register
:
8750 return "DW_CFA_register";
8751 case DW_CFA_remember_state
:
8752 return "DW_CFA_remember_state";
8753 case DW_CFA_restore_state
:
8754 return "DW_CFA_restore_state";
8755 case DW_CFA_def_cfa
:
8756 return "DW_CFA_def_cfa";
8757 case DW_CFA_def_cfa_register
:
8758 return "DW_CFA_def_cfa_register";
8759 case DW_CFA_def_cfa_offset
:
8760 return "DW_CFA_def_cfa_offset";
8762 case DW_CFA_def_cfa_expression
:
8763 return "DW_CFA_def_cfa_expression";
8764 case DW_CFA_expression
:
8765 return "DW_CFA_expression";
8766 case DW_CFA_offset_extended_sf
:
8767 return "DW_CFA_offset_extended_sf";
8768 case DW_CFA_def_cfa_sf
:
8769 return "DW_CFA_def_cfa_sf";
8770 case DW_CFA_def_cfa_offset_sf
:
8771 return "DW_CFA_def_cfa_offset_sf";
8772 case DW_CFA_val_offset
:
8773 return "DW_CFA_val_offset";
8774 case DW_CFA_val_offset_sf
:
8775 return "DW_CFA_val_offset_sf";
8776 case DW_CFA_val_expression
:
8777 return "DW_CFA_val_expression";
8778 /* SGI/MIPS specific. */
8779 case DW_CFA_MIPS_advance_loc8
:
8780 return "DW_CFA_MIPS_advance_loc8";
8781 /* GNU extensions. */
8782 case DW_CFA_GNU_window_save
:
8783 return "DW_CFA_GNU_window_save";
8784 case DW_CFA_GNU_args_size
:
8785 return "DW_CFA_GNU_args_size";
8786 case DW_CFA_GNU_negative_offset_extended
:
8787 return "DW_CFA_GNU_negative_offset_extended";
8789 return "DW_CFA_<unknown>";
8795 dump_die (struct die_info
*die
)
8799 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8800 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8801 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8802 dwarf_bool_name (die
->child
!= NULL
));
8804 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8805 for (i
= 0; i
< die
->num_attrs
; ++i
)
8807 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8808 dwarf_attr_name (die
->attrs
[i
].name
),
8809 dwarf_form_name (die
->attrs
[i
].form
));
8810 switch (die
->attrs
[i
].form
)
8812 case DW_FORM_ref_addr
:
8814 fprintf_unfiltered (gdb_stderr
, "address: ");
8815 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8817 case DW_FORM_block2
:
8818 case DW_FORM_block4
:
8820 case DW_FORM_block1
:
8821 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8826 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8827 (long) (DW_ADDR (&die
->attrs
[i
])));
8835 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8837 case DW_FORM_string
:
8839 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8840 DW_STRING (&die
->attrs
[i
])
8841 ? DW_STRING (&die
->attrs
[i
]) : "");
8844 if (DW_UNSND (&die
->attrs
[i
]))
8845 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8847 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8849 case DW_FORM_indirect
:
8850 /* the reader will have reduced the indirect form to
8851 the "base form" so this form should not occur */
8852 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8855 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8856 die
->attrs
[i
].form
);
8858 fprintf_unfiltered (gdb_stderr
, "\n");
8863 dump_die_list (struct die_info
*die
)
8868 if (die
->child
!= NULL
)
8869 dump_die_list (die
->child
);
8870 if (die
->sibling
!= NULL
)
8871 dump_die_list (die
->sibling
);
8876 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8877 struct dwarf2_cu
*cu
)
8880 struct die_info
*old
;
8882 h
= (offset
% REF_HASH_SIZE
);
8883 old
= cu
->die_ref_table
[h
];
8884 die
->next_ref
= old
;
8885 cu
->die_ref_table
[h
] = die
;
8889 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8891 unsigned int result
= 0;
8895 case DW_FORM_ref_addr
:
8900 case DW_FORM_ref_udata
:
8901 result
= DW_ADDR (attr
);
8904 complaint (&symfile_complaints
,
8905 _("unsupported die ref attribute form: '%s'"),
8906 dwarf_form_name (attr
->form
));
8911 /* Return the constant value held by the given attribute. Return -1
8912 if the value held by the attribute is not constant. */
8915 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8917 if (attr
->form
== DW_FORM_sdata
)
8918 return DW_SND (attr
);
8919 else if (attr
->form
== DW_FORM_udata
8920 || attr
->form
== DW_FORM_data1
8921 || attr
->form
== DW_FORM_data2
8922 || attr
->form
== DW_FORM_data4
8923 || attr
->form
== DW_FORM_data8
)
8924 return DW_UNSND (attr
);
8927 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8928 dwarf_form_name (attr
->form
));
8929 return default_value
;
8933 static struct die_info
*
8934 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8935 struct dwarf2_cu
*cu
)
8937 struct die_info
*die
;
8938 unsigned int offset
;
8940 struct die_info temp_die
;
8941 struct dwarf2_cu
*target_cu
;
8943 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8945 if (DW_ADDR (attr
) < cu
->header
.offset
8946 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8948 struct dwarf2_per_cu_data
*per_cu
;
8949 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8951 target_cu
= per_cu
->cu
;
8956 h
= (offset
% REF_HASH_SIZE
);
8957 die
= target_cu
->die_ref_table
[h
];
8960 if (die
->offset
== offset
)
8962 die
= die
->next_ref
;
8965 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8966 "at 0x%lx [in module %s]"),
8967 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8972 static struct type
*
8973 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8974 struct dwarf2_cu
*cu
)
8976 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8978 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8979 typeid, objfile
->name
);
8982 /* Look for this particular type in the fundamental type vector. If
8983 one is not found, create and install one appropriate for the
8984 current language and the current target machine. */
8986 if (cu
->ftypes
[typeid] == NULL
)
8988 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8991 return (cu
->ftypes
[typeid]);
8994 /* Decode simple location descriptions.
8995 Given a pointer to a dwarf block that defines a location, compute
8996 the location and return the value.
8998 NOTE drow/2003-11-18: This function is called in two situations
8999 now: for the address of static or global variables (partial symbols
9000 only) and for offsets into structures which are expected to be
9001 (more or less) constant. The partial symbol case should go away,
9002 and only the constant case should remain. That will let this
9003 function complain more accurately. A few special modes are allowed
9004 without complaint for global variables (for instance, global
9005 register values and thread-local values).
9007 A location description containing no operations indicates that the
9008 object is optimized out. The return value is 0 for that case.
9009 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9010 callers will only want a very basic result and this can become a
9013 Note that stack[0] is unused except as a default error return.
9014 Note that stack overflow is not yet handled. */
9017 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9019 struct objfile
*objfile
= cu
->objfile
;
9020 struct comp_unit_head
*cu_header
= &cu
->header
;
9022 int size
= blk
->size
;
9023 gdb_byte
*data
= blk
->data
;
9024 CORE_ADDR stack
[64];
9026 unsigned int bytes_read
, unsnd
;
9070 stack
[++stacki
] = op
- DW_OP_lit0
;
9105 stack
[++stacki
] = op
- DW_OP_reg0
;
9107 dwarf2_complex_location_expr_complaint ();
9111 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9113 stack
[++stacki
] = unsnd
;
9115 dwarf2_complex_location_expr_complaint ();
9119 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9125 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9130 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9135 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9140 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9145 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9150 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9155 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9161 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9166 stack
[stacki
+ 1] = stack
[stacki
];
9171 stack
[stacki
- 1] += stack
[stacki
];
9175 case DW_OP_plus_uconst
:
9176 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9181 stack
[stacki
- 1] -= stack
[stacki
];
9186 /* If we're not the last op, then we definitely can't encode
9187 this using GDB's address_class enum. This is valid for partial
9188 global symbols, although the variable's address will be bogus
9191 dwarf2_complex_location_expr_complaint ();
9194 case DW_OP_GNU_push_tls_address
:
9195 /* The top of the stack has the offset from the beginning
9196 of the thread control block at which the variable is located. */
9197 /* Nothing should follow this operator, so the top of stack would
9199 /* This is valid for partial global symbols, but the variable's
9200 address will be bogus in the psymtab. */
9202 dwarf2_complex_location_expr_complaint ();
9206 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9207 dwarf_stack_op_name (op
));
9208 return (stack
[stacki
]);
9211 return (stack
[stacki
]);
9214 /* memory allocation interface */
9216 static struct dwarf_block
*
9217 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9219 struct dwarf_block
*blk
;
9221 blk
= (struct dwarf_block
*)
9222 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9226 static struct abbrev_info
*
9227 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9229 struct abbrev_info
*abbrev
;
9231 abbrev
= (struct abbrev_info
*)
9232 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9233 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9237 static struct die_info
*
9238 dwarf_alloc_die (void)
9240 struct die_info
*die
;
9242 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9243 memset (die
, 0, sizeof (struct die_info
));
9248 /* Macro support. */
9251 /* Return the full name of file number I in *LH's file name table.
9252 Use COMP_DIR as the name of the current directory of the
9253 compilation. The result is allocated using xmalloc; the caller is
9254 responsible for freeing it. */
9256 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9258 /* Is the file number a valid index into the line header's file name
9259 table? Remember that file numbers start with one, not zero. */
9260 if (1 <= file
&& file
<= lh
->num_file_names
)
9262 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9264 if (IS_ABSOLUTE_PATH (fe
->name
))
9265 return xstrdup (fe
->name
);
9273 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9279 dir_len
= strlen (dir
);
9280 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9281 strcpy (full_name
, dir
);
9282 full_name
[dir_len
] = '/';
9283 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9287 return xstrdup (fe
->name
);
9292 /* The compiler produced a bogus file number. We can at least
9293 record the macro definitions made in the file, even if we
9294 won't be able to find the file by name. */
9296 sprintf (fake_name
, "<bad macro file number %d>", file
);
9298 complaint (&symfile_complaints
,
9299 _("bad file number in macro information (%d)"),
9302 return xstrdup (fake_name
);
9307 static struct macro_source_file
*
9308 macro_start_file (int file
, int line
,
9309 struct macro_source_file
*current_file
,
9310 const char *comp_dir
,
9311 struct line_header
*lh
, struct objfile
*objfile
)
9313 /* The full name of this source file. */
9314 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9316 /* We don't create a macro table for this compilation unit
9317 at all until we actually get a filename. */
9318 if (! pending_macros
)
9319 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9320 objfile
->macro_cache
);
9323 /* If we have no current file, then this must be the start_file
9324 directive for the compilation unit's main source file. */
9325 current_file
= macro_set_main (pending_macros
, full_name
);
9327 current_file
= macro_include (current_file
, line
, full_name
);
9331 return current_file
;
9335 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9336 followed by a null byte. */
9338 copy_string (const char *buf
, int len
)
9340 char *s
= xmalloc (len
+ 1);
9341 memcpy (s
, buf
, len
);
9349 consume_improper_spaces (const char *p
, const char *body
)
9353 complaint (&symfile_complaints
,
9354 _("macro definition contains spaces in formal argument list:\n`%s'"),
9366 parse_macro_definition (struct macro_source_file
*file
, int line
,
9371 /* The body string takes one of two forms. For object-like macro
9372 definitions, it should be:
9374 <macro name> " " <definition>
9376 For function-like macro definitions, it should be:
9378 <macro name> "() " <definition>
9380 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9382 Spaces may appear only where explicitly indicated, and in the
9385 The Dwarf 2 spec says that an object-like macro's name is always
9386 followed by a space, but versions of GCC around March 2002 omit
9387 the space when the macro's definition is the empty string.
9389 The Dwarf 2 spec says that there should be no spaces between the
9390 formal arguments in a function-like macro's formal argument list,
9391 but versions of GCC around March 2002 include spaces after the
9395 /* Find the extent of the macro name. The macro name is terminated
9396 by either a space or null character (for an object-like macro) or
9397 an opening paren (for a function-like macro). */
9398 for (p
= body
; *p
; p
++)
9399 if (*p
== ' ' || *p
== '(')
9402 if (*p
== ' ' || *p
== '\0')
9404 /* It's an object-like macro. */
9405 int name_len
= p
- body
;
9406 char *name
= copy_string (body
, name_len
);
9407 const char *replacement
;
9410 replacement
= body
+ name_len
+ 1;
9413 dwarf2_macro_malformed_definition_complaint (body
);
9414 replacement
= body
+ name_len
;
9417 macro_define_object (file
, line
, name
, replacement
);
9423 /* It's a function-like macro. */
9424 char *name
= copy_string (body
, p
- body
);
9427 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9431 p
= consume_improper_spaces (p
, body
);
9433 /* Parse the formal argument list. */
9434 while (*p
&& *p
!= ')')
9436 /* Find the extent of the current argument name. */
9437 const char *arg_start
= p
;
9439 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9442 if (! *p
|| p
== arg_start
)
9443 dwarf2_macro_malformed_definition_complaint (body
);
9446 /* Make sure argv has room for the new argument. */
9447 if (argc
>= argv_size
)
9450 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9453 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9456 p
= consume_improper_spaces (p
, body
);
9458 /* Consume the comma, if present. */
9463 p
= consume_improper_spaces (p
, body
);
9472 /* Perfectly formed definition, no complaints. */
9473 macro_define_function (file
, line
, name
,
9474 argc
, (const char **) argv
,
9476 else if (*p
== '\0')
9478 /* Complain, but do define it. */
9479 dwarf2_macro_malformed_definition_complaint (body
);
9480 macro_define_function (file
, line
, name
,
9481 argc
, (const char **) argv
,
9485 /* Just complain. */
9486 dwarf2_macro_malformed_definition_complaint (body
);
9489 /* Just complain. */
9490 dwarf2_macro_malformed_definition_complaint (body
);
9496 for (i
= 0; i
< argc
; i
++)
9502 dwarf2_macro_malformed_definition_complaint (body
);
9507 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9508 char *comp_dir
, bfd
*abfd
,
9509 struct dwarf2_cu
*cu
)
9511 gdb_byte
*mac_ptr
, *mac_end
;
9512 struct macro_source_file
*current_file
= 0;
9514 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9516 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9520 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9521 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9522 + dwarf2_per_objfile
->macinfo_size
;
9526 enum dwarf_macinfo_record_type macinfo_type
;
9528 /* Do we at least have room for a macinfo type byte? */
9529 if (mac_ptr
>= mac_end
)
9531 dwarf2_macros_too_long_complaint ();
9535 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9538 switch (macinfo_type
)
9540 /* A zero macinfo type indicates the end of the macro
9545 case DW_MACINFO_define
:
9546 case DW_MACINFO_undef
:
9548 unsigned int bytes_read
;
9552 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9553 mac_ptr
+= bytes_read
;
9554 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9555 mac_ptr
+= bytes_read
;
9558 complaint (&symfile_complaints
,
9559 _("debug info gives macro %s outside of any file: %s"),
9561 DW_MACINFO_define
? "definition" : macinfo_type
==
9562 DW_MACINFO_undef
? "undefinition" :
9563 "something-or-other", body
);
9566 if (macinfo_type
== DW_MACINFO_define
)
9567 parse_macro_definition (current_file
, line
, body
);
9568 else if (macinfo_type
== DW_MACINFO_undef
)
9569 macro_undef (current_file
, line
, body
);
9574 case DW_MACINFO_start_file
:
9576 unsigned int bytes_read
;
9579 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9580 mac_ptr
+= bytes_read
;
9581 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9582 mac_ptr
+= bytes_read
;
9584 current_file
= macro_start_file (file
, line
,
9585 current_file
, comp_dir
,
9590 case DW_MACINFO_end_file
:
9592 complaint (&symfile_complaints
,
9593 _("macro debug info has an unmatched `close_file' directive"));
9596 current_file
= current_file
->included_by
;
9599 enum dwarf_macinfo_record_type next_type
;
9601 /* GCC circa March 2002 doesn't produce the zero
9602 type byte marking the end of the compilation
9603 unit. Complain if it's not there, but exit no
9606 /* Do we at least have room for a macinfo type byte? */
9607 if (mac_ptr
>= mac_end
)
9609 dwarf2_macros_too_long_complaint ();
9613 /* We don't increment mac_ptr here, so this is just
9615 next_type
= read_1_byte (abfd
, mac_ptr
);
9617 complaint (&symfile_complaints
,
9618 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9625 case DW_MACINFO_vendor_ext
:
9627 unsigned int bytes_read
;
9631 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9632 mac_ptr
+= bytes_read
;
9633 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9634 mac_ptr
+= bytes_read
;
9636 /* We don't recognize any vendor extensions. */
9643 /* Check if the attribute's form is a DW_FORM_block*
9644 if so return true else false. */
9646 attr_form_is_block (struct attribute
*attr
)
9648 return (attr
== NULL
? 0 :
9649 attr
->form
== DW_FORM_block1
9650 || attr
->form
== DW_FORM_block2
9651 || attr
->form
== DW_FORM_block4
9652 || attr
->form
== DW_FORM_block
);
9656 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9657 struct dwarf2_cu
*cu
)
9659 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9660 /* ".debug_loc" may not exist at all, or the offset may be outside
9661 the section. If so, fall through to the complaint in the
9663 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9665 struct dwarf2_loclist_baton
*baton
;
9667 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9668 sizeof (struct dwarf2_loclist_baton
));
9669 baton
->objfile
= cu
->objfile
;
9671 /* We don't know how long the location list is, but make sure we
9672 don't run off the edge of the section. */
9673 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9674 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9675 baton
->base_address
= cu
->header
.base_address
;
9676 if (cu
->header
.base_known
== 0)
9677 complaint (&symfile_complaints
,
9678 _("Location list used without specifying the CU base address."));
9680 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9681 SYMBOL_LOCATION_BATON (sym
) = baton
;
9685 struct dwarf2_locexpr_baton
*baton
;
9687 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9688 sizeof (struct dwarf2_locexpr_baton
));
9689 baton
->objfile
= cu
->objfile
;
9691 if (attr_form_is_block (attr
))
9693 /* Note that we're just copying the block's data pointer
9694 here, not the actual data. We're still pointing into the
9695 info_buffer for SYM's objfile; right now we never release
9696 that buffer, but when we do clean up properly this may
9698 baton
->size
= DW_BLOCK (attr
)->size
;
9699 baton
->data
= DW_BLOCK (attr
)->data
;
9703 dwarf2_invalid_attrib_class_complaint ("location description",
9704 SYMBOL_NATURAL_NAME (sym
));
9709 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9710 SYMBOL_LOCATION_BATON (sym
) = baton
;
9714 /* Locate the compilation unit from CU's objfile which contains the
9715 DIE at OFFSET. Raises an error on failure. */
9717 static struct dwarf2_per_cu_data
*
9718 dwarf2_find_containing_comp_unit (unsigned long offset
,
9719 struct objfile
*objfile
)
9721 struct dwarf2_per_cu_data
*this_cu
;
9725 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9728 int mid
= low
+ (high
- low
) / 2;
9729 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9734 gdb_assert (low
== high
);
9735 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9738 error (_("Dwarf Error: could not find partial DIE containing "
9739 "offset 0x%lx [in module %s]"),
9740 (long) offset
, bfd_get_filename (objfile
->obfd
));
9742 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9743 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9747 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9748 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9749 && offset
>= this_cu
->offset
+ this_cu
->length
)
9750 error (_("invalid dwarf2 offset %ld"), offset
);
9751 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9756 /* Locate the compilation unit from OBJFILE which is located at exactly
9757 OFFSET. Raises an error on failure. */
9759 static struct dwarf2_per_cu_data
*
9760 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9762 struct dwarf2_per_cu_data
*this_cu
;
9763 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9764 if (this_cu
->offset
!= offset
)
9765 error (_("no compilation unit with offset %ld."), offset
);
9769 /* Release one cached compilation unit, CU. We unlink it from the tree
9770 of compilation units, but we don't remove it from the read_in_chain;
9771 the caller is responsible for that. */
9774 free_one_comp_unit (void *data
)
9776 struct dwarf2_cu
*cu
= data
;
9778 if (cu
->per_cu
!= NULL
)
9779 cu
->per_cu
->cu
= NULL
;
9782 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9784 free_die_list (cu
->dies
);
9789 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9790 when we're finished with it. We can't free the pointer itself, but be
9791 sure to unlink it from the cache. Also release any associated storage
9792 and perform cache maintenance.
9794 Only used during partial symbol parsing. */
9797 free_stack_comp_unit (void *data
)
9799 struct dwarf2_cu
*cu
= data
;
9801 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9802 cu
->partial_dies
= NULL
;
9804 if (cu
->per_cu
!= NULL
)
9806 /* This compilation unit is on the stack in our caller, so we
9807 should not xfree it. Just unlink it. */
9808 cu
->per_cu
->cu
= NULL
;
9811 /* If we had a per-cu pointer, then we may have other compilation
9812 units loaded, so age them now. */
9813 age_cached_comp_units ();
9817 /* Free all cached compilation units. */
9820 free_cached_comp_units (void *data
)
9822 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9824 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9825 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9826 while (per_cu
!= NULL
)
9828 struct dwarf2_per_cu_data
*next_cu
;
9830 next_cu
= per_cu
->cu
->read_in_chain
;
9832 free_one_comp_unit (per_cu
->cu
);
9833 *last_chain
= next_cu
;
9839 /* Increase the age counter on each cached compilation unit, and free
9840 any that are too old. */
9843 age_cached_comp_units (void)
9845 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9847 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9848 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9849 while (per_cu
!= NULL
)
9851 per_cu
->cu
->last_used
++;
9852 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9853 dwarf2_mark (per_cu
->cu
);
9854 per_cu
= per_cu
->cu
->read_in_chain
;
9857 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9858 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9859 while (per_cu
!= NULL
)
9861 struct dwarf2_per_cu_data
*next_cu
;
9863 next_cu
= per_cu
->cu
->read_in_chain
;
9865 if (!per_cu
->cu
->mark
)
9867 free_one_comp_unit (per_cu
->cu
);
9868 *last_chain
= next_cu
;
9871 last_chain
= &per_cu
->cu
->read_in_chain
;
9877 /* Remove a single compilation unit from the cache. */
9880 free_one_cached_comp_unit (void *target_cu
)
9882 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9884 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9885 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9886 while (per_cu
!= NULL
)
9888 struct dwarf2_per_cu_data
*next_cu
;
9890 next_cu
= per_cu
->cu
->read_in_chain
;
9892 if (per_cu
->cu
== target_cu
)
9894 free_one_comp_unit (per_cu
->cu
);
9895 *last_chain
= next_cu
;
9899 last_chain
= &per_cu
->cu
->read_in_chain
;
9905 /* A pair of DIE offset and GDB type pointer. We store these
9906 in a hash table separate from the DIEs, and preserve them
9907 when the DIEs are flushed out of cache. */
9909 struct dwarf2_offset_and_type
9911 unsigned int offset
;
9915 /* Hash function for a dwarf2_offset_and_type. */
9918 offset_and_type_hash (const void *item
)
9920 const struct dwarf2_offset_and_type
*ofs
= item
;
9924 /* Equality function for a dwarf2_offset_and_type. */
9927 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9929 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9930 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9931 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9934 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9935 table if necessary. */
9938 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9940 struct dwarf2_offset_and_type
**slot
, ofs
;
9944 if (cu
->per_cu
== NULL
)
9947 if (cu
->per_cu
->type_hash
== NULL
)
9948 cu
->per_cu
->type_hash
9949 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9950 offset_and_type_hash
,
9953 &cu
->objfile
->objfile_obstack
,
9954 hashtab_obstack_allocate
,
9955 dummy_obstack_deallocate
);
9957 ofs
.offset
= die
->offset
;
9959 slot
= (struct dwarf2_offset_and_type
**)
9960 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9961 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9965 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9966 have a saved type. */
9968 static struct type
*
9969 get_die_type (struct die_info
*die
, htab_t type_hash
)
9971 struct dwarf2_offset_and_type
*slot
, ofs
;
9973 ofs
.offset
= die
->offset
;
9974 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9981 /* Restore the types of the DIE tree starting at START_DIE from the hash
9982 table saved in CU. */
9985 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9987 struct die_info
*die
;
9989 if (cu
->per_cu
->type_hash
== NULL
)
9992 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9994 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9995 if (die
->child
!= NULL
)
9996 reset_die_and_siblings_types (die
->child
, cu
);
10000 /* Set the mark field in CU and in every other compilation unit in the
10001 cache that we must keep because we are keeping CU. */
10003 /* Add a dependence relationship from CU to REF_PER_CU. */
10006 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10007 struct dwarf2_per_cu_data
*ref_per_cu
)
10011 if (cu
->dependencies
== NULL
)
10013 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10014 NULL
, &cu
->comp_unit_obstack
,
10015 hashtab_obstack_allocate
,
10016 dummy_obstack_deallocate
);
10018 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10020 *slot
= ref_per_cu
;
10023 /* Set the mark field in CU and in every other compilation unit in the
10024 cache that we must keep because we are keeping CU. */
10027 dwarf2_mark_helper (void **slot
, void *data
)
10029 struct dwarf2_per_cu_data
*per_cu
;
10031 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10032 if (per_cu
->cu
->mark
)
10034 per_cu
->cu
->mark
= 1;
10036 if (per_cu
->cu
->dependencies
!= NULL
)
10037 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10043 dwarf2_mark (struct dwarf2_cu
*cu
)
10048 if (cu
->dependencies
!= NULL
)
10049 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10053 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10057 per_cu
->cu
->mark
= 0;
10058 per_cu
= per_cu
->cu
->read_in_chain
;
10062 /* Trivial hash function for partial_die_info: the hash value of a DIE
10063 is its offset in .debug_info for this objfile. */
10066 partial_die_hash (const void *item
)
10068 const struct partial_die_info
*part_die
= item
;
10069 return part_die
->offset
;
10072 /* Trivial comparison function for partial_die_info structures: two DIEs
10073 are equal if they have the same offset. */
10076 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10078 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10079 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10080 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10083 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10084 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10087 set_dwarf2_cmd (char *args
, int from_tty
)
10089 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10093 show_dwarf2_cmd (char *args
, int from_tty
)
10095 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10098 void _initialize_dwarf2_read (void);
10101 _initialize_dwarf2_read (void)
10103 dwarf2_objfile_data_key
= register_objfile_data ();
10105 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10106 Set DWARF 2 specific variables.\n\
10107 Configure DWARF 2 variables such as the cache size"),
10108 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10109 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10111 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10112 Show DWARF 2 specific variables\n\
10113 Show DWARF 2 variables such as the cache size"),
10114 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10115 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10117 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10118 &dwarf2_max_cache_age
, _("\
10119 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10120 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10121 A higher limit means that cached compilation units will be stored\n\
10122 in memory longer, and more total memory will be used. Zero disables\n\
10123 caching, which can slow down startup."),
10125 show_dwarf2_max_cache_age
,
10126 &set_dwarf2_cmdlist
,
10127 &show_dwarf2_cmdlist
);