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, 2008, 2009, 2010
5
Free Software Foundation, Inc.
7
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8
Inc. with support from Florida State University (under contract
9
with the Ada Joint Program Office), and Silicon Graphics, Inc.
10
Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11
based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14
This file is part of GDB.
16
This program is free software; you can redistribute it and/or modify
17
it under the terms of the GNU General Public License as published by
18
the Free Software Foundation; either version 3 of the License, or
19
(at your option) any later version.
21
This program is distributed in the hope that it will be useful,
22
but WITHOUT ANY WARRANTY; without even the implied warranty of
23
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24
GNU General Public License for more details.
26
You should have received a copy of the GNU General Public License
27
along with this program. If not, see <http://www.gnu.org/licenses/>. */
37
#include "expression.h"
38
#include "filenames.h" /* for DOSish file names */
41
#include "complaints.h"
43
#include "dwarf2expr.h"
44
#include "dwarf2loc.h"
45
#include "cp-support.h"
53
#include "gdb_string.h"
54
#include "gdb_assert.h"
55
#include <sys/types.h>
62
#define MAP_FAILED ((void *) -1)
67
/* .debug_info header for a compilation unit
68
Because of alignment constraints, this structure has padding and cannot
69
be mapped directly onto the beginning of the .debug_info section. */
70
typedef struct comp_unit_header
72
unsigned int length; /* length of the .debug_info
74
unsigned short version; /* version number -- 2 for DWARF
76
unsigned int abbrev_offset; /* offset into .debug_abbrev section */
77
unsigned char addr_size; /* byte size of an address -- 4 */
80
#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
83
/* .debug_pubnames header
84
Because of alignment constraints, this structure has padding and cannot
85
be mapped directly onto the beginning of the .debug_info section. */
86
typedef struct pubnames_header
88
unsigned int length; /* length of the .debug_pubnames
90
unsigned char version; /* version number -- 2 for DWARF
92
unsigned int info_offset; /* offset into .debug_info section */
93
unsigned int info_size; /* byte size of .debug_info section
97
#define _ACTUAL_PUBNAMES_HEADER_SIZE 13
99
/* .debug_pubnames header
100
Because of alignment constraints, this structure has padding and cannot
101
be mapped directly onto the beginning of the .debug_info section. */
102
typedef struct aranges_header
104
unsigned int length; /* byte len of the .debug_aranges
106
unsigned short version; /* version number -- 2 for DWARF
108
unsigned int info_offset; /* offset into .debug_info section */
109
unsigned char addr_size; /* byte size of an address */
110
unsigned char seg_size; /* byte size of segment descriptor */
113
#define _ACTUAL_ARANGES_HEADER_SIZE 12
115
/* .debug_line statement program prologue
116
Because of alignment constraints, this structure has padding and cannot
117
be mapped directly onto the beginning of the .debug_info section. */
118
typedef struct statement_prologue
120
unsigned int total_length; /* byte length of the statement
122
unsigned short version; /* version number -- 2 for DWARF
124
unsigned int prologue_length; /* # bytes between prologue &
126
unsigned char minimum_instruction_length; /* byte size of
128
unsigned char default_is_stmt; /* initial value of is_stmt
131
unsigned char line_range;
132
unsigned char opcode_base; /* number assigned to first special
134
unsigned char *standard_opcode_lengths;
138
/* When non-zero, dump DIEs after they are read in. */
139
static int dwarf2_die_debug = 0;
143
/* When set, the file that we're processing is known to have debugging
144
info for C++ namespaces. GCC 3.3.x did not produce this information,
145
but later versions do. */
147
static int processing_has_namespace_info;
149
static const struct objfile_data *dwarf2_objfile_data_key;
151
struct dwarf2_section_info
159
struct dwarf2_per_objfile
161
struct dwarf2_section_info info;
162
struct dwarf2_section_info abbrev;
163
struct dwarf2_section_info line;
164
struct dwarf2_section_info pubnames;
165
struct dwarf2_section_info aranges;
166
struct dwarf2_section_info loc;
167
struct dwarf2_section_info macinfo;
168
struct dwarf2_section_info str;
169
struct dwarf2_section_info ranges;
170
struct dwarf2_section_info types;
171
struct dwarf2_section_info frame;
172
struct dwarf2_section_info eh_frame;
174
/* A list of all the compilation units. This is used to locate
175
the target compilation unit of a particular reference. */
176
struct dwarf2_per_cu_data **all_comp_units;
178
/* The number of compilation units in ALL_COMP_UNITS. */
181
/* A chain of compilation units that are currently read in, so that
182
they can be freed later. */
183
struct dwarf2_per_cu_data *read_in_chain;
185
/* A table mapping .debug_types signatures to its signatured_type entry.
186
This is NULL if the .debug_types section hasn't been read in yet. */
187
htab_t signatured_types;
189
/* A flag indicating wether this objfile has a section loaded at a
191
int has_section_at_zero;
194
static struct dwarf2_per_objfile *dwarf2_per_objfile;
196
/* names of the debugging sections */
198
/* Note that if the debugging section has been compressed, it might
199
have a name like .zdebug_info. */
201
#define INFO_SECTION "debug_info"
202
#define ABBREV_SECTION "debug_abbrev"
203
#define LINE_SECTION "debug_line"
204
#define PUBNAMES_SECTION "debug_pubnames"
205
#define ARANGES_SECTION "debug_aranges"
206
#define LOC_SECTION "debug_loc"
207
#define MACINFO_SECTION "debug_macinfo"
208
#define STR_SECTION "debug_str"
209
#define RANGES_SECTION "debug_ranges"
210
#define TYPES_SECTION "debug_types"
211
#define FRAME_SECTION "debug_frame"
212
#define EH_FRAME_SECTION "eh_frame"
214
/* local data types */
216
/* We hold several abbreviation tables in memory at the same time. */
217
#ifndef ABBREV_HASH_SIZE
218
#define ABBREV_HASH_SIZE 121
221
/* The data in a compilation unit header, after target2host
222
translation, looks like this. */
223
struct comp_unit_head
227
unsigned char addr_size;
228
unsigned char signed_addr_p;
229
unsigned int abbrev_offset;
231
/* Size of file offsets; either 4 or 8. */
232
unsigned int offset_size;
234
/* Size of the length field; either 4 or 12. */
235
unsigned int initial_length_size;
237
/* Offset to the first byte of this compilation unit header in the
238
.debug_info section, for resolving relative reference dies. */
241
/* Offset to first die in this cu from the start of the cu.
242
This will be the first byte following the compilation unit header. */
243
unsigned int first_die_offset;
246
/* Internal state when decoding a particular compilation unit. */
249
/* The objfile containing this compilation unit. */
250
struct objfile *objfile;
252
/* The header of the compilation unit. */
253
struct comp_unit_head header;
255
/* Base address of this compilation unit. */
256
CORE_ADDR base_address;
258
/* Non-zero if base_address has been set. */
261
struct function_range *first_fn, *last_fn, *cached_fn;
263
/* The language we are debugging. */
264
enum language language;
265
const struct language_defn *language_defn;
267
const char *producer;
269
/* The generic symbol table building routines have separate lists for
270
file scope symbols and all all other scopes (local scopes). So
271
we need to select the right one to pass to add_symbol_to_list().
272
We do it by keeping a pointer to the correct list in list_in_scope.
274
FIXME: The original dwarf code just treated the file scope as the
275
first local scope, and all other local scopes as nested local
276
scopes, and worked fine. Check to see if we really need to
277
distinguish these in buildsym.c. */
278
struct pending **list_in_scope;
280
/* DWARF abbreviation table associated with this compilation unit. */
281
struct abbrev_info **dwarf2_abbrevs;
283
/* Storage for the abbrev table. */
284
struct obstack abbrev_obstack;
286
/* Hash table holding all the loaded partial DIEs. */
289
/* Storage for things with the same lifetime as this read-in compilation
290
unit, including partial DIEs. */
291
struct obstack comp_unit_obstack;
293
/* When multiple dwarf2_cu structures are living in memory, this field
294
chains them all together, so that they can be released efficiently.
295
We will probably also want a generation counter so that most-recently-used
296
compilation units are cached... */
297
struct dwarf2_per_cu_data *read_in_chain;
299
/* Backchain to our per_cu entry if the tree has been built. */
300
struct dwarf2_per_cu_data *per_cu;
302
/* Pointer to the die -> type map. Although it is stored
303
permanently in per_cu, we copy it here to avoid double
307
/* How many compilation units ago was this CU last referenced? */
310
/* A hash table of die offsets for following references. */
313
/* Full DIEs if read in. */
314
struct die_info *dies;
316
/* A set of pointers to dwarf2_per_cu_data objects for compilation
317
units referenced by this one. Only set during full symbol processing;
318
partial symbol tables do not have dependencies. */
321
/* Header data from the line table, during full symbol processing. */
322
struct line_header *line_header;
324
/* Mark used when releasing cached dies. */
325
unsigned int mark : 1;
327
/* This flag will be set if this compilation unit might include
328
inter-compilation-unit references. */
329
unsigned int has_form_ref_addr : 1;
331
/* This flag will be set if this compilation unit includes any
332
DW_TAG_namespace DIEs. If we know that there are explicit
333
DIEs for namespaces, we don't need to try to infer them
334
from mangled names. */
335
unsigned int has_namespace_info : 1;
338
/* Persistent data held for a compilation unit, even when not
339
processing it. We put a pointer to this structure in the
340
read_symtab_private field of the psymtab. If we encounter
341
inter-compilation-unit references, we also maintain a sorted
342
list of all compilation units. */
344
struct dwarf2_per_cu_data
346
/* The start offset and length of this compilation unit. 2**29-1
347
bytes should suffice to store the length of any compilation unit
348
- if it doesn't, GDB will fall over anyway.
349
NOTE: Unlike comp_unit_head.length, this length includes
350
initial_length_size. */
352
unsigned int length : 29;
354
/* Flag indicating this compilation unit will be read in before
355
any of the current compilation units are processed. */
356
unsigned int queued : 1;
358
/* This flag will be set if we need to load absolutely all DIEs
359
for this compilation unit, instead of just the ones we think
360
are interesting. It gets set if we look for a DIE in the
361
hash table and don't find it. */
362
unsigned int load_all_dies : 1;
364
/* Non-zero if this CU is from .debug_types.
365
Otherwise it's from .debug_info. */
366
unsigned int from_debug_types : 1;
368
/* Set iff currently read in. */
369
struct dwarf2_cu *cu;
371
/* If full symbols for this CU have been read in, then this field
372
holds a map of DIE offsets to types. It isn't always possible
373
to reconstruct this information later, so we have to preserve
377
/* The partial symbol table associated with this compilation unit,
378
or NULL for partial units (which do not have an associated
380
struct partial_symtab *psymtab;
383
/* Entry in the signatured_types hash table. */
385
struct signatured_type
389
/* Offset in .debug_types of the TU (type_unit) for this type. */
392
/* Offset in .debug_types of the type defined by this TU. */
393
unsigned int type_offset;
395
/* The CU(/TU) of this type. */
396
struct dwarf2_per_cu_data per_cu;
399
/* Struct used to pass misc. parameters to read_die_and_children, et. al.
400
which are used for both .debug_info and .debug_types dies.
401
All parameters here are unchanging for the life of the call.
402
This struct exists to abstract away the constant parameters of
405
struct die_reader_specs
407
/* The bfd of this objfile. */
410
/* The CU of the DIE we are parsing. */
411
struct dwarf2_cu *cu;
413
/* Pointer to start of section buffer.
414
This is either the start of .debug_info or .debug_types. */
415
const gdb_byte *buffer;
418
/* The line number information for a compilation unit (found in the
419
.debug_line section) begins with a "statement program header",
420
which contains the following information. */
423
unsigned int total_length;
424
unsigned short version;
425
unsigned int header_length;
426
unsigned char minimum_instruction_length;
427
unsigned char default_is_stmt;
429
unsigned char line_range;
430
unsigned char opcode_base;
432
/* standard_opcode_lengths[i] is the number of operands for the
433
standard opcode whose value is i. This means that
434
standard_opcode_lengths[0] is unused, and the last meaningful
435
element is standard_opcode_lengths[opcode_base - 1]. */
436
unsigned char *standard_opcode_lengths;
438
/* The include_directories table. NOTE! These strings are not
439
allocated with xmalloc; instead, they are pointers into
440
debug_line_buffer. If you try to free them, `free' will get
442
unsigned int num_include_dirs, include_dirs_size;
445
/* The file_names table. NOTE! These strings are not allocated
446
with xmalloc; instead, they are pointers into debug_line_buffer.
447
Don't try to free them directly. */
448
unsigned int num_file_names, file_names_size;
452
unsigned int dir_index;
453
unsigned int mod_time;
455
int included_p; /* Non-zero if referenced by the Line Number Program. */
456
struct symtab *symtab; /* The associated symbol table, if any. */
459
/* The start and end of the statement program following this
460
header. These point into dwarf2_per_objfile->line_buffer. */
461
gdb_byte *statement_program_start, *statement_program_end;
464
/* When we construct a partial symbol table entry we only
465
need this much information. */
466
struct partial_die_info
468
/* Offset of this DIE. */
471
/* DWARF-2 tag for this DIE. */
472
ENUM_BITFIELD(dwarf_tag) tag : 16;
474
/* Assorted flags describing the data found in this DIE. */
475
unsigned int has_children : 1;
476
unsigned int is_external : 1;
477
unsigned int is_declaration : 1;
478
unsigned int has_type : 1;
479
unsigned int has_specification : 1;
480
unsigned int has_pc_info : 1;
482
/* Flag set if the SCOPE field of this structure has been
484
unsigned int scope_set : 1;
486
/* Flag set if the DIE has a byte_size attribute. */
487
unsigned int has_byte_size : 1;
489
/* The name of this DIE. Normally the value of DW_AT_name, but
490
sometimes DW_TAG_MIPS_linkage_name or a string computed in some
494
/* The scope to prepend to our children. This is generally
495
allocated on the comp_unit_obstack, so will disappear
496
when this compilation unit leaves the cache. */
499
/* The location description associated with this DIE, if any. */
500
struct dwarf_block *locdesc;
502
/* If HAS_PC_INFO, the PC range associated with this DIE. */
506
/* Pointer into the info_buffer (or types_buffer) pointing at the target of
507
DW_AT_sibling, if any. */
510
/* If HAS_SPECIFICATION, the offset of the DIE referred to by
511
DW_AT_specification (or DW_AT_abstract_origin or
513
unsigned int spec_offset;
515
/* Pointers to this DIE's parent, first child, and next sibling,
517
struct partial_die_info *die_parent, *die_child, *die_sibling;
520
/* This data structure holds the information of an abbrev. */
523
unsigned int number; /* number identifying abbrev */
524
enum dwarf_tag tag; /* dwarf tag */
525
unsigned short has_children; /* boolean */
526
unsigned short num_attrs; /* number of attributes */
527
struct attr_abbrev *attrs; /* an array of attribute descriptions */
528
struct abbrev_info *next; /* next in chain */
533
ENUM_BITFIELD(dwarf_attribute) name : 16;
534
ENUM_BITFIELD(dwarf_form) form : 16;
537
/* Attributes have a name and a value */
540
ENUM_BITFIELD(dwarf_attribute) name : 16;
541
ENUM_BITFIELD(dwarf_form) form : 15;
543
/* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
544
field should be in u.str (existing only for DW_STRING) but it is kept
545
here for better struct attribute alignment. */
546
unsigned int string_is_canonical : 1;
551
struct dwarf_block *blk;
555
struct signatured_type *signatured_type;
560
/* This data structure holds a complete die structure. */
563
/* DWARF-2 tag for this DIE. */
564
ENUM_BITFIELD(dwarf_tag) tag : 16;
566
/* Number of attributes */
567
unsigned short num_attrs;
572
/* Offset in .debug_info or .debug_types section. */
575
/* The dies in a compilation unit form an n-ary tree. PARENT
576
points to this die's parent; CHILD points to the first child of
577
this node; and all the children of a given node are chained
578
together via their SIBLING fields, terminated by a die whose
580
struct die_info *child; /* Its first child, if any. */
581
struct die_info *sibling; /* Its next sibling, if any. */
582
struct die_info *parent; /* Its parent, if any. */
584
/* An array of attributes, with NUM_ATTRS elements. There may be
585
zero, but it's not common and zero-sized arrays are not
586
sufficiently portable C. */
587
struct attribute attrs[1];
590
struct function_range
593
CORE_ADDR lowpc, highpc;
595
struct function_range *next;
598
/* Get at parts of an attribute structure */
600
#define DW_STRING(attr) ((attr)->u.str)
601
#define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
602
#define DW_UNSND(attr) ((attr)->u.unsnd)
603
#define DW_BLOCK(attr) ((attr)->u.blk)
604
#define DW_SND(attr) ((attr)->u.snd)
605
#define DW_ADDR(attr) ((attr)->u.addr)
606
#define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
608
/* Blocks are a bunch of untyped bytes. */
615
#ifndef ATTR_ALLOC_CHUNK
616
#define ATTR_ALLOC_CHUNK 4
619
/* Allocate fields for structs, unions and enums in this size. */
620
#ifndef DW_FIELD_ALLOC_CHUNK
621
#define DW_FIELD_ALLOC_CHUNK 4
624
/* A zeroed version of a partial die for initialization purposes. */
625
static struct partial_die_info zeroed_partial_die;
627
/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
628
but this would require a corresponding change in unpack_field_as_long
630
static int bits_per_byte = 8;
632
/* The routines that read and process dies for a C struct or C++ class
633
pass lists of data member fields and lists of member function fields
634
in an instance of a field_info structure, as defined below. */
637
/* List of data member and baseclasses fields. */
640
struct nextfield *next;
645
*fields, *baseclasses;
647
/* Number of fields (including baseclasses). */
650
/* Number of baseclasses. */
653
/* Set if the accesibility of one of the fields is not public. */
654
int non_public_fields;
656
/* Member function fields array, entries are allocated in the order they
657
are encountered in the object file. */
660
struct nextfnfield *next;
661
struct fn_field fnfield;
665
/* Member function fieldlist array, contains name of possibly overloaded
666
member function, number of overloaded member functions and a pointer
667
to the head of the member function field chain. */
672
struct nextfnfield *head;
676
/* Number of entries in the fnfieldlists array. */
680
/* One item on the queue of compilation units to read in full symbols
682
struct dwarf2_queue_item
684
struct dwarf2_per_cu_data *per_cu;
685
struct dwarf2_queue_item *next;
688
/* The current queue. */
689
static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
691
/* Loaded secondary compilation units are kept in memory until they
692
have not been referenced for the processing of this many
693
compilation units. Set this to zero to disable caching. Cache
694
sizes of up to at least twenty will improve startup time for
695
typical inter-CU-reference binaries, at an obvious memory cost. */
696
static int dwarf2_max_cache_age = 5;
698
show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
699
struct cmd_list_element *c, const char *value)
701
fprintf_filtered (file, _("\
702
The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
707
/* Various complaints about symbol reading that don't abort the process */
710
dwarf2_statement_list_fits_in_line_number_section_complaint (void)
712
complaint (&symfile_complaints,
713
_("statement list doesn't fit in .debug_line section"));
717
dwarf2_debug_line_missing_file_complaint (void)
719
complaint (&symfile_complaints,
720
_(".debug_line section has line data without a file"));
724
dwarf2_debug_line_missing_end_sequence_complaint (void)
726
complaint (&symfile_complaints,
727
_(".debug_line section has line program sequence without an end"));
731
dwarf2_complex_location_expr_complaint (void)
733
complaint (&symfile_complaints, _("location expression too complex"));
737
dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
740
complaint (&symfile_complaints,
741
_("const value length mismatch for '%s', got %d, expected %d"), arg1,
746
dwarf2_macros_too_long_complaint (void)
748
complaint (&symfile_complaints,
749
_("macro info runs off end of `.debug_macinfo' section"));
753
dwarf2_macro_malformed_definition_complaint (const char *arg1)
755
complaint (&symfile_complaints,
756
_("macro debug info contains a malformed macro definition:\n`%s'"),
761
dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
763
complaint (&symfile_complaints,
764
_("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
767
/* local function prototypes */
769
static void dwarf2_locate_sections (bfd *, asection *, void *);
772
static void dwarf2_build_psymtabs_easy (struct objfile *);
775
static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
778
static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
780
struct partial_symtab *);
782
static void dwarf2_build_psymtabs_hard (struct objfile *);
784
static void scan_partial_symbols (struct partial_die_info *,
785
CORE_ADDR *, CORE_ADDR *,
786
int, struct dwarf2_cu *);
788
static void add_partial_symbol (struct partial_die_info *,
791
static int pdi_needs_namespace (enum dwarf_tag tag);
793
static void add_partial_namespace (struct partial_die_info *pdi,
794
CORE_ADDR *lowpc, CORE_ADDR *highpc,
795
int need_pc, struct dwarf2_cu *cu);
797
static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
798
CORE_ADDR *highpc, int need_pc,
799
struct dwarf2_cu *cu);
801
static void add_partial_enumeration (struct partial_die_info *enum_pdi,
802
struct dwarf2_cu *cu);
804
static void add_partial_subprogram (struct partial_die_info *pdi,
805
CORE_ADDR *lowpc, CORE_ADDR *highpc,
806
int need_pc, struct dwarf2_cu *cu);
808
static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
809
gdb_byte *buffer, gdb_byte *info_ptr,
810
bfd *abfd, struct dwarf2_cu *cu);
812
static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
814
static void psymtab_to_symtab_1 (struct partial_symtab *);
816
static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
818
static void dwarf2_free_abbrev_table (void *);
820
static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
823
static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
826
static struct partial_die_info *load_partial_dies (bfd *,
827
gdb_byte *, gdb_byte *,
828
int, struct dwarf2_cu *);
830
static gdb_byte *read_partial_die (struct partial_die_info *,
831
struct abbrev_info *abbrev,
833
gdb_byte *, gdb_byte *,
836
static struct partial_die_info *find_partial_die (unsigned int,
839
static void fixup_partial_die (struct partial_die_info *,
842
static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
843
bfd *, gdb_byte *, struct dwarf2_cu *);
845
static gdb_byte *read_attribute_value (struct attribute *, unsigned,
846
bfd *, gdb_byte *, struct dwarf2_cu *);
848
static unsigned int read_1_byte (bfd *, gdb_byte *);
850
static int read_1_signed_byte (bfd *, gdb_byte *);
852
static unsigned int read_2_bytes (bfd *, gdb_byte *);
854
static unsigned int read_4_bytes (bfd *, gdb_byte *);
856
static ULONGEST read_8_bytes (bfd *, gdb_byte *);
858
static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
861
static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *);
863
static LONGEST read_checked_initial_length_and_offset
864
(bfd *, gdb_byte *, const struct comp_unit_head *,
865
unsigned int *, unsigned int *);
867
static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
870
static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int);
872
static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
874
static char *read_string (bfd *, gdb_byte *, unsigned int *);
876
static char *read_indirect_string (bfd *, gdb_byte *,
877
const struct comp_unit_head *,
880
static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
882
static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
884
static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
886
static void set_cu_language (unsigned int, struct dwarf2_cu *);
888
static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
891
static struct attribute *dwarf2_attr_no_follow (struct die_info *,
895
static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
896
struct dwarf2_cu *cu);
898
static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
900
static struct die_info *die_specification (struct die_info *die,
901
struct dwarf2_cu **);
903
static void free_line_header (struct line_header *lh);
905
static void add_file_name (struct line_header *, char *, unsigned int,
906
unsigned int, unsigned int);
908
static struct line_header *(dwarf_decode_line_header
909
(unsigned int offset,
910
bfd *abfd, struct dwarf2_cu *cu));
912
static void dwarf_decode_lines (struct line_header *, char *, bfd *,
913
struct dwarf2_cu *, struct partial_symtab *);
915
static void dwarf2_start_subfile (char *, char *, char *);
917
static struct symbol *new_symbol (struct die_info *, struct type *,
920
static void dwarf2_const_value (struct attribute *, struct symbol *,
923
static void dwarf2_const_value_data (struct attribute *attr,
927
static struct type *die_type (struct die_info *, struct dwarf2_cu *);
929
static int need_gnat_info (struct dwarf2_cu *);
931
static struct type *die_descriptive_type (struct die_info *, struct dwarf2_cu *);
933
static void set_descriptive_type (struct type *, struct die_info *,
936
static struct type *die_containing_type (struct die_info *,
939
static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
941
static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
943
static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
945
static char *typename_concat (struct obstack *,
950
static void read_file_scope (struct die_info *, struct dwarf2_cu *);
952
static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
954
static void read_func_scope (struct die_info *, struct dwarf2_cu *);
956
static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
958
static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
959
struct dwarf2_cu *, struct partial_symtab *);
961
static int dwarf2_get_pc_bounds (struct die_info *,
962
CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
963
struct partial_symtab *);
965
static void get_scope_pc_bounds (struct die_info *,
966
CORE_ADDR *, CORE_ADDR *,
969
static void dwarf2_record_block_ranges (struct die_info *, struct block *,
970
CORE_ADDR, struct dwarf2_cu *);
972
static void dwarf2_add_field (struct field_info *, struct die_info *,
975
static void dwarf2_attach_fields_to_type (struct field_info *,
976
struct type *, struct dwarf2_cu *);
978
static void dwarf2_add_member_fn (struct field_info *,
979
struct die_info *, struct type *,
982
static void dwarf2_attach_fn_fields_to_type (struct field_info *,
983
struct type *, struct dwarf2_cu *);
985
static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
987
static const char *determine_class_name (struct die_info *die,
988
struct dwarf2_cu *cu);
990
static void read_common_block (struct die_info *, struct dwarf2_cu *);
992
static void read_namespace (struct die_info *die, struct dwarf2_cu *);
994
static void read_module (struct die_info *die, struct dwarf2_cu *cu);
996
static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
998
static const char *namespace_name (struct die_info *die,
999
int *is_anonymous, struct dwarf2_cu *);
1001
static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1003
static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1005
static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1006
struct dwarf2_cu *);
1008
static struct die_info *read_comp_unit (gdb_byte *, struct dwarf2_cu *);
1010
static struct die_info *read_die_and_children_1 (const struct die_reader_specs *reader,
1012
gdb_byte **new_info_ptr,
1013
struct die_info *parent);
1015
static struct die_info *read_die_and_children (const struct die_reader_specs *reader,
1017
gdb_byte **new_info_ptr,
1018
struct die_info *parent);
1020
static struct die_info *read_die_and_siblings (const struct die_reader_specs *reader,
1022
gdb_byte **new_info_ptr,
1023
struct die_info *parent);
1025
static gdb_byte *read_full_die (const struct die_reader_specs *reader,
1026
struct die_info **, gdb_byte *,
1029
static void process_die (struct die_info *, struct dwarf2_cu *);
1031
static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
1033
static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
1036
static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1038
static struct die_info *dwarf2_extension (struct die_info *die,
1039
struct dwarf2_cu **);
1041
static char *dwarf_tag_name (unsigned int);
1043
static char *dwarf_attr_name (unsigned int);
1045
static char *dwarf_form_name (unsigned int);
1047
static char *dwarf_stack_op_name (unsigned int);
1049
static char *dwarf_bool_name (unsigned int);
1051
static char *dwarf_type_encoding_name (unsigned int);
1054
static char *dwarf_cfi_name (unsigned int);
1057
static struct die_info *sibling_die (struct die_info *);
1059
static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1061
static void dump_die_for_error (struct die_info *);
1063
static void dump_die_1 (struct ui_file *, int level, int max_level,
1066
/*static*/ void dump_die (struct die_info *, int max_level);
1068
static void store_in_ref_table (struct die_info *,
1069
struct dwarf2_cu *);
1071
static int is_ref_attr (struct attribute *);
1073
static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
1075
static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
1077
static struct die_info *follow_die_ref_or_sig (struct die_info *,
1079
struct dwarf2_cu **);
1081
static struct die_info *follow_die_ref (struct die_info *,
1083
struct dwarf2_cu **);
1085
static struct die_info *follow_die_sig (struct die_info *,
1087
struct dwarf2_cu **);
1089
static void read_signatured_type_at_offset (struct objfile *objfile,
1090
unsigned int offset);
1092
static void read_signatured_type (struct objfile *,
1093
struct signatured_type *type_sig);
1095
/* memory allocation interface */
1097
static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1099
static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1101
static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1103
static void initialize_cu_func_list (struct dwarf2_cu *);
1105
static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1106
struct dwarf2_cu *);
1108
static void dwarf_decode_macros (struct line_header *, unsigned int,
1109
char *, bfd *, struct dwarf2_cu *);
1111
static int attr_form_is_block (struct attribute *);
1113
static int attr_form_is_section_offset (struct attribute *);
1115
static int attr_form_is_constant (struct attribute *);
1117
static void dwarf2_symbol_mark_computed (struct attribute *attr,
1119
struct dwarf2_cu *cu);
1121
static gdb_byte *skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
1122
struct abbrev_info *abbrev,
1123
struct dwarf2_cu *cu);
1125
static void free_stack_comp_unit (void *);
1127
static hashval_t partial_die_hash (const void *item);
1129
static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1131
static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1132
(unsigned int offset, struct objfile *objfile);
1134
static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1135
(unsigned int offset, struct objfile *objfile);
1137
static struct dwarf2_cu *alloc_one_comp_unit (struct objfile *objfile);
1139
static void free_one_comp_unit (void *);
1141
static void free_cached_comp_units (void *);
1143
static void age_cached_comp_units (void);
1145
static void free_one_cached_comp_unit (void *);
1147
static struct type *set_die_type (struct die_info *, struct type *,
1148
struct dwarf2_cu *);
1150
static void create_all_comp_units (struct objfile *);
1152
static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1155
static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1157
static void dwarf2_add_dependence (struct dwarf2_cu *,
1158
struct dwarf2_per_cu_data *);
1160
static void dwarf2_mark (struct dwarf2_cu *);
1162
static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1164
static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1166
/* Try to locate the sections we need for DWARF 2 debugging
1167
information and return true if we have enough to do something. */
1170
dwarf2_has_info (struct objfile *objfile)
1172
struct dwarf2_per_objfile *data;
1174
/* Initialize per-objfile state. */
1175
data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1176
memset (data, 0, sizeof (*data));
1177
set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1178
dwarf2_per_objfile = data;
1180
bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
1181
return (data->info.asection != NULL && data->abbrev.asection != NULL);
1184
/* When loading sections, we can either look for ".<name>", or for
1185
* ".z<name>", which indicates a compressed section. */
1188
section_is_p (const char *section_name, const char *name)
1190
return (section_name[0] == '.'
1191
&& (strcmp (section_name + 1, name) == 0
1192
|| (section_name[1] == 'z'
1193
&& strcmp (section_name + 2, name) == 0)));
1196
/* This function is mapped across the sections and remembers the
1197
offset and size of each of the debugging sections we are interested
1201
dwarf2_locate_sections (bfd *abfd, asection *sectp, void *ignore_ptr)
1203
if (section_is_p (sectp->name, INFO_SECTION))
1205
dwarf2_per_objfile->info.asection = sectp;
1206
dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
1208
else if (section_is_p (sectp->name, ABBREV_SECTION))
1210
dwarf2_per_objfile->abbrev.asection = sectp;
1211
dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
1213
else if (section_is_p (sectp->name, LINE_SECTION))
1215
dwarf2_per_objfile->line.asection = sectp;
1216
dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
1218
else if (section_is_p (sectp->name, PUBNAMES_SECTION))
1220
dwarf2_per_objfile->pubnames.asection = sectp;
1221
dwarf2_per_objfile->pubnames.size = bfd_get_section_size (sectp);
1223
else if (section_is_p (sectp->name, ARANGES_SECTION))
1225
dwarf2_per_objfile->aranges.asection = sectp;
1226
dwarf2_per_objfile->aranges.size = bfd_get_section_size (sectp);
1228
else if (section_is_p (sectp->name, LOC_SECTION))
1230
dwarf2_per_objfile->loc.asection = sectp;
1231
dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
1233
else if (section_is_p (sectp->name, MACINFO_SECTION))
1235
dwarf2_per_objfile->macinfo.asection = sectp;
1236
dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
1238
else if (section_is_p (sectp->name, STR_SECTION))
1240
dwarf2_per_objfile->str.asection = sectp;
1241
dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
1243
else if (section_is_p (sectp->name, FRAME_SECTION))
1245
dwarf2_per_objfile->frame.asection = sectp;
1246
dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
1248
else if (section_is_p (sectp->name, EH_FRAME_SECTION))
1250
flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1251
if (aflag & SEC_HAS_CONTENTS)
1253
dwarf2_per_objfile->eh_frame.asection = sectp;
1254
dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
1257
else if (section_is_p (sectp->name, RANGES_SECTION))
1259
dwarf2_per_objfile->ranges.asection = sectp;
1260
dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
1262
else if (section_is_p (sectp->name, TYPES_SECTION))
1264
dwarf2_per_objfile->types.asection = sectp;
1265
dwarf2_per_objfile->types.size = bfd_get_section_size (sectp);
1268
if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1269
&& bfd_section_vma (abfd, sectp) == 0)
1270
dwarf2_per_objfile->has_section_at_zero = 1;
1273
/* Decompress a section that was compressed using zlib. Store the
1274
decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1277
zlib_decompress_section (struct objfile *objfile, asection *sectp,
1278
gdb_byte **outbuf, bfd_size_type *outsize)
1280
bfd *abfd = objfile->obfd;
1282
error (_("Support for zlib-compressed DWARF data (from '%s') "
1283
"is disabled in this copy of GDB"),
1284
bfd_get_filename (abfd));
1286
bfd_size_type compressed_size = bfd_get_section_size (sectp);
1287
gdb_byte *compressed_buffer = xmalloc (compressed_size);
1288
struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer);
1289
bfd_size_type uncompressed_size;
1290
gdb_byte *uncompressed_buffer;
1293
int header_size = 12;
1295
if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1296
|| bfd_bread (compressed_buffer, compressed_size, abfd) != compressed_size)
1297
error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1298
bfd_get_filename (abfd));
1300
/* Read the zlib header. In this case, it should be "ZLIB" followed
1301
by the uncompressed section size, 8 bytes in big-endian order. */
1302
if (compressed_size < header_size
1303
|| strncmp (compressed_buffer, "ZLIB", 4) != 0)
1304
error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1305
bfd_get_filename (abfd));
1306
uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
1307
uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
1308
uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
1309
uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
1310
uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
1311
uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
1312
uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
1313
uncompressed_size += compressed_buffer[11];
1315
/* It is possible the section consists of several compressed
1316
buffers concatenated together, so we uncompress in a loop. */
1320
strm.avail_in = compressed_size - header_size;
1321
strm.next_in = (Bytef*) compressed_buffer + header_size;
1322
strm.avail_out = uncompressed_size;
1323
uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack,
1325
rc = inflateInit (&strm);
1326
while (strm.avail_in > 0)
1329
error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1330
bfd_get_filename (abfd), rc);
1331
strm.next_out = ((Bytef*) uncompressed_buffer
1332
+ (uncompressed_size - strm.avail_out));
1333
rc = inflate (&strm, Z_FINISH);
1334
if (rc != Z_STREAM_END)
1335
error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1336
bfd_get_filename (abfd), rc);
1337
rc = inflateReset (&strm);
1339
rc = inflateEnd (&strm);
1341
|| strm.avail_out != 0)
1342
error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1343
bfd_get_filename (abfd), rc);
1345
do_cleanups (cleanup);
1346
*outbuf = uncompressed_buffer;
1347
*outsize = uncompressed_size;
1351
/* Read the contents of the section SECTP from object file specified by
1352
OBJFILE, store info about the section into INFO.
1353
If the section is compressed, uncompress it before returning. */
1356
dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
1358
bfd *abfd = objfile->obfd;
1359
asection *sectp = info->asection;
1360
gdb_byte *buf, *retbuf;
1361
unsigned char header[4];
1363
info->buffer = NULL;
1364
info->was_mmapped = 0;
1366
if (info->asection == NULL || info->size == 0)
1369
/* Check if the file has a 4-byte header indicating compression. */
1370
if (info->size > sizeof (header)
1371
&& bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0
1372
&& bfd_bread (header, sizeof (header), abfd) == sizeof (header))
1374
/* Upon decompression, update the buffer and its size. */
1375
if (strncmp (header, "ZLIB", sizeof (header)) == 0)
1377
zlib_decompress_section (objfile, sectp, &info->buffer,
1385
pagesize = getpagesize ();
1387
/* Only try to mmap sections which are large enough: we don't want to
1388
waste space due to fragmentation. Also, only try mmap for sections
1389
without relocations. */
1391
if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0)
1393
off_t pg_offset = sectp->filepos & ~(pagesize - 1);
1394
size_t map_length = info->size + sectp->filepos - pg_offset;
1395
caddr_t retbuf = bfd_mmap (abfd, 0, map_length, PROT_READ,
1396
MAP_PRIVATE, pg_offset);
1398
if (retbuf != MAP_FAILED)
1400
info->was_mmapped = 1;
1401
info->buffer = retbuf + (sectp->filepos & (pagesize - 1)) ;
1407
/* If we get here, we are a normal, not-compressed section. */
1409
= obstack_alloc (&objfile->objfile_obstack, info->size);
1411
/* When debugging .o files, we may need to apply relocations; see
1412
http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1413
We never compress sections in .o files, so we only need to
1414
try this when the section is not compressed. */
1415
retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
1418
info->buffer = retbuf;
1422
if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1423
|| bfd_bread (buf, info->size, abfd) != info->size)
1424
error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1425
bfd_get_filename (abfd));
1428
/* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1432
dwarf2_get_section_info (struct objfile *objfile, const char *section_name,
1433
asection **sectp, gdb_byte **bufp,
1434
bfd_size_type *sizep)
1436
struct dwarf2_per_objfile *data
1437
= objfile_data (objfile, dwarf2_objfile_data_key);
1438
struct dwarf2_section_info *info;
1439
if (section_is_p (section_name, EH_FRAME_SECTION))
1440
info = &data->eh_frame;
1441
else if (section_is_p (section_name, FRAME_SECTION))
1442
info = &data->frame;
1446
if (info->asection != NULL && info->size != 0 && info->buffer == NULL)
1447
/* We haven't read this section in yet. Do it now. */
1448
dwarf2_read_section (objfile, info);
1450
*sectp = info->asection;
1451
*bufp = info->buffer;
1452
*sizep = info->size;
1455
/* Build a partial symbol table. */
1458
dwarf2_build_psymtabs (struct objfile *objfile)
1460
dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
1461
dwarf2_read_section (objfile, &dwarf2_per_objfile->abbrev);
1462
dwarf2_read_section (objfile, &dwarf2_per_objfile->line);
1463
dwarf2_read_section (objfile, &dwarf2_per_objfile->str);
1464
dwarf2_read_section (objfile, &dwarf2_per_objfile->macinfo);
1465
dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
1466
dwarf2_read_section (objfile, &dwarf2_per_objfile->types);
1467
dwarf2_read_section (objfile, &dwarf2_per_objfile->loc);
1468
dwarf2_read_section (objfile, &dwarf2_per_objfile->eh_frame);
1469
dwarf2_read_section (objfile, &dwarf2_per_objfile->frame);
1471
if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
1473
init_psymbol_list (objfile, 1024);
1477
if (dwarf_aranges_offset && dwarf_pubnames_offset)
1479
/* Things are significantly easier if we have .debug_aranges and
1480
.debug_pubnames sections */
1482
dwarf2_build_psymtabs_easy (objfile);
1486
/* only test this case for now */
1488
/* In this case we have to work a bit harder */
1489
dwarf2_build_psymtabs_hard (objfile);
1494
/* Build the partial symbol table from the information in the
1495
.debug_pubnames and .debug_aranges sections. */
1498
dwarf2_build_psymtabs_easy (struct objfile *objfile)
1500
bfd *abfd = objfile->obfd;
1501
char *aranges_buffer, *pubnames_buffer;
1502
char *aranges_ptr, *pubnames_ptr;
1503
unsigned int entry_length, version, info_offset, info_size;
1505
pubnames_buffer = dwarf2_read_section (objfile,
1506
dwarf_pubnames_section);
1507
pubnames_ptr = pubnames_buffer;
1508
while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames.size)
1510
unsigned int bytes_read;
1512
entry_length = read_initial_length (abfd, pubnames_ptr, &bytes_read);
1513
pubnames_ptr += bytes_read;
1514
version = read_1_byte (abfd, pubnames_ptr);
1516
info_offset = read_4_bytes (abfd, pubnames_ptr);
1518
info_size = read_4_bytes (abfd, pubnames_ptr);
1522
aranges_buffer = dwarf2_read_section (objfile,
1523
dwarf_aranges_section);
1528
/* Return TRUE if OFFSET is within CU_HEADER. */
1531
offset_in_cu_p (const struct comp_unit_head *cu_header, unsigned int offset)
1533
unsigned int bottom = cu_header->offset;
1534
unsigned int top = (cu_header->offset
1536
+ cu_header->initial_length_size);
1537
return (offset >= bottom && offset < top);
1540
/* Read in the comp unit header information from the debug_info at info_ptr.
1541
NOTE: This leaves members offset, first_die_offset to be filled in
1545
read_comp_unit_head (struct comp_unit_head *cu_header,
1546
gdb_byte *info_ptr, bfd *abfd)
1549
unsigned int bytes_read;
1551
cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
1552
cu_header->initial_length_size = bytes_read;
1553
cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
1554
info_ptr += bytes_read;
1555
cu_header->version = read_2_bytes (abfd, info_ptr);
1557
cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1559
info_ptr += bytes_read;
1560
cu_header->addr_size = read_1_byte (abfd, info_ptr);
1562
signed_addr = bfd_get_sign_extend_vma (abfd);
1563
if (signed_addr < 0)
1564
internal_error (__FILE__, __LINE__,
1565
_("read_comp_unit_head: dwarf from non elf file"));
1566
cu_header->signed_addr_p = signed_addr;
1572
partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
1573
gdb_byte *buffer, unsigned int buffer_size,
1576
gdb_byte *beg_of_comp_unit = info_ptr;
1578
info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1580
if (header->version != 2 && header->version != 3)
1581
error (_("Dwarf Error: wrong version in compilation unit header "
1582
"(is %d, should be %d) [in module %s]"), header->version,
1583
2, bfd_get_filename (abfd));
1585
if (header->abbrev_offset >= dwarf2_per_objfile->abbrev.size)
1586
error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1587
"(offset 0x%lx + 6) [in module %s]"),
1588
(long) header->abbrev_offset,
1589
(long) (beg_of_comp_unit - buffer),
1590
bfd_get_filename (abfd));
1592
if (beg_of_comp_unit + header->length + header->initial_length_size
1593
> buffer + buffer_size)
1594
error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1595
"(offset 0x%lx + 0) [in module %s]"),
1596
(long) header->length,
1597
(long) (beg_of_comp_unit - buffer),
1598
bfd_get_filename (abfd));
1603
/* Read in the types comp unit header information from .debug_types entry at
1604
types_ptr. The result is a pointer to one past the end of the header. */
1607
read_type_comp_unit_head (struct comp_unit_head *cu_header,
1608
ULONGEST *signature,
1609
gdb_byte *types_ptr, bfd *abfd)
1611
unsigned int bytes_read;
1612
gdb_byte *initial_types_ptr = types_ptr;
1614
cu_header->offset = types_ptr - dwarf2_per_objfile->types.buffer;
1616
types_ptr = read_comp_unit_head (cu_header, types_ptr, abfd);
1618
*signature = read_8_bytes (abfd, types_ptr);
1620
types_ptr += cu_header->offset_size;
1621
cu_header->first_die_offset = types_ptr - initial_types_ptr;
1626
/* Allocate a new partial symtab for file named NAME and mark this new
1627
partial symtab as being an include of PST. */
1630
dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1631
struct objfile *objfile)
1633
struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1635
subpst->section_offsets = pst->section_offsets;
1636
subpst->textlow = 0;
1637
subpst->texthigh = 0;
1639
subpst->dependencies = (struct partial_symtab **)
1640
obstack_alloc (&objfile->objfile_obstack,
1641
sizeof (struct partial_symtab *));
1642
subpst->dependencies[0] = pst;
1643
subpst->number_of_dependencies = 1;
1645
subpst->globals_offset = 0;
1646
subpst->n_global_syms = 0;
1647
subpst->statics_offset = 0;
1648
subpst->n_static_syms = 0;
1649
subpst->symtab = NULL;
1650
subpst->read_symtab = pst->read_symtab;
1653
/* No private part is necessary for include psymtabs. This property
1654
can be used to differentiate between such include psymtabs and
1655
the regular ones. */
1656
subpst->read_symtab_private = NULL;
1659
/* Read the Line Number Program data and extract the list of files
1660
included by the source file represented by PST. Build an include
1661
partial symtab for each of these included files. */
1664
dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1665
struct die_info *die,
1666
struct partial_symtab *pst)
1668
struct objfile *objfile = cu->objfile;
1669
bfd *abfd = objfile->obfd;
1670
struct line_header *lh = NULL;
1671
struct attribute *attr;
1673
attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
1676
unsigned int line_offset = DW_UNSND (attr);
1677
lh = dwarf_decode_line_header (line_offset, abfd, cu);
1680
return; /* No linetable, so no includes. */
1682
dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1684
free_line_header (lh);
1688
hash_type_signature (const void *item)
1690
const struct signatured_type *type_sig = item;
1691
/* This drops the top 32 bits of the signature, but is ok for a hash. */
1692
return type_sig->signature;
1696
eq_type_signature (const void *item_lhs, const void *item_rhs)
1698
const struct signatured_type *lhs = item_lhs;
1699
const struct signatured_type *rhs = item_rhs;
1700
return lhs->signature == rhs->signature;
1703
/* Create the hash table of all entries in the .debug_types section.
1704
The result is zero if there is an error (e.g. missing .debug_types section),
1705
otherwise non-zero. */
1708
create_debug_types_hash_table (struct objfile *objfile)
1710
gdb_byte *info_ptr = dwarf2_per_objfile->types.buffer;
1713
if (info_ptr == NULL)
1715
dwarf2_per_objfile->signatured_types = NULL;
1719
types_htab = htab_create_alloc_ex (41,
1720
hash_type_signature,
1723
&objfile->objfile_obstack,
1724
hashtab_obstack_allocate,
1725
dummy_obstack_deallocate);
1727
if (dwarf2_die_debug)
1728
fprintf_unfiltered (gdb_stdlog, "Signatured types:\n");
1730
while (info_ptr < dwarf2_per_objfile->types.buffer + dwarf2_per_objfile->types.size)
1732
unsigned int offset;
1733
unsigned int offset_size;
1734
unsigned int type_offset;
1735
unsigned int length, initial_length_size;
1736
unsigned short version;
1738
struct signatured_type *type_sig;
1740
gdb_byte *ptr = info_ptr;
1742
offset = ptr - dwarf2_per_objfile->types.buffer;
1744
/* We need to read the type's signature in order to build the hash
1745
table, but we don't need to read anything else just yet. */
1747
/* Sanity check to ensure entire cu is present. */
1748
length = read_initial_length (objfile->obfd, ptr, &initial_length_size);
1749
if (ptr + length + initial_length_size
1750
> dwarf2_per_objfile->types.buffer + dwarf2_per_objfile->types.size)
1752
complaint (&symfile_complaints,
1753
_("debug type entry runs off end of `.debug_types' section, ignored"));
1757
offset_size = initial_length_size == 4 ? 4 : 8;
1758
ptr += initial_length_size;
1759
version = bfd_get_16 (objfile->obfd, ptr);
1761
ptr += offset_size; /* abbrev offset */
1762
ptr += 1; /* address size */
1763
signature = bfd_get_64 (objfile->obfd, ptr);
1765
type_offset = read_offset_1 (objfile->obfd, ptr, offset_size);
1767
type_sig = obstack_alloc (&objfile->objfile_obstack, sizeof (*type_sig));
1768
memset (type_sig, 0, sizeof (*type_sig));
1769
type_sig->signature = signature;
1770
type_sig->offset = offset;
1771
type_sig->type_offset = type_offset;
1773
slot = htab_find_slot (types_htab, type_sig, INSERT);
1774
gdb_assert (slot != NULL);
1777
if (dwarf2_die_debug)
1778
fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature 0x%s\n",
1779
offset, phex (signature, sizeof (signature)));
1781
info_ptr = info_ptr + initial_length_size + length;
1784
dwarf2_per_objfile->signatured_types = types_htab;
1789
/* Lookup a signature based type.
1790
Returns NULL if SIG is not present in the table. */
1792
static struct signatured_type *
1793
lookup_signatured_type (struct objfile *objfile, ULONGEST sig)
1795
struct signatured_type find_entry, *entry;
1797
if (dwarf2_per_objfile->signatured_types == NULL)
1799
complaint (&symfile_complaints,
1800
_("missing `.debug_types' section for DW_FORM_sig8 die"));
1804
find_entry.signature = sig;
1805
entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
1809
/* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
1812
init_cu_die_reader (struct die_reader_specs *reader,
1813
struct dwarf2_cu *cu)
1815
reader->abfd = cu->objfile->obfd;
1817
if (cu->per_cu->from_debug_types)
1818
reader->buffer = dwarf2_per_objfile->types.buffer;
1820
reader->buffer = dwarf2_per_objfile->info.buffer;
1823
/* Find the base address of the compilation unit for range lists and
1824
location lists. It will normally be specified by DW_AT_low_pc.
1825
In DWARF-3 draft 4, the base address could be overridden by
1826
DW_AT_entry_pc. It's been removed, but GCC still uses this for
1827
compilation units with discontinuous ranges. */
1830
dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
1832
struct attribute *attr;
1835
cu->base_address = 0;
1837
attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
1840
cu->base_address = DW_ADDR (attr);
1845
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
1848
cu->base_address = DW_ADDR (attr);
1854
/* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
1855
to combine the common parts.
1856
Process a compilation unit for a psymtab.
1857
BUFFER is a pointer to the beginning of the dwarf section buffer,
1858
either .debug_info or debug_types.
1859
INFO_PTR is a pointer to the start of the CU.
1860
Returns a pointer to the next CU. */
1863
process_psymtab_comp_unit (struct objfile *objfile,
1864
struct dwarf2_per_cu_data *this_cu,
1865
gdb_byte *buffer, gdb_byte *info_ptr,
1866
unsigned int buffer_size)
1868
bfd *abfd = objfile->obfd;
1869
gdb_byte *beg_of_comp_unit = info_ptr;
1870
struct die_info *comp_unit_die;
1871
struct partial_symtab *pst;
1873
struct cleanup *back_to_inner;
1874
struct dwarf2_cu cu;
1875
unsigned int bytes_read;
1876
int has_children, has_pc_info;
1877
struct attribute *attr;
1879
CORE_ADDR best_lowpc = 0, best_highpc = 0;
1880
struct die_reader_specs reader_specs;
1882
memset (&cu, 0, sizeof (cu));
1883
cu.objfile = objfile;
1884
obstack_init (&cu.comp_unit_obstack);
1886
back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1888
info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr,
1889
buffer, buffer_size,
1892
/* Complete the cu_header. */
1893
cu.header.offset = beg_of_comp_unit - buffer;
1894
cu.header.first_die_offset = info_ptr - beg_of_comp_unit;
1896
cu.list_in_scope = &file_symbols;
1898
/* If this compilation unit was already read in, free the
1899
cached copy in order to read it in again. This is
1900
necessary because we skipped some symbols when we first
1901
read in the compilation unit (see load_partial_dies).
1902
This problem could be avoided, but the benefit is
1904
if (this_cu->cu != NULL)
1905
free_one_cached_comp_unit (this_cu->cu);
1907
/* Note that this is a pointer to our stack frame, being
1908
added to a global data structure. It will be cleaned up
1909
in free_stack_comp_unit when we finish with this
1910
compilation unit. */
1912
cu.per_cu = this_cu;
1914
/* Read the abbrevs for this compilation unit into a table. */
1915
dwarf2_read_abbrevs (abfd, &cu);
1916
make_cleanup (dwarf2_free_abbrev_table, &cu);
1918
/* Read the compilation unit die. */
1919
if (this_cu->from_debug_types)
1920
info_ptr += 8 /*signature*/ + cu.header.offset_size;
1921
init_cu_die_reader (&reader_specs, &cu);
1922
info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
1925
if (this_cu->from_debug_types)
1927
/* offset,length haven't been set yet for type units. */
1928
this_cu->offset = cu.header.offset;
1929
this_cu->length = cu.header.length + cu.header.initial_length_size;
1931
else if (comp_unit_die->tag == DW_TAG_partial_unit)
1933
info_ptr = (beg_of_comp_unit + cu.header.length
1934
+ cu.header.initial_length_size);
1935
do_cleanups (back_to_inner);
1939
/* Set the language we're debugging. */
1940
attr = dwarf2_attr (comp_unit_die, DW_AT_language, &cu);
1942
set_cu_language (DW_UNSND (attr), &cu);
1944
set_cu_language (language_minimal, &cu);
1946
/* Allocate a new partial symbol table structure. */
1947
attr = dwarf2_attr (comp_unit_die, DW_AT_name, &cu);
1948
pst = start_psymtab_common (objfile, objfile->section_offsets,
1949
(attr != NULL) ? DW_STRING (attr) : "",
1950
/* TEXTLOW and TEXTHIGH are set below. */
1952
objfile->global_psymbols.next,
1953
objfile->static_psymbols.next);
1955
attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, &cu);
1957
pst->dirname = DW_STRING (attr);
1959
pst->read_symtab_private = (char *) this_cu;
1961
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1963
/* Store the function that reads in the rest of the symbol table */
1964
pst->read_symtab = dwarf2_psymtab_to_symtab;
1966
this_cu->psymtab = pst;
1968
dwarf2_find_base_address (comp_unit_die, &cu);
1970
/* Possibly set the default values of LOWPC and HIGHPC from
1972
has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
1973
&best_highpc, &cu, pst);
1974
if (has_pc_info == 1 && best_lowpc < best_highpc)
1975
/* Store the contiguous range if it is not empty; it can be empty for
1976
CUs with no code. */
1977
addrmap_set_empty (objfile->psymtabs_addrmap,
1978
best_lowpc + baseaddr,
1979
best_highpc + baseaddr - 1, pst);
1981
/* Check if comp unit has_children.
1982
If so, read the rest of the partial symbols from this comp unit.
1983
If not, there's no more debug_info for this comp unit. */
1986
struct partial_die_info *first_die;
1987
CORE_ADDR lowpc, highpc;
1989
lowpc = ((CORE_ADDR) -1);
1990
highpc = ((CORE_ADDR) 0);
1992
first_die = load_partial_dies (abfd, buffer, info_ptr, 1, &cu);
1994
scan_partial_symbols (first_die, &lowpc, &highpc,
1995
! has_pc_info, &cu);
1997
/* If we didn't find a lowpc, set it to highpc to avoid
1998
complaints from `maint check'. */
1999
if (lowpc == ((CORE_ADDR) -1))
2002
/* If the compilation unit didn't have an explicit address range,
2003
then use the information extracted from its child dies. */
2007
best_highpc = highpc;
2010
pst->textlow = best_lowpc + baseaddr;
2011
pst->texthigh = best_highpc + baseaddr;
2013
pst->n_global_syms = objfile->global_psymbols.next -
2014
(objfile->global_psymbols.list + pst->globals_offset);
2015
pst->n_static_syms = objfile->static_psymbols.next -
2016
(objfile->static_psymbols.list + pst->statics_offset);
2017
sort_pst_symbols (pst);
2019
info_ptr = (beg_of_comp_unit + cu.header.length
2020
+ cu.header.initial_length_size);
2022
if (this_cu->from_debug_types)
2024
/* It's not clear we want to do anything with stmt lists here.
2025
Waiting to see what gcc ultimately does. */
2029
/* Get the list of files included in the current compilation unit,
2030
and build a psymtab for each of them. */
2031
dwarf2_build_include_psymtabs (&cu, comp_unit_die, pst);
2034
do_cleanups (back_to_inner);
2039
/* Traversal function for htab_traverse_noresize.
2040
Process one .debug_types comp-unit. */
2043
process_type_comp_unit (void **slot, void *info)
2045
struct signatured_type *entry = (struct signatured_type *) *slot;
2046
struct objfile *objfile = (struct objfile *) info;
2047
struct dwarf2_per_cu_data *this_cu;
2049
this_cu = &entry->per_cu;
2050
this_cu->from_debug_types = 1;
2052
process_psymtab_comp_unit (objfile, this_cu,
2053
dwarf2_per_objfile->types.buffer,
2054
dwarf2_per_objfile->types.buffer + entry->offset,
2055
dwarf2_per_objfile->types.size);
2060
/* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
2061
Build partial symbol tables for the .debug_types comp-units. */
2064
build_type_psymtabs (struct objfile *objfile)
2066
if (! create_debug_types_hash_table (objfile))
2069
htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
2070
process_type_comp_unit, objfile);
2073
/* Build the partial symbol table by doing a quick pass through the
2074
.debug_info and .debug_abbrev sections. */
2077
dwarf2_build_psymtabs_hard (struct objfile *objfile)
2079
/* Instead of reading this into a big buffer, we should probably use
2080
mmap() on architectures that support it. (FIXME) */
2081
bfd *abfd = objfile->obfd;
2083
struct cleanup *back_to;
2085
info_ptr = dwarf2_per_objfile->info.buffer;
2087
/* Any cached compilation units will be linked by the per-objfile
2088
read_in_chain. Make sure to free them when we're done. */
2089
back_to = make_cleanup (free_cached_comp_units, NULL);
2091
build_type_psymtabs (objfile);
2093
create_all_comp_units (objfile);
2095
objfile->psymtabs_addrmap =
2096
addrmap_create_mutable (&objfile->objfile_obstack);
2098
/* Since the objects we're extracting from .debug_info vary in
2099
length, only the individual functions to extract them (like
2100
read_comp_unit_head and load_partial_die) can really know whether
2101
the buffer is large enough to hold another complete object.
2103
At the moment, they don't actually check that. If .debug_info
2104
holds just one extra byte after the last compilation unit's dies,
2105
then read_comp_unit_head will happily read off the end of the
2106
buffer. read_partial_die is similarly casual. Those functions
2109
For this loop condition, simply checking whether there's any data
2110
left at all should be sufficient. */
2112
while (info_ptr < (dwarf2_per_objfile->info.buffer
2113
+ dwarf2_per_objfile->info.size))
2115
struct dwarf2_per_cu_data *this_cu;
2117
this_cu = dwarf2_find_comp_unit (info_ptr - dwarf2_per_objfile->info.buffer,
2120
info_ptr = process_psymtab_comp_unit (objfile, this_cu,
2121
dwarf2_per_objfile->info.buffer,
2123
dwarf2_per_objfile->info.size);
2126
objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
2127
&objfile->objfile_obstack);
2129
do_cleanups (back_to);
2132
/* Load the partial DIEs for a secondary CU into memory. */
2135
load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu,
2136
struct objfile *objfile)
2138
bfd *abfd = objfile->obfd;
2139
gdb_byte *info_ptr, *beg_of_comp_unit;
2140
struct die_info *comp_unit_die;
2141
struct dwarf2_cu *cu;
2142
unsigned int bytes_read;
2143
struct cleanup *back_to;
2144
struct attribute *attr;
2146
struct die_reader_specs reader_specs;
2148
gdb_assert (! this_cu->from_debug_types);
2150
info_ptr = dwarf2_per_objfile->info.buffer + this_cu->offset;
2151
beg_of_comp_unit = info_ptr;
2153
cu = alloc_one_comp_unit (objfile);
2155
/* ??? Missing cleanup for CU? */
2157
/* Link this compilation unit into the compilation unit tree. */
2159
cu->per_cu = this_cu;
2160
cu->type_hash = this_cu->type_hash;
2162
info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr,
2163
dwarf2_per_objfile->info.buffer,
2164
dwarf2_per_objfile->info.size,
2167
/* Complete the cu_header. */
2168
cu->header.offset = this_cu->offset;
2169
cu->header.first_die_offset = info_ptr - beg_of_comp_unit;
2171
/* Read the abbrevs for this compilation unit into a table. */
2172
dwarf2_read_abbrevs (abfd, cu);
2173
back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
2175
/* Read the compilation unit die. */
2176
init_cu_die_reader (&reader_specs, cu);
2177
info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
2180
/* Set the language we're debugging. */
2181
attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
2183
set_cu_language (DW_UNSND (attr), cu);
2185
set_cu_language (language_minimal, cu);
2187
/* Check if comp unit has_children.
2188
If so, read the rest of the partial symbols from this comp unit.
2189
If not, there's no more debug_info for this comp unit. */
2191
load_partial_dies (abfd, dwarf2_per_objfile->info.buffer, info_ptr, 0, cu);
2193
do_cleanups (back_to);
2196
/* Create a list of all compilation units in OBJFILE. We do this only
2197
if an inter-comp-unit reference is found; presumably if there is one,
2198
there will be many, and one will occur early in the .debug_info section.
2199
So there's no point in building this list incrementally. */
2202
create_all_comp_units (struct objfile *objfile)
2206
struct dwarf2_per_cu_data **all_comp_units;
2207
gdb_byte *info_ptr = dwarf2_per_objfile->info.buffer;
2211
all_comp_units = xmalloc (n_allocated
2212
* sizeof (struct dwarf2_per_cu_data *));
2214
while (info_ptr < dwarf2_per_objfile->info.buffer + dwarf2_per_objfile->info.size)
2216
unsigned int length, initial_length_size;
2217
gdb_byte *beg_of_comp_unit;
2218
struct dwarf2_per_cu_data *this_cu;
2219
unsigned int offset;
2221
offset = info_ptr - dwarf2_per_objfile->info.buffer;
2223
/* Read just enough information to find out where the next
2224
compilation unit is. */
2225
length = read_initial_length (objfile->obfd, info_ptr,
2226
&initial_length_size);
2228
/* Save the compilation unit for later lookup. */
2229
this_cu = obstack_alloc (&objfile->objfile_obstack,
2230
sizeof (struct dwarf2_per_cu_data));
2231
memset (this_cu, 0, sizeof (*this_cu));
2232
this_cu->offset = offset;
2233
this_cu->length = length + initial_length_size;
2235
if (n_comp_units == n_allocated)
2238
all_comp_units = xrealloc (all_comp_units,
2240
* sizeof (struct dwarf2_per_cu_data *));
2242
all_comp_units[n_comp_units++] = this_cu;
2244
info_ptr = info_ptr + this_cu->length;
2247
dwarf2_per_objfile->all_comp_units
2248
= obstack_alloc (&objfile->objfile_obstack,
2249
n_comp_units * sizeof (struct dwarf2_per_cu_data *));
2250
memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
2251
n_comp_units * sizeof (struct dwarf2_per_cu_data *));
2252
xfree (all_comp_units);
2253
dwarf2_per_objfile->n_comp_units = n_comp_units;
2256
/* Process all loaded DIEs for compilation unit CU, starting at
2257
FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
2258
unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
2259
DW_AT_ranges). If NEED_PC is set, then this function will set
2260
*LOWPC and *HIGHPC to the lowest and highest PC values found in CU
2261
and record the covered ranges in the addrmap. */
2264
scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
2265
CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
2267
struct objfile *objfile = cu->objfile;
2268
bfd *abfd = objfile->obfd;
2269
struct partial_die_info *pdi;
2271
/* Now, march along the PDI's, descending into ones which have
2272
interesting children but skipping the children of the other ones,
2273
until we reach the end of the compilation unit. */
2279
fixup_partial_die (pdi, cu);
2281
/* Anonymous namespaces have no name but have interesting
2282
children, so we need to look at them. Ditto for anonymous
2285
if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
2286
|| pdi->tag == DW_TAG_enumeration_type)
2290
case DW_TAG_subprogram:
2291
add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
2293
case DW_TAG_variable:
2294
case DW_TAG_typedef:
2295
case DW_TAG_union_type:
2296
if (!pdi->is_declaration)
2298
add_partial_symbol (pdi, cu);
2301
case DW_TAG_class_type:
2302
case DW_TAG_interface_type:
2303
case DW_TAG_structure_type:
2304
if (!pdi->is_declaration)
2306
add_partial_symbol (pdi, cu);
2309
case DW_TAG_enumeration_type:
2310
if (!pdi->is_declaration)
2311
add_partial_enumeration (pdi, cu);
2313
case DW_TAG_base_type:
2314
case DW_TAG_subrange_type:
2315
/* File scope base type definitions are added to the partial
2317
add_partial_symbol (pdi, cu);
2319
case DW_TAG_namespace:
2320
add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
2323
add_partial_module (pdi, lowpc, highpc, need_pc, cu);
2330
/* If the die has a sibling, skip to the sibling. */
2332
pdi = pdi->die_sibling;
2336
/* Functions used to compute the fully scoped name of a partial DIE.
2338
Normally, this is simple. For C++, the parent DIE's fully scoped
2339
name is concatenated with "::" and the partial DIE's name. For
2340
Java, the same thing occurs except that "." is used instead of "::".
2341
Enumerators are an exception; they use the scope of their parent
2342
enumeration type, i.e. the name of the enumeration type is not
2343
prepended to the enumerator.
2345
There are two complexities. One is DW_AT_specification; in this
2346
case "parent" means the parent of the target of the specification,
2347
instead of the direct parent of the DIE. The other is compilers
2348
which do not emit DW_TAG_namespace; in this case we try to guess
2349
the fully qualified name of structure types from their members'
2350
linkage names. This must be done using the DIE's children rather
2351
than the children of any DW_AT_specification target. We only need
2352
to do this for structures at the top level, i.e. if the target of
2353
any DW_AT_specification (if any; otherwise the DIE itself) does not
2356
/* Compute the scope prefix associated with PDI's parent, in
2357
compilation unit CU. The result will be allocated on CU's
2358
comp_unit_obstack, or a copy of the already allocated PDI->NAME
2359
field. NULL is returned if no prefix is necessary. */
2361
partial_die_parent_scope (struct partial_die_info *pdi,
2362
struct dwarf2_cu *cu)
2364
char *grandparent_scope;
2365
struct partial_die_info *parent, *real_pdi;
2367
/* We need to look at our parent DIE; if we have a DW_AT_specification,
2368
then this means the parent of the specification DIE. */
2371
while (real_pdi->has_specification)
2372
real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2374
parent = real_pdi->die_parent;
2378
if (parent->scope_set)
2379
return parent->scope;
2381
fixup_partial_die (parent, cu);
2383
grandparent_scope = partial_die_parent_scope (parent, cu);
2385
if (parent->tag == DW_TAG_namespace
2386
|| parent->tag == DW_TAG_structure_type
2387
|| parent->tag == DW_TAG_class_type
2388
|| parent->tag == DW_TAG_interface_type
2389
|| parent->tag == DW_TAG_union_type
2390
|| parent->tag == DW_TAG_enumeration_type)
2392
if (grandparent_scope == NULL)
2393
parent->scope = parent->name;
2395
parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
2398
else if (parent->tag == DW_TAG_enumerator)
2399
/* Enumerators should not get the name of the enumeration as a prefix. */
2400
parent->scope = grandparent_scope;
2403
/* FIXME drow/2004-04-01: What should we be doing with
2404
function-local names? For partial symbols, we should probably be
2406
complaint (&symfile_complaints,
2407
_("unhandled containing DIE tag %d for DIE at %d"),
2408
parent->tag, pdi->offset);
2409
parent->scope = grandparent_scope;
2412
parent->scope_set = 1;
2413
return parent->scope;
2416
/* Return the fully scoped name associated with PDI, from compilation unit
2417
CU. The result will be allocated with malloc. */
2419
partial_die_full_name (struct partial_die_info *pdi,
2420
struct dwarf2_cu *cu)
2424
parent_scope = partial_die_parent_scope (pdi, cu);
2425
if (parent_scope == NULL)
2428
return typename_concat (NULL, parent_scope, pdi->name, cu);
2432
add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
2434
struct objfile *objfile = cu->objfile;
2436
char *actual_name = NULL;
2437
const char *my_prefix;
2438
const struct partial_symbol *psym = NULL;
2440
int built_actual_name = 0;
2442
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2444
if (pdi_needs_namespace (pdi->tag))
2446
actual_name = partial_die_full_name (pdi, cu);
2448
built_actual_name = 1;
2451
if (actual_name == NULL)
2452
actual_name = pdi->name;
2456
case DW_TAG_subprogram:
2457
if (pdi->is_external || cu->language == language_ada)
2459
/* brobecker/2007-12-26: Normally, only "external" DIEs are part
2460
of the global scope. But in Ada, we want to be able to access
2461
nested procedures globally. So all Ada subprograms are stored
2462
in the global scope. */
2463
/*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2464
mst_text, objfile); */
2465
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
2467
VAR_DOMAIN, LOC_BLOCK,
2468
&objfile->global_psymbols,
2469
0, pdi->lowpc + baseaddr,
2470
cu->language, objfile);
2474
/*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2475
mst_file_text, objfile); */
2476
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
2478
VAR_DOMAIN, LOC_BLOCK,
2479
&objfile->static_psymbols,
2480
0, pdi->lowpc + baseaddr,
2481
cu->language, objfile);
2484
case DW_TAG_variable:
2485
if (pdi->is_external)
2488
Don't enter into the minimal symbol tables as there is
2489
a minimal symbol table entry from the ELF symbols already.
2490
Enter into partial symbol table if it has a location
2491
descriptor or a type.
2492
If the location descriptor is missing, new_symbol will create
2493
a LOC_UNRESOLVED symbol, the address of the variable will then
2494
be determined from the minimal symbol table whenever the variable
2496
The address for the partial symbol table entry is not
2497
used by GDB, but it comes in handy for debugging partial symbol
2501
addr = decode_locdesc (pdi->locdesc, cu);
2502
if (pdi->locdesc || pdi->has_type)
2503
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
2505
VAR_DOMAIN, LOC_STATIC,
2506
&objfile->global_psymbols,
2508
cu->language, objfile);
2512
/* Static Variable. Skip symbols without location descriptors. */
2513
if (pdi->locdesc == NULL)
2515
if (built_actual_name)
2516
xfree (actual_name);
2519
addr = decode_locdesc (pdi->locdesc, cu);
2520
/*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2521
mst_file_data, objfile); */
2522
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
2524
VAR_DOMAIN, LOC_STATIC,
2525
&objfile->static_psymbols,
2527
cu->language, objfile);
2530
case DW_TAG_typedef:
2531
case DW_TAG_base_type:
2532
case DW_TAG_subrange_type:
2533
add_psymbol_to_list (actual_name, strlen (actual_name),
2535
VAR_DOMAIN, LOC_TYPEDEF,
2536
&objfile->static_psymbols,
2537
0, (CORE_ADDR) 0, cu->language, objfile);
2539
case DW_TAG_namespace:
2540
add_psymbol_to_list (actual_name, strlen (actual_name),
2542
VAR_DOMAIN, LOC_TYPEDEF,
2543
&objfile->global_psymbols,
2544
0, (CORE_ADDR) 0, cu->language, objfile);
2546
case DW_TAG_class_type:
2547
case DW_TAG_interface_type:
2548
case DW_TAG_structure_type:
2549
case DW_TAG_union_type:
2550
case DW_TAG_enumeration_type:
2551
/* Skip external references. The DWARF standard says in the section
2552
about "Structure, Union, and Class Type Entries": "An incomplete
2553
structure, union or class type is represented by a structure,
2554
union or class entry that does not have a byte size attribute
2555
and that has a DW_AT_declaration attribute." */
2556
if (!pdi->has_byte_size && pdi->is_declaration)
2558
if (built_actual_name)
2559
xfree (actual_name);
2563
/* NOTE: carlton/2003-10-07: See comment in new_symbol about
2564
static vs. global. */
2565
add_psymbol_to_list (actual_name, strlen (actual_name),
2567
STRUCT_DOMAIN, LOC_TYPEDEF,
2568
(cu->language == language_cplus
2569
|| cu->language == language_java)
2570
? &objfile->global_psymbols
2571
: &objfile->static_psymbols,
2572
0, (CORE_ADDR) 0, cu->language, objfile);
2575
case DW_TAG_enumerator:
2576
add_psymbol_to_list (actual_name, strlen (actual_name),
2578
VAR_DOMAIN, LOC_CONST,
2579
(cu->language == language_cplus
2580
|| cu->language == language_java)
2581
? &objfile->global_psymbols
2582
: &objfile->static_psymbols,
2583
0, (CORE_ADDR) 0, cu->language, objfile);
2589
/* Check to see if we should scan the name for possible namespace
2590
info. Only do this if this is C++, if we don't have namespace
2591
debugging info in the file, if the psym is of an appropriate type
2592
(otherwise we'll have psym == NULL), and if we actually had a
2593
mangled name to begin with. */
2595
/* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2596
cases which do not set PSYM above? */
2598
if (cu->language == language_cplus
2599
&& cu->has_namespace_info == 0
2601
&& SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
2602
cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
2605
if (built_actual_name)
2606
xfree (actual_name);
2609
/* Determine whether a die of type TAG living in a C++ class or
2610
namespace needs to have the name of the scope prepended to the
2611
name listed in the die. */
2614
pdi_needs_namespace (enum dwarf_tag tag)
2618
case DW_TAG_namespace:
2619
case DW_TAG_typedef:
2620
case DW_TAG_class_type:
2621
case DW_TAG_interface_type:
2622
case DW_TAG_structure_type:
2623
case DW_TAG_union_type:
2624
case DW_TAG_enumeration_type:
2625
case DW_TAG_enumerator:
2632
/* Read a partial die corresponding to a namespace; also, add a symbol
2633
corresponding to that namespace to the symbol table. NAMESPACE is
2634
the name of the enclosing namespace. */
2637
add_partial_namespace (struct partial_die_info *pdi,
2638
CORE_ADDR *lowpc, CORE_ADDR *highpc,
2639
int need_pc, struct dwarf2_cu *cu)
2641
struct objfile *objfile = cu->objfile;
2643
/* Add a symbol for the namespace. */
2645
add_partial_symbol (pdi, cu);
2647
/* Now scan partial symbols in that namespace. */
2649
if (pdi->has_children)
2650
scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
2653
/* Read a partial die corresponding to a Fortran module. */
2656
add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
2657
CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
2659
/* Now scan partial symbols in that module.
2661
FIXME: Support the separate Fortran module namespaces. */
2663
if (pdi->has_children)
2664
scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
2667
/* Read a partial die corresponding to a subprogram and create a partial
2668
symbol for that subprogram. When the CU language allows it, this
2669
routine also defines a partial symbol for each nested subprogram
2670
that this subprogram contains.
2672
DIE my also be a lexical block, in which case we simply search
2673
recursively for suprograms defined inside that lexical block.
2674
Again, this is only performed when the CU language allows this
2675
type of definitions. */
2678
add_partial_subprogram (struct partial_die_info *pdi,
2679
CORE_ADDR *lowpc, CORE_ADDR *highpc,
2680
int need_pc, struct dwarf2_cu *cu)
2682
if (pdi->tag == DW_TAG_subprogram)
2684
if (pdi->has_pc_info)
2686
if (pdi->lowpc < *lowpc)
2687
*lowpc = pdi->lowpc;
2688
if (pdi->highpc > *highpc)
2689
*highpc = pdi->highpc;
2693
struct objfile *objfile = cu->objfile;
2695
baseaddr = ANOFFSET (objfile->section_offsets,
2696
SECT_OFF_TEXT (objfile));
2697
addrmap_set_empty (objfile->psymtabs_addrmap,
2698
pdi->lowpc + baseaddr,
2699
pdi->highpc - 1 + baseaddr,
2700
cu->per_cu->psymtab);
2702
if (!pdi->is_declaration)
2703
add_partial_symbol (pdi, cu);
2707
if (! pdi->has_children)
2710
if (cu->language == language_ada)
2712
pdi = pdi->die_child;
2715
fixup_partial_die (pdi, cu);
2716
if (pdi->tag == DW_TAG_subprogram
2717
|| pdi->tag == DW_TAG_lexical_block)
2718
add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
2719
pdi = pdi->die_sibling;
2724
/* See if we can figure out if the class lives in a namespace. We do
2725
this by looking for a member function; its demangled name will
2726
contain namespace info, if there is any. */
2729
guess_structure_name (struct partial_die_info *struct_pdi,
2730
struct dwarf2_cu *cu)
2732
if ((cu->language == language_cplus
2733
|| cu->language == language_java)
2734
&& cu->has_namespace_info == 0
2735
&& struct_pdi->has_children)
2737
/* NOTE: carlton/2003-10-07: Getting the info this way changes
2738
what template types look like, because the demangler
2739
frequently doesn't give the same name as the debug info. We
2740
could fix this by only using the demangled name to get the
2741
prefix (but see comment in read_structure_type). */
2743
struct partial_die_info *child_pdi = struct_pdi->die_child;
2744
struct partial_die_info *real_pdi;
2746
/* If this DIE (this DIE's specification, if any) has a parent, then
2747
we should not do this. We'll prepend the parent's fully qualified
2748
name when we create the partial symbol. */
2750
real_pdi = struct_pdi;
2751
while (real_pdi->has_specification)
2752
real_pdi = find_partial_die (real_pdi->spec_offset, cu);
2754
if (real_pdi->die_parent != NULL)
2757
while (child_pdi != NULL)
2759
if (child_pdi->tag == DW_TAG_subprogram)
2761
char *actual_class_name
2762
= language_class_name_from_physname (cu->language_defn,
2764
if (actual_class_name != NULL)
2767
= obsavestring (actual_class_name,
2768
strlen (actual_class_name),
2769
&cu->objfile->objfile_obstack);
2770
xfree (actual_class_name);
2775
child_pdi = child_pdi->die_sibling;
2780
/* Read a partial die corresponding to an enumeration type. */
2783
add_partial_enumeration (struct partial_die_info *enum_pdi,
2784
struct dwarf2_cu *cu)
2786
struct objfile *objfile = cu->objfile;
2787
bfd *abfd = objfile->obfd;
2788
struct partial_die_info *pdi;
2790
if (enum_pdi->name != NULL)
2791
add_partial_symbol (enum_pdi, cu);
2793
pdi = enum_pdi->die_child;
2796
if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
2797
complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
2799
add_partial_symbol (pdi, cu);
2800
pdi = pdi->die_sibling;
2804
/* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2805
Return the corresponding abbrev, or NULL if the number is zero (indicating
2806
an empty DIE). In either case *BYTES_READ will be set to the length of
2807
the initial number. */
2809
static struct abbrev_info *
2810
peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
2811
struct dwarf2_cu *cu)
2813
bfd *abfd = cu->objfile->obfd;
2814
unsigned int abbrev_number;
2815
struct abbrev_info *abbrev;
2817
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
2819
if (abbrev_number == 0)
2822
abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
2825
error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
2826
bfd_get_filename (abfd));
2832
/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2833
Returns a pointer to the end of a series of DIEs, terminated by an empty
2834
DIE. Any children of the skipped DIEs will also be skipped. */
2837
skip_children (gdb_byte *buffer, gdb_byte *info_ptr, struct dwarf2_cu *cu)
2839
struct abbrev_info *abbrev;
2840
unsigned int bytes_read;
2844
abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
2846
return info_ptr + bytes_read;
2848
info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
2852
/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
2853
INFO_PTR should point just after the initial uleb128 of a DIE, and the
2854
abbrev corresponding to that skipped uleb128 should be passed in
2855
ABBREV. Returns a pointer to this DIE's sibling, skipping any
2859
skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
2860
struct abbrev_info *abbrev, struct dwarf2_cu *cu)
2862
unsigned int bytes_read;
2863
struct attribute attr;
2864
bfd *abfd = cu->objfile->obfd;
2865
unsigned int form, i;
2867
for (i = 0; i < abbrev->num_attrs; i++)
2869
/* The only abbrev we care about is DW_AT_sibling. */
2870
if (abbrev->attrs[i].name == DW_AT_sibling)
2872
read_attribute (&attr, &abbrev->attrs[i],
2873
abfd, info_ptr, cu);
2874
if (attr.form == DW_FORM_ref_addr)
2875
complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
2877
return buffer + dwarf2_get_ref_die_offset (&attr);
2880
/* If it isn't DW_AT_sibling, skip this attribute. */
2881
form = abbrev->attrs[i].form;
2885
case DW_FORM_ref_addr:
2886
/* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
2887
and later it is offset sized. */
2888
if (cu->header.version == 2)
2889
info_ptr += cu->header.addr_size;
2891
info_ptr += cu->header.offset_size;
2894
info_ptr += cu->header.addr_size;
2914
case DW_FORM_string:
2915
read_string (abfd, info_ptr, &bytes_read);
2916
info_ptr += bytes_read;
2919
info_ptr += cu->header.offset_size;
2922
info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2923
info_ptr += bytes_read;
2925
case DW_FORM_block1:
2926
info_ptr += 1 + read_1_byte (abfd, info_ptr);
2928
case DW_FORM_block2:
2929
info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2931
case DW_FORM_block4:
2932
info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2936
case DW_FORM_ref_udata:
2937
info_ptr = skip_leb128 (abfd, info_ptr);
2939
case DW_FORM_indirect:
2940
form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2941
info_ptr += bytes_read;
2942
/* We need to continue parsing from here, so just go back to
2944
goto skip_attribute;
2947
error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2948
dwarf_form_name (form),
2949
bfd_get_filename (abfd));
2953
if (abbrev->has_children)
2954
return skip_children (buffer, info_ptr, cu);
2959
/* Locate ORIG_PDI's sibling.
2960
INFO_PTR should point to the start of the next DIE after ORIG_PDI
2964
locate_pdi_sibling (struct partial_die_info *orig_pdi,
2965
gdb_byte *buffer, gdb_byte *info_ptr,
2966
bfd *abfd, struct dwarf2_cu *cu)
2968
/* Do we know the sibling already? */
2970
if (orig_pdi->sibling)
2971
return orig_pdi->sibling;
2973
/* Are there any children to deal with? */
2975
if (!orig_pdi->has_children)
2978
/* Skip the children the long way. */
2980
return skip_children (buffer, info_ptr, cu);
2983
/* Expand this partial symbol table into a full symbol table. */
2986
dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2988
/* FIXME: This is barely more than a stub. */
2993
warning (_("bug: psymtab for %s is already read in."), pst->filename);
2999
printf_filtered (_("Reading in symbols for %s..."), pst->filename);
3000
gdb_flush (gdb_stdout);
3003
/* Restore our global data. */
3004
dwarf2_per_objfile = objfile_data (pst->objfile,
3005
dwarf2_objfile_data_key);
3007
/* If this psymtab is constructed from a debug-only objfile, the
3008
has_section_at_zero flag will not necessarily be correct. We
3009
can get the correct value for this flag by looking at the data
3010
associated with the (presumably stripped) associated objfile. */
3011
if (pst->objfile->separate_debug_objfile_backlink)
3013
struct dwarf2_per_objfile *dpo_backlink
3014
= objfile_data (pst->objfile->separate_debug_objfile_backlink,
3015
dwarf2_objfile_data_key);
3016
dwarf2_per_objfile->has_section_at_zero
3017
= dpo_backlink->has_section_at_zero;
3020
psymtab_to_symtab_1 (pst);
3022
/* Finish up the debug error message. */
3024
printf_filtered (_("done.\n"));
3029
/* Add PER_CU to the queue. */
3032
queue_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
3034
struct dwarf2_queue_item *item;
3037
item = xmalloc (sizeof (*item));
3038
item->per_cu = per_cu;
3041
if (dwarf2_queue == NULL)
3042
dwarf2_queue = item;
3044
dwarf2_queue_tail->next = item;
3046
dwarf2_queue_tail = item;
3049
/* Process the queue. */
3052
process_queue (struct objfile *objfile)
3054
struct dwarf2_queue_item *item, *next_item;
3056
/* The queue starts out with one item, but following a DIE reference
3057
may load a new CU, adding it to the end of the queue. */
3058
for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
3060
if (item->per_cu->psymtab && !item->per_cu->psymtab->readin)
3061
process_full_comp_unit (item->per_cu);
3063
item->per_cu->queued = 0;
3064
next_item = item->next;
3068
dwarf2_queue_tail = NULL;
3071
/* Free all allocated queue entries. This function only releases anything if
3072
an error was thrown; if the queue was processed then it would have been
3073
freed as we went along. */
3076
dwarf2_release_queue (void *dummy)
3078
struct dwarf2_queue_item *item, *last;
3080
item = dwarf2_queue;
3083
/* Anything still marked queued is likely to be in an
3084
inconsistent state, so discard it. */
3085
if (item->per_cu->queued)
3087
if (item->per_cu->cu != NULL)
3088
free_one_cached_comp_unit (item->per_cu->cu);
3089
item->per_cu->queued = 0;
3097
dwarf2_queue = dwarf2_queue_tail = NULL;
3100
/* Read in full symbols for PST, and anything it depends on. */
3103
psymtab_to_symtab_1 (struct partial_symtab *pst)
3105
struct dwarf2_per_cu_data *per_cu;
3106
struct cleanup *back_to;
3109
for (i = 0; i < pst->number_of_dependencies; i++)
3110
if (!pst->dependencies[i]->readin)
3112
/* Inform about additional files that need to be read in. */
3115
/* FIXME: i18n: Need to make this a single string. */
3116
fputs_filtered (" ", gdb_stdout);
3118
fputs_filtered ("and ", gdb_stdout);
3120
printf_filtered ("%s...", pst->dependencies[i]->filename);
3121
wrap_here (""); /* Flush output */
3122
gdb_flush (gdb_stdout);
3124
psymtab_to_symtab_1 (pst->dependencies[i]);
3127
per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
3131
/* It's an include file, no symbols to read for it.
3132
Everything is in the parent symtab. */
3137
back_to = make_cleanup (dwarf2_release_queue, NULL);
3139
queue_comp_unit (per_cu, pst->objfile);
3141
if (per_cu->from_debug_types)
3142
read_signatured_type_at_offset (pst->objfile, per_cu->offset);
3144
load_full_comp_unit (per_cu, pst->objfile);
3146
process_queue (pst->objfile);
3148
/* Age the cache, releasing compilation units that have not
3149
been used recently. */
3150
age_cached_comp_units ();
3152
do_cleanups (back_to);
3155
/* Load the DIEs associated with PER_CU into memory. */
3158
load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
3160
bfd *abfd = objfile->obfd;
3161
struct dwarf2_cu *cu;
3162
unsigned int offset;
3163
gdb_byte *info_ptr, *beg_of_comp_unit;
3164
struct cleanup *back_to, *free_cu_cleanup;
3165
struct attribute *attr;
3168
gdb_assert (! per_cu->from_debug_types);
3170
/* Set local variables from the partial symbol table info. */
3171
offset = per_cu->offset;
3173
info_ptr = dwarf2_per_objfile->info.buffer + offset;
3174
beg_of_comp_unit = info_ptr;
3176
cu = alloc_one_comp_unit (objfile);
3178
/* If an error occurs while loading, release our storage. */
3179
free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
3181
/* Read in the comp_unit header. */
3182
info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
3184
/* Complete the cu_header. */
3185
cu->header.offset = offset;
3186
cu->header.first_die_offset = info_ptr - beg_of_comp_unit;
3188
/* Read the abbrevs for this compilation unit. */
3189
dwarf2_read_abbrevs (abfd, cu);
3190
back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
3192
/* Link this compilation unit into the compilation unit tree. */
3194
cu->per_cu = per_cu;
3195
cu->type_hash = per_cu->type_hash;
3197
cu->dies = read_comp_unit (info_ptr, cu);
3199
/* We try not to read any attributes in this function, because not
3200
all objfiles needed for references have been loaded yet, and symbol
3201
table processing isn't initialized. But we have to set the CU language,
3202
or we won't be able to build types correctly. */
3203
attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
3205
set_cu_language (DW_UNSND (attr), cu);
3207
set_cu_language (language_minimal, cu);
3209
/* Link this CU into read_in_chain. */
3210
per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
3211
dwarf2_per_objfile->read_in_chain = per_cu;
3213
do_cleanups (back_to);
3215
/* We've successfully allocated this compilation unit. Let our caller
3216
clean it up when finished with it. */
3217
discard_cleanups (free_cu_cleanup);
3220
/* Generate full symbol information for PST and CU, whose DIEs have
3221
already been loaded into memory. */
3224
process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
3226
struct partial_symtab *pst = per_cu->psymtab;
3227
struct dwarf2_cu *cu = per_cu->cu;
3228
struct objfile *objfile = pst->objfile;
3229
bfd *abfd = objfile->obfd;
3230
CORE_ADDR lowpc, highpc;
3231
struct symtab *symtab;
3232
struct cleanup *back_to;
3235
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3238
back_to = make_cleanup (really_free_pendings, NULL);
3240
cu->list_in_scope = &file_symbols;
3242
dwarf2_find_base_address (cu->dies, cu);
3244
/* Do line number decoding in read_file_scope () */
3245
process_die (cu->dies, cu);
3247
/* Some compilers don't define a DW_AT_high_pc attribute for the
3248
compilation unit. If the DW_AT_high_pc is missing, synthesize
3249
it, by scanning the DIE's below the compilation unit. */
3250
get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
3252
symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
3254
/* Set symtab language to language from DW_AT_language.
3255
If the compilation is from a C file generated by language preprocessors,
3256
do not set the language if it was already deduced by start_subfile. */
3258
&& !(cu->language == language_c && symtab->language != language_c))
3260
symtab->language = cu->language;
3262
pst->symtab = symtab;
3265
do_cleanups (back_to);
3268
/* Process a die and its children. */
3271
process_die (struct die_info *die, struct dwarf2_cu *cu)
3275
case DW_TAG_padding:
3277
case DW_TAG_compile_unit:
3278
read_file_scope (die, cu);
3280
case DW_TAG_type_unit:
3281
read_type_unit_scope (die, cu);
3283
case DW_TAG_subprogram:
3284
case DW_TAG_inlined_subroutine:
3285
read_func_scope (die, cu);
3287
case DW_TAG_lexical_block:
3288
case DW_TAG_try_block:
3289
case DW_TAG_catch_block:
3290
read_lexical_block_scope (die, cu);
3292
case DW_TAG_class_type:
3293
case DW_TAG_interface_type:
3294
case DW_TAG_structure_type:
3295
case DW_TAG_union_type:
3296
process_structure_scope (die, cu);
3298
case DW_TAG_enumeration_type:
3299
process_enumeration_scope (die, cu);
3302
/* These dies have a type, but processing them does not create
3303
a symbol or recurse to process the children. Therefore we can
3304
read them on-demand through read_type_die. */
3305
case DW_TAG_subroutine_type:
3306
case DW_TAG_set_type:
3307
case DW_TAG_array_type:
3308
case DW_TAG_pointer_type:
3309
case DW_TAG_ptr_to_member_type:
3310
case DW_TAG_reference_type:
3311
case DW_TAG_string_type:
3314
case DW_TAG_base_type:
3315
case DW_TAG_subrange_type:
3316
case DW_TAG_typedef:
3317
/* Add a typedef symbol for the type definition, if it has a
3319
new_symbol (die, read_type_die (die, cu), cu);
3321
case DW_TAG_common_block:
3322
read_common_block (die, cu);
3324
case DW_TAG_common_inclusion:
3326
case DW_TAG_namespace:
3327
processing_has_namespace_info = 1;
3328
read_namespace (die, cu);
3331
read_module (die, cu);
3333
case DW_TAG_imported_declaration:
3334
case DW_TAG_imported_module:
3335
processing_has_namespace_info = 1;
3336
if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
3337
|| cu->language != language_fortran))
3338
complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
3339
dwarf_tag_name (die->tag));
3340
read_import_statement (die, cu);
3343
new_symbol (die, NULL, cu);
3348
/* Return the fully qualified name of DIE, based on its DW_AT_name.
3349
If scope qualifiers are appropriate they will be added. The result
3350
will be allocated on the objfile_obstack, or NULL if the DIE does
3354
dwarf2_full_name (struct die_info *die, struct dwarf2_cu *cu)
3356
struct attribute *attr;
3357
char *prefix, *name;
3358
struct ui_file *buf = NULL;
3360
name = dwarf2_name (die, cu);
3364
/* These are the only languages we know how to qualify names in. */
3365
if (cu->language != language_cplus
3366
&& cu->language != language_java)
3369
/* If no prefix is necessary for this type of DIE, return the
3370
unqualified name. The other three tags listed could be handled
3371
in pdi_needs_namespace, but that requires broader changes. */
3372
if (!pdi_needs_namespace (die->tag)
3373
&& die->tag != DW_TAG_subprogram
3374
&& die->tag != DW_TAG_variable
3375
&& die->tag != DW_TAG_member)
3378
prefix = determine_prefix (die, cu);
3379
if (*prefix != '\0')
3380
name = typename_concat (&cu->objfile->objfile_obstack, prefix,
3386
/* Read the import statement specified by the given die and record it. */
3389
read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
3391
struct attribute *import_attr;
3392
struct die_info *imported_die;
3393
struct dwarf2_cu *imported_cu;
3394
const char *imported_name;
3395
const char *imported_name_prefix;
3398
const char *import_prefix;
3399
char *canonical_name;
3401
import_attr = dwarf2_attr (die, DW_AT_import, cu);
3402
if (import_attr == NULL)
3404
complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
3405
dwarf_tag_name (die->tag));
3410
imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
3411
imported_name = dwarf2_name (imported_die, imported_cu);
3412
if (imported_name == NULL)
3414
/* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
3416
The import in the following code:
3430
<2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
3431
<52> DW_AT_decl_file : 1
3432
<53> DW_AT_decl_line : 6
3433
<54> DW_AT_import : <0x75>
3434
<2><58>: Abbrev Number: 4 (DW_TAG_typedef)
3436
<5b> DW_AT_decl_file : 1
3437
<5c> DW_AT_decl_line : 2
3438
<5d> DW_AT_type : <0x6e>
3440
<1><75>: Abbrev Number: 7 (DW_TAG_base_type)
3441
<76> DW_AT_byte_size : 4
3442
<77> DW_AT_encoding : 5 (signed)
3444
imports the wrong die ( 0x75 instead of 0x58 ).
3445
This case will be ignored until the gcc bug is fixed. */
3449
/* Figure out the local name after import. */
3450
import_alias = dwarf2_name (die, cu);
3452
/* Figure out where the statement is being imported to. */
3453
import_prefix = determine_prefix (die, cu);
3455
/* Figure out what the scope of the imported die is and prepend it
3456
to the name of the imported die. */
3457
imported_name_prefix = determine_prefix (imported_die, imported_cu);
3459
if (strlen (imported_name_prefix) > 0)
3461
canonical_name = alloca (strlen (imported_name_prefix)
3462
+ 2 + strlen (imported_name) + 1);
3463
strcpy (canonical_name, imported_name_prefix);
3464
strcat (canonical_name, "::");
3465
strcat (canonical_name, imported_name);
3469
canonical_name = alloca (strlen (imported_name) + 1);
3470
strcpy (canonical_name, imported_name);
3473
using_directives = cp_add_using (import_prefix,
3480
initialize_cu_func_list (struct dwarf2_cu *cu)
3482
cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
3486
free_cu_line_header (void *arg)
3488
struct dwarf2_cu *cu = arg;
3490
free_line_header (cu->line_header);
3491
cu->line_header = NULL;
3495
read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
3497
struct objfile *objfile = cu->objfile;
3498
struct comp_unit_head *cu_header = &cu->header;
3499
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
3500
CORE_ADDR lowpc = ((CORE_ADDR) -1);
3501
CORE_ADDR highpc = ((CORE_ADDR) 0);
3502
struct attribute *attr;
3504
char *comp_dir = NULL;
3505
struct die_info *child_die;
3506
bfd *abfd = objfile->obfd;
3507
struct line_header *line_header = 0;
3510
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3512
get_scope_pc_bounds (die, &lowpc, &highpc, cu);
3514
/* If we didn't find a lowpc, set it to highpc to avoid complaints
3515
from finish_block. */
3516
if (lowpc == ((CORE_ADDR) -1))
3521
/* Find the filename. Do not use dwarf2_name here, since the filename
3522
is not a source language identifier. */
3523
attr = dwarf2_attr (die, DW_AT_name, cu);
3526
name = DW_STRING (attr);
3529
attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
3531
comp_dir = DW_STRING (attr);
3532
else if (name != NULL && IS_ABSOLUTE_PATH (name))
3534
comp_dir = ldirname (name);
3535
if (comp_dir != NULL)
3536
make_cleanup (xfree, comp_dir);
3538
if (comp_dir != NULL)
3540
/* Irix 6.2 native cc prepends <machine>.: to the compilation
3541
directory, get rid of it. */
3542
char *cp = strchr (comp_dir, ':');
3544
if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
3551
attr = dwarf2_attr (die, DW_AT_language, cu);
3554
set_cu_language (DW_UNSND (attr), cu);
3557
attr = dwarf2_attr (die, DW_AT_producer, cu);
3559
cu->producer = DW_STRING (attr);
3561
/* We assume that we're processing GCC output. */
3562
processing_gcc_compilation = 2;
3564
processing_has_namespace_info = 0;
3566
start_symtab (name, comp_dir, lowpc);
3567
record_debugformat ("DWARF 2");
3568
record_producer (cu->producer);
3570
initialize_cu_func_list (cu);
3572
/* Decode line number information if present. We do this before
3573
processing child DIEs, so that the line header table is available
3574
for DW_AT_decl_file. */
3575
attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
3578
unsigned int line_offset = DW_UNSND (attr);
3579
line_header = dwarf_decode_line_header (line_offset, abfd, cu);
3582
cu->line_header = line_header;
3583
make_cleanup (free_cu_line_header, cu);
3584
dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
3588
/* Process all dies in compilation unit. */
3589
if (die->child != NULL)
3591
child_die = die->child;
3592
while (child_die && child_die->tag)
3594
process_die (child_die, cu);
3595
child_die = sibling_die (child_die);
3599
/* Decode macro information, if present. Dwarf 2 macro information
3600
refers to information in the line number info statement program
3601
header, so we can only read it if we've read the header
3603
attr = dwarf2_attr (die, DW_AT_macro_info, cu);
3604
if (attr && line_header)
3606
unsigned int macro_offset = DW_UNSND (attr);
3607
dwarf_decode_macros (line_header, macro_offset,
3608
comp_dir, abfd, cu);
3610
do_cleanups (back_to);
3613
/* For TUs we want to skip the first top level sibling if it's not the
3614
actual type being defined by this TU. In this case the first top
3615
level sibling is there to provide context only. */
3618
read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
3620
struct objfile *objfile = cu->objfile;
3621
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
3623
struct attribute *attr;
3625
char *comp_dir = NULL;
3626
struct die_info *child_die;
3627
bfd *abfd = objfile->obfd;
3628
struct line_header *line_header = 0;
3630
/* start_symtab needs a low pc, but we don't really have one.
3631
Do what read_file_scope would do in the absence of such info. */
3632
lowpc = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3634
/* Find the filename. Do not use dwarf2_name here, since the filename
3635
is not a source language identifier. */
3636
attr = dwarf2_attr (die, DW_AT_name, cu);
3638
name = DW_STRING (attr);
3640
attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
3642
comp_dir = DW_STRING (attr);
3643
else if (name != NULL && IS_ABSOLUTE_PATH (name))
3645
comp_dir = ldirname (name);
3646
if (comp_dir != NULL)
3647
make_cleanup (xfree, comp_dir);
3653
attr = dwarf2_attr (die, DW_AT_language, cu);
3655
set_cu_language (DW_UNSND (attr), cu);
3657
/* This isn't technically needed today. It is done for symmetry
3658
with read_file_scope. */
3659
attr = dwarf2_attr (die, DW_AT_producer, cu);
3661
cu->producer = DW_STRING (attr);
3663
/* We assume that we're processing GCC output. */
3664
processing_gcc_compilation = 2;
3666
processing_has_namespace_info = 0;
3668
start_symtab (name, comp_dir, lowpc);
3669
record_debugformat ("DWARF 2");
3670
record_producer (cu->producer);
3672
/* Process the dies in the type unit. */
3673
if (die->child == NULL)
3675
dump_die_for_error (die);
3676
error (_("Dwarf Error: Missing children for type unit [in module %s]"),
3677
bfd_get_filename (abfd));
3680
child_die = die->child;
3682
while (child_die && child_die->tag)
3684
process_die (child_die, cu);
3686
child_die = sibling_die (child_die);
3689
do_cleanups (back_to);
3693
add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
3694
struct dwarf2_cu *cu)
3696
struct function_range *thisfn;
3698
thisfn = (struct function_range *)
3699
obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
3700
thisfn->name = name;
3701
thisfn->lowpc = lowpc;
3702
thisfn->highpc = highpc;
3703
thisfn->seen_line = 0;
3704
thisfn->next = NULL;
3706
if (cu->last_fn == NULL)
3707
cu->first_fn = thisfn;
3709
cu->last_fn->next = thisfn;
3711
cu->last_fn = thisfn;
3714
/* qsort helper for inherit_abstract_dies. */
3717
unsigned_int_compar (const void *ap, const void *bp)
3719
unsigned int a = *(unsigned int *) ap;
3720
unsigned int b = *(unsigned int *) bp;
3722
return (a > b) - (b > a);
3725
/* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
3726
Inherit only the children of the DW_AT_abstract_origin DIE not being already
3727
referenced by DW_AT_abstract_origin from the children of the current DIE. */
3730
inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
3732
struct die_info *child_die;
3733
unsigned die_children_count;
3734
/* CU offsets which were referenced by children of the current DIE. */
3736
unsigned *offsets_end, *offsetp;
3737
/* Parent of DIE - referenced by DW_AT_abstract_origin. */
3738
struct die_info *origin_die;
3739
/* Iterator of the ORIGIN_DIE children. */
3740
struct die_info *origin_child_die;
3741
struct cleanup *cleanups;
3742
struct attribute *attr;
3744
attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
3748
origin_die = follow_die_ref (die, attr, &cu);
3749
if (die->tag != origin_die->tag
3750
&& !(die->tag == DW_TAG_inlined_subroutine
3751
&& origin_die->tag == DW_TAG_subprogram))
3752
complaint (&symfile_complaints,
3753
_("DIE 0x%x and its abstract origin 0x%x have different tags"),
3754
die->offset, origin_die->offset);
3756
child_die = die->child;
3757
die_children_count = 0;
3758
while (child_die && child_die->tag)
3760
child_die = sibling_die (child_die);
3761
die_children_count++;
3763
offsets = xmalloc (sizeof (*offsets) * die_children_count);
3764
cleanups = make_cleanup (xfree, offsets);
3766
offsets_end = offsets;
3767
child_die = die->child;
3768
while (child_die && child_die->tag)
3770
/* For each CHILD_DIE, find the corresponding child of
3771
ORIGIN_DIE. If there is more than one layer of
3772
DW_AT_abstract_origin, follow them all; there shouldn't be,
3773
but GCC versions at least through 4.4 generate this (GCC PR
3775
struct die_info *child_origin_die = child_die;
3778
attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin, cu);
3781
child_origin_die = follow_die_ref (child_origin_die, attr, &cu);
3784
/* According to DWARF3 3.3.8.2 #3 new entries without their abstract
3785
counterpart may exist. */
3786
if (child_origin_die != child_die)
3788
if (child_die->tag != child_origin_die->tag
3789
&& !(child_die->tag == DW_TAG_inlined_subroutine
3790
&& child_origin_die->tag == DW_TAG_subprogram))
3791
complaint (&symfile_complaints,
3792
_("Child DIE 0x%x and its abstract origin 0x%x have "
3793
"different tags"), child_die->offset,
3794
child_origin_die->offset);
3795
if (child_origin_die->parent != origin_die)
3796
complaint (&symfile_complaints,
3797
_("Child DIE 0x%x and its abstract origin 0x%x have "
3798
"different parents"), child_die->offset,
3799
child_origin_die->offset);
3801
*offsets_end++ = child_origin_die->offset;
3803
child_die = sibling_die (child_die);
3805
qsort (offsets, offsets_end - offsets, sizeof (*offsets),
3806
unsigned_int_compar);
3807
for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
3808
if (offsetp[-1] == *offsetp)
3809
complaint (&symfile_complaints, _("Multiple children of DIE 0x%x refer "
3810
"to DIE 0x%x as their abstract origin"),
3811
die->offset, *offsetp);
3814
origin_child_die = origin_die->child;
3815
while (origin_child_die && origin_child_die->tag)
3817
/* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
3818
while (offsetp < offsets_end && *offsetp < origin_child_die->offset)
3820
if (offsetp >= offsets_end || *offsetp > origin_child_die->offset)
3822
/* Found that ORIGIN_CHILD_DIE is really not referenced. */
3823
process_die (origin_child_die, cu);
3825
origin_child_die = sibling_die (origin_child_die);
3828
do_cleanups (cleanups);
3832
read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
3834
struct objfile *objfile = cu->objfile;
3835
struct context_stack *new;
3838
struct die_info *child_die;
3839
struct attribute *attr, *call_line, *call_file;
3842
struct block *block;
3843
int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
3847
/* If we do not have call site information, we can't show the
3848
caller of this inlined function. That's too confusing, so
3849
only use the scope for local variables. */
3850
call_line = dwarf2_attr (die, DW_AT_call_line, cu);
3851
call_file = dwarf2_attr (die, DW_AT_call_file, cu);
3852
if (call_line == NULL || call_file == NULL)
3854
read_lexical_block_scope (die, cu);
3859
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3861
name = dwarf2_linkage_name (die, cu);
3863
/* Ignore functions with missing or empty names and functions with
3864
missing or invalid low and high pc attributes. */
3865
if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
3871
/* Record the function range for dwarf_decode_lines. */
3872
add_to_cu_func_list (name, lowpc, highpc, cu);
3874
new = push_context (0, lowpc);
3875
new->name = new_symbol (die, read_type_die (die, cu), cu);
3877
/* If there is a location expression for DW_AT_frame_base, record
3879
attr = dwarf2_attr (die, DW_AT_frame_base, cu);
3881
/* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
3882
expression is being recorded directly in the function's symbol
3883
and not in a separate frame-base object. I guess this hack is
3884
to avoid adding some sort of frame-base adjunct/annex to the
3885
function's symbol :-(. The problem with doing this is that it
3886
results in a function symbol with a location expression that
3887
has nothing to do with the location of the function, ouch! The
3888
relationship should be: a function's symbol has-a frame base; a
3889
frame-base has-a location expression. */
3890
dwarf2_symbol_mark_computed (attr, new->name, cu);
3892
cu->list_in_scope = &local_symbols;
3894
if (die->child != NULL)
3896
child_die = die->child;
3897
while (child_die && child_die->tag)
3899
process_die (child_die, cu);
3900
child_die = sibling_die (child_die);
3904
inherit_abstract_dies (die, cu);
3906
new = pop_context ();
3907
/* Make a block for the local symbols within. */
3908
block = finish_block (new->name, &local_symbols, new->old_blocks,
3909
lowpc, highpc, objfile);
3911
/* For C++, set the block's scope. */
3912
if (cu->language == language_cplus)
3913
cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
3914
determine_prefix (die, cu),
3915
processing_has_namespace_info);
3917
/* If we have address ranges, record them. */
3918
dwarf2_record_block_ranges (die, block, baseaddr, cu);
3920
/* In C++, we can have functions nested inside functions (e.g., when
3921
a function declares a class that has methods). This means that
3922
when we finish processing a function scope, we may need to go
3923
back to building a containing block's symbol lists. */
3924
local_symbols = new->locals;
3925
param_symbols = new->params;
3926
using_directives = new->using_directives;
3928
/* If we've finished processing a top-level function, subsequent
3929
symbols go in the file symbol list. */
3930
if (outermost_context_p ())
3931
cu->list_in_scope = &file_symbols;
3934
/* Process all the DIES contained within a lexical block scope. Start
3935
a new scope, process the dies, and then close the scope. */
3938
read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
3940
struct objfile *objfile = cu->objfile;
3941
struct context_stack *new;
3942
CORE_ADDR lowpc, highpc;
3943
struct die_info *child_die;
3946
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3948
/* Ignore blocks with missing or invalid low and high pc attributes. */
3949
/* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3950
as multiple lexical blocks? Handling children in a sane way would
3951
be nasty. Might be easier to properly extend generic blocks to
3953
if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
3958
push_context (0, lowpc);
3959
if (die->child != NULL)
3961
child_die = die->child;
3962
while (child_die && child_die->tag)
3964
process_die (child_die, cu);
3965
child_die = sibling_die (child_die);
3968
new = pop_context ();
3970
if (local_symbols != NULL || using_directives != NULL)
3973
= finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
3976
/* Note that recording ranges after traversing children, as we
3977
do here, means that recording a parent's ranges entails
3978
walking across all its children's ranges as they appear in
3979
the address map, which is quadratic behavior.
3981
It would be nicer to record the parent's ranges before
3982
traversing its children, simply overriding whatever you find
3983
there. But since we don't even decide whether to create a
3984
block until after we've traversed its children, that's hard
3986
dwarf2_record_block_ranges (die, block, baseaddr, cu);
3988
local_symbols = new->locals;
3989
using_directives = new->using_directives;
3992
/* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3993
Return 1 if the attributes are present and valid, otherwise, return 0.
3994
If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
3997
dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
3998
CORE_ADDR *high_return, struct dwarf2_cu *cu,
3999
struct partial_symtab *ranges_pst)
4001
struct objfile *objfile = cu->objfile;
4002
struct comp_unit_head *cu_header = &cu->header;
4003
bfd *obfd = objfile->obfd;
4004
unsigned int addr_size = cu_header->addr_size;
4005
CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
4006
/* Base address selection entry. */
4017
found_base = cu->base_known;
4018
base = cu->base_address;
4020
if (offset >= dwarf2_per_objfile->ranges.size)
4022
complaint (&symfile_complaints,
4023
_("Offset %d out of bounds for DW_AT_ranges attribute"),
4027
buffer = dwarf2_per_objfile->ranges.buffer + offset;
4029
/* Read in the largest possible address. */
4030
marker = read_address (obfd, buffer, cu, &dummy);
4031
if ((marker & mask) == mask)
4033
/* If we found the largest possible address, then
4034
read the base address. */
4035
base = read_address (obfd, buffer + addr_size, cu, &dummy);
4036
buffer += 2 * addr_size;
4037
offset += 2 * addr_size;
4043
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4047
CORE_ADDR range_beginning, range_end;
4049
range_beginning = read_address (obfd, buffer, cu, &dummy);
4050
buffer += addr_size;
4051
range_end = read_address (obfd, buffer, cu, &dummy);
4052
buffer += addr_size;
4053
offset += 2 * addr_size;
4055
/* An end of list marker is a pair of zero addresses. */
4056
if (range_beginning == 0 && range_end == 0)
4057
/* Found the end of list entry. */
4060
/* Each base address selection entry is a pair of 2 values.
4061
The first is the largest possible address, the second is
4062
the base address. Check for a base address here. */
4063
if ((range_beginning & mask) == mask)
4065
/* If we found the largest possible address, then
4066
read the base address. */
4067
base = read_address (obfd, buffer + addr_size, cu, &dummy);
4074
/* We have no valid base address for the ranges
4076
complaint (&symfile_complaints,
4077
_("Invalid .debug_ranges data (no base address)"));
4081
range_beginning += base;
4084
if (ranges_pst != NULL && range_beginning < range_end)
4085
addrmap_set_empty (objfile->psymtabs_addrmap,
4086
range_beginning + baseaddr, range_end - 1 + baseaddr,
4089
/* FIXME: This is recording everything as a low-high
4090
segment of consecutive addresses. We should have a
4091
data structure for discontiguous block ranges
4095
low = range_beginning;
4101
if (range_beginning < low)
4102
low = range_beginning;
4103
if (range_end > high)
4109
/* If the first entry is an end-of-list marker, the range
4110
describes an empty scope, i.e. no instructions. */
4116
*high_return = high;
4120
/* Get low and high pc attributes from a die. Return 1 if the attributes
4121
are present and valid, otherwise, return 0. Return -1 if the range is
4122
discontinuous, i.e. derived from DW_AT_ranges information. */
4124
dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
4125
CORE_ADDR *highpc, struct dwarf2_cu *cu,
4126
struct partial_symtab *pst)
4128
struct attribute *attr;
4133
attr = dwarf2_attr (die, DW_AT_high_pc, cu);
4136
high = DW_ADDR (attr);
4137
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4139
low = DW_ADDR (attr);
4141
/* Found high w/o low attribute. */
4144
/* Found consecutive range of addresses. */
4149
attr = dwarf2_attr (die, DW_AT_ranges, cu);
4152
/* Value of the DW_AT_ranges attribute is the offset in the
4153
.debug_ranges section. */
4154
if (!dwarf2_ranges_read (DW_UNSND (attr), &low, &high, cu, pst))
4156
/* Found discontinuous range of addresses. */
4164
/* When using the GNU linker, .gnu.linkonce. sections are used to
4165
eliminate duplicate copies of functions and vtables and such.
4166
The linker will arbitrarily choose one and discard the others.
4167
The AT_*_pc values for such functions refer to local labels in
4168
these sections. If the section from that file was discarded, the
4169
labels are not in the output, so the relocs get a value of 0.
4170
If this is a discarded function, mark the pc bounds as invalid,
4171
so that GDB will ignore it. */
4172
if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
4180
/* Assuming that DIE represents a subprogram DIE or a lexical block, get
4181
its low and high PC addresses. Do nothing if these addresses could not
4182
be determined. Otherwise, set LOWPC to the low address if it is smaller,
4183
and HIGHPC to the high address if greater than HIGHPC. */
4186
dwarf2_get_subprogram_pc_bounds (struct die_info *die,
4187
CORE_ADDR *lowpc, CORE_ADDR *highpc,
4188
struct dwarf2_cu *cu)
4190
CORE_ADDR low, high;
4191
struct die_info *child = die->child;
4193
if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
4195
*lowpc = min (*lowpc, low);
4196
*highpc = max (*highpc, high);
4199
/* If the language does not allow nested subprograms (either inside
4200
subprograms or lexical blocks), we're done. */
4201
if (cu->language != language_ada)
4204
/* Check all the children of the given DIE. If it contains nested
4205
subprograms, then check their pc bounds. Likewise, we need to
4206
check lexical blocks as well, as they may also contain subprogram
4208
while (child && child->tag)
4210
if (child->tag == DW_TAG_subprogram
4211
|| child->tag == DW_TAG_lexical_block)
4212
dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
4213
child = sibling_die (child);
4217
/* Get the low and high pc's represented by the scope DIE, and store
4218
them in *LOWPC and *HIGHPC. If the correct values can't be
4219
determined, set *LOWPC to -1 and *HIGHPC to 0. */
4222
get_scope_pc_bounds (struct die_info *die,
4223
CORE_ADDR *lowpc, CORE_ADDR *highpc,
4224
struct dwarf2_cu *cu)
4226
CORE_ADDR best_low = (CORE_ADDR) -1;
4227
CORE_ADDR best_high = (CORE_ADDR) 0;
4228
CORE_ADDR current_low, current_high;
4230
if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
4232
best_low = current_low;
4233
best_high = current_high;
4237
struct die_info *child = die->child;
4239
while (child && child->tag)
4241
switch (child->tag) {
4242
case DW_TAG_subprogram:
4243
dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
4245
case DW_TAG_namespace:
4246
/* FIXME: carlton/2004-01-16: Should we do this for
4247
DW_TAG_class_type/DW_TAG_structure_type, too? I think
4248
that current GCC's always emit the DIEs corresponding
4249
to definitions of methods of classes as children of a
4250
DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
4251
the DIEs giving the declarations, which could be
4252
anywhere). But I don't see any reason why the
4253
standards says that they have to be there. */
4254
get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
4256
if (current_low != ((CORE_ADDR) -1))
4258
best_low = min (best_low, current_low);
4259
best_high = max (best_high, current_high);
4267
child = sibling_die (child);
4272
*highpc = best_high;
4275
/* Record the address ranges for BLOCK, offset by BASEADDR, as given
4278
dwarf2_record_block_ranges (struct die_info *die, struct block *block,
4279
CORE_ADDR baseaddr, struct dwarf2_cu *cu)
4281
struct attribute *attr;
4283
attr = dwarf2_attr (die, DW_AT_high_pc, cu);
4286
CORE_ADDR high = DW_ADDR (attr);
4287
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4290
CORE_ADDR low = DW_ADDR (attr);
4291
record_block_range (block, baseaddr + low, baseaddr + high - 1);
4295
attr = dwarf2_attr (die, DW_AT_ranges, cu);
4298
bfd *obfd = cu->objfile->obfd;
4300
/* The value of the DW_AT_ranges attribute is the offset of the
4301
address range list in the .debug_ranges section. */
4302
unsigned long offset = DW_UNSND (attr);
4303
gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset;
4305
/* For some target architectures, but not others, the
4306
read_address function sign-extends the addresses it returns.
4307
To recognize base address selection entries, we need a
4309
unsigned int addr_size = cu->header.addr_size;
4310
CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
4312
/* The base address, to which the next pair is relative. Note
4313
that this 'base' is a DWARF concept: most entries in a range
4314
list are relative, to reduce the number of relocs against the
4315
debugging information. This is separate from this function's
4316
'baseaddr' argument, which GDB uses to relocate debugging
4317
information from a shared library based on the address at
4318
which the library was loaded. */
4319
CORE_ADDR base = cu->base_address;
4320
int base_known = cu->base_known;
4322
if (offset >= dwarf2_per_objfile->ranges.size)
4324
complaint (&symfile_complaints,
4325
_("Offset %lu out of bounds for DW_AT_ranges attribute"),
4332
unsigned int bytes_read;
4333
CORE_ADDR start, end;
4335
start = read_address (obfd, buffer, cu, &bytes_read);
4336
buffer += bytes_read;
4337
end = read_address (obfd, buffer, cu, &bytes_read);
4338
buffer += bytes_read;
4340
/* Did we find the end of the range list? */
4341
if (start == 0 && end == 0)
4344
/* Did we find a base address selection entry? */
4345
else if ((start & base_select_mask) == base_select_mask)
4351
/* We found an ordinary address range. */
4356
complaint (&symfile_complaints,
4357
_("Invalid .debug_ranges data (no base address)"));
4361
record_block_range (block,
4362
baseaddr + base + start,
4363
baseaddr + base + end - 1);
4369
/* Add an aggregate field to the field list. */
4372
dwarf2_add_field (struct field_info *fip, struct die_info *die,
4373
struct dwarf2_cu *cu)
4375
struct objfile *objfile = cu->objfile;
4376
struct gdbarch *gdbarch = get_objfile_arch (objfile);
4377
struct nextfield *new_field;
4378
struct attribute *attr;
4380
char *fieldname = "";
4382
/* Allocate a new field list entry and link it in. */
4383
new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
4384
make_cleanup (xfree, new_field);
4385
memset (new_field, 0, sizeof (struct nextfield));
4387
if (die->tag == DW_TAG_inheritance)
4389
new_field->next = fip->baseclasses;
4390
fip->baseclasses = new_field;
4394
new_field->next = fip->fields;
4395
fip->fields = new_field;
4399
/* Handle accessibility and virtuality of field.
4400
The default accessibility for members is public, the default
4401
accessibility for inheritance is private. */
4402
if (die->tag != DW_TAG_inheritance)
4403
new_field->accessibility = DW_ACCESS_public;
4405
new_field->accessibility = DW_ACCESS_private;
4406
new_field->virtuality = DW_VIRTUALITY_none;
4408
attr = dwarf2_attr (die, DW_AT_accessibility, cu);
4410
new_field->accessibility = DW_UNSND (attr);
4411
if (new_field->accessibility != DW_ACCESS_public)
4412
fip->non_public_fields = 1;
4413
attr = dwarf2_attr (die, DW_AT_virtuality, cu);
4415
new_field->virtuality = DW_UNSND (attr);
4417
fp = &new_field->field;
4419
if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
4421
/* Data member other than a C++ static data member. */
4423
/* Get type of field. */
4424
fp->type = die_type (die, cu);
4426
SET_FIELD_BITPOS (*fp, 0);
4428
/* Get bit size of field (zero if none). */
4429
attr = dwarf2_attr (die, DW_AT_bit_size, cu);
4432
FIELD_BITSIZE (*fp) = DW_UNSND (attr);
4436
FIELD_BITSIZE (*fp) = 0;
4439
/* Get bit offset of field. */
4440
attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
4443
int byte_offset = 0;
4445
if (attr_form_is_section_offset (attr))
4446
dwarf2_complex_location_expr_complaint ();
4447
else if (attr_form_is_constant (attr))
4448
byte_offset = dwarf2_get_attr_constant_value (attr, 0);
4449
else if (attr_form_is_block (attr))
4450
byte_offset = decode_locdesc (DW_BLOCK (attr), cu);
4452
dwarf2_complex_location_expr_complaint ();
4454
SET_FIELD_BITPOS (*fp, byte_offset * bits_per_byte);
4456
attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
4459
if (gdbarch_bits_big_endian (gdbarch))
4461
/* For big endian bits, the DW_AT_bit_offset gives the
4462
additional bit offset from the MSB of the containing
4463
anonymous object to the MSB of the field. We don't
4464
have to do anything special since we don't need to
4465
know the size of the anonymous object. */
4466
FIELD_BITPOS (*fp) += DW_UNSND (attr);
4470
/* For little endian bits, compute the bit offset to the
4471
MSB of the anonymous object, subtract off the number of
4472
bits from the MSB of the field to the MSB of the
4473
object, and then subtract off the number of bits of
4474
the field itself. The result is the bit offset of
4475
the LSB of the field. */
4477
int bit_offset = DW_UNSND (attr);
4479
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4482
/* The size of the anonymous object containing
4483
the bit field is explicit, so use the
4484
indicated size (in bytes). */
4485
anonymous_size = DW_UNSND (attr);
4489
/* The size of the anonymous object containing
4490
the bit field must be inferred from the type
4491
attribute of the data member containing the
4493
anonymous_size = TYPE_LENGTH (fp->type);
4495
FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
4496
- bit_offset - FIELD_BITSIZE (*fp);
4500
/* Get name of field. */
4501
fieldname = dwarf2_name (die, cu);
4502
if (fieldname == NULL)
4505
/* The name is already allocated along with this objfile, so we don't
4506
need to duplicate it for the type. */
4507
fp->name = fieldname;
4509
/* Change accessibility for artificial fields (e.g. virtual table
4510
pointer or virtual base class pointer) to private. */
4511
if (dwarf2_attr (die, DW_AT_artificial, cu))
4513
FIELD_ARTIFICIAL (*fp) = 1;
4514
new_field->accessibility = DW_ACCESS_private;
4515
fip->non_public_fields = 1;
4518
else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
4520
/* C++ static member. */
4522
/* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
4523
is a declaration, but all versions of G++ as of this writing
4524
(so through at least 3.2.1) incorrectly generate
4525
DW_TAG_variable tags. */
4529
/* Get name of field. */
4530
fieldname = dwarf2_name (die, cu);
4531
if (fieldname == NULL)
4534
/* Get physical name. */
4535
physname = dwarf2_linkage_name (die, cu);
4537
/* The name is already allocated along with this objfile, so we don't
4538
need to duplicate it for the type. */
4539
SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
4540
FIELD_TYPE (*fp) = die_type (die, cu);
4541
FIELD_NAME (*fp) = fieldname;
4543
else if (die->tag == DW_TAG_inheritance)
4545
/* C++ base class field. */
4546
attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
4549
int byte_offset = 0;
4551
if (attr_form_is_section_offset (attr))
4552
dwarf2_complex_location_expr_complaint ();
4553
else if (attr_form_is_constant (attr))
4554
byte_offset = dwarf2_get_attr_constant_value (attr, 0);
4555
else if (attr_form_is_block (attr))
4556
byte_offset = decode_locdesc (DW_BLOCK (attr), cu);
4558
dwarf2_complex_location_expr_complaint ();
4560
SET_FIELD_BITPOS (*fp, byte_offset * bits_per_byte);
4562
FIELD_BITSIZE (*fp) = 0;
4563
FIELD_TYPE (*fp) = die_type (die, cu);
4564
FIELD_NAME (*fp) = type_name_no_tag (fp->type);
4565
fip->nbaseclasses++;
4569
/* Create the vector of fields, and attach it to the type. */
4572
dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
4573
struct dwarf2_cu *cu)
4575
int nfields = fip->nfields;
4577
/* Record the field count, allocate space for the array of fields,
4578
and create blank accessibility bitfields if necessary. */
4579
TYPE_NFIELDS (type) = nfields;
4580
TYPE_FIELDS (type) = (struct field *)
4581
TYPE_ALLOC (type, sizeof (struct field) * nfields);
4582
memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
4584
if (fip->non_public_fields && cu->language != language_ada)
4586
ALLOCATE_CPLUS_STRUCT_TYPE (type);
4588
TYPE_FIELD_PRIVATE_BITS (type) =
4589
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4590
B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
4592
TYPE_FIELD_PROTECTED_BITS (type) =
4593
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4594
B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
4596
TYPE_FIELD_IGNORE_BITS (type) =
4597
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4598
B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
4601
/* If the type has baseclasses, allocate and clear a bit vector for
4602
TYPE_FIELD_VIRTUAL_BITS. */
4603
if (fip->nbaseclasses && cu->language != language_ada)
4605
int num_bytes = B_BYTES (fip->nbaseclasses);
4606
unsigned char *pointer;
4608
ALLOCATE_CPLUS_STRUCT_TYPE (type);
4609
pointer = TYPE_ALLOC (type, num_bytes);
4610
TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
4611
B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
4612
TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
4615
/* Copy the saved-up fields into the field vector. Start from the head
4616
of the list, adding to the tail of the field array, so that they end
4617
up in the same order in the array in which they were added to the list. */
4618
while (nfields-- > 0)
4620
struct nextfield *fieldp;
4624
fieldp = fip->fields;
4625
fip->fields = fieldp->next;
4629
fieldp = fip->baseclasses;
4630
fip->baseclasses = fieldp->next;
4633
TYPE_FIELD (type, nfields) = fieldp->field;
4634
switch (fieldp->accessibility)
4636
case DW_ACCESS_private:
4637
if (cu->language != language_ada)
4638
SET_TYPE_FIELD_PRIVATE (type, nfields);
4641
case DW_ACCESS_protected:
4642
if (cu->language != language_ada)
4643
SET_TYPE_FIELD_PROTECTED (type, nfields);
4646
case DW_ACCESS_public:
4650
/* Unknown accessibility. Complain and treat it as public. */
4652
complaint (&symfile_complaints, _("unsupported accessibility %d"),
4653
fieldp->accessibility);
4657
if (nfields < fip->nbaseclasses)
4659
switch (fieldp->virtuality)
4661
case DW_VIRTUALITY_virtual:
4662
case DW_VIRTUALITY_pure_virtual:
4663
if (cu->language == language_ada)
4664
error ("unexpected virtuality in component of Ada type");
4665
SET_TYPE_FIELD_VIRTUAL (type, nfields);
4672
/* Add a member function to the proper fieldlist. */
4675
dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
4676
struct type *type, struct dwarf2_cu *cu)
4678
struct objfile *objfile = cu->objfile;
4679
struct attribute *attr;
4680
struct fnfieldlist *flp;
4682
struct fn_field *fnp;
4685
struct nextfnfield *new_fnfield;
4686
struct type *this_type;
4688
if (cu->language == language_ada)
4689
error ("unexpected member function in Ada type");
4691
/* Get name of member function. */
4692
fieldname = dwarf2_name (die, cu);
4693
if (fieldname == NULL)
4696
/* Get the mangled name. */
4697
physname = dwarf2_linkage_name (die, cu);
4699
/* Look up member function name in fieldlist. */
4700
for (i = 0; i < fip->nfnfields; i++)
4702
if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
4706
/* Create new list element if necessary. */
4707
if (i < fip->nfnfields)
4708
flp = &fip->fnfieldlists[i];
4711
if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
4713
fip->fnfieldlists = (struct fnfieldlist *)
4714
xrealloc (fip->fnfieldlists,
4715
(fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
4716
* sizeof (struct fnfieldlist));
4717
if (fip->nfnfields == 0)
4718
make_cleanup (free_current_contents, &fip->fnfieldlists);
4720
flp = &fip->fnfieldlists[fip->nfnfields];
4721
flp->name = fieldname;
4727
/* Create a new member function field and chain it to the field list
4729
new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
4730
make_cleanup (xfree, new_fnfield);
4731
memset (new_fnfield, 0, sizeof (struct nextfnfield));
4732
new_fnfield->next = flp->head;
4733
flp->head = new_fnfield;
4736
/* Fill in the member function field info. */
4737
fnp = &new_fnfield->fnfield;
4738
/* The name is already allocated along with this objfile, so we don't
4739
need to duplicate it for the type. */
4740
fnp->physname = physname ? physname : "";
4741
fnp->type = alloc_type (objfile);
4742
this_type = read_type_die (die, cu);
4743
if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
4745
int nparams = TYPE_NFIELDS (this_type);
4747
/* TYPE is the domain of this method, and THIS_TYPE is the type
4748
of the method itself (TYPE_CODE_METHOD). */
4749
smash_to_method_type (fnp->type, type,
4750
TYPE_TARGET_TYPE (this_type),
4751
TYPE_FIELDS (this_type),
4752
TYPE_NFIELDS (this_type),
4753
TYPE_VARARGS (this_type));
4755
/* Handle static member functions.
4756
Dwarf2 has no clean way to discern C++ static and non-static
4757
member functions. G++ helps GDB by marking the first
4758
parameter for non-static member functions (which is the
4759
this pointer) as artificial. We obtain this information
4760
from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
4761
if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
4762
fnp->voffset = VOFFSET_STATIC;
4765
complaint (&symfile_complaints, _("member function type missing for '%s'"),
4768
/* Get fcontext from DW_AT_containing_type if present. */
4769
if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
4770
fnp->fcontext = die_containing_type (die, cu);
4772
/* dwarf2 doesn't have stubbed physical names, so the setting of is_const
4773
and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
4775
/* Get accessibility. */
4776
attr = dwarf2_attr (die, DW_AT_accessibility, cu);
4779
switch (DW_UNSND (attr))
4781
case DW_ACCESS_private:
4782
fnp->is_private = 1;
4784
case DW_ACCESS_protected:
4785
fnp->is_protected = 1;
4790
/* Check for artificial methods. */
4791
attr = dwarf2_attr (die, DW_AT_artificial, cu);
4792
if (attr && DW_UNSND (attr) != 0)
4793
fnp->is_artificial = 1;
4795
/* Get index in virtual function table if it is a virtual member
4796
function. For GCC, this is an offset in the appropriate
4797
virtual table, as specified by DW_AT_containing_type. For
4798
everyone else, it is an expression to be evaluated relative
4799
to the object address. */
4801
attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
4802
if (attr && fnp->fcontext)
4804
/* Support the .debug_loc offsets */
4805
if (attr_form_is_block (attr))
4807
fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
4809
else if (attr_form_is_section_offset (attr))
4811
dwarf2_complex_location_expr_complaint ();
4815
dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
4821
/* We only support trivial expressions here. This hack will work
4822
for v3 classes, which always start with the vtable pointer. */
4823
if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0
4824
&& DW_BLOCK (attr)->data[0] == DW_OP_deref)
4826
struct dwarf_block blk;
4827
blk.size = DW_BLOCK (attr)->size - 1;
4828
blk.data = DW_BLOCK (attr)->data + 1;
4829
fnp->voffset = decode_locdesc (&blk, cu);
4830
if ((fnp->voffset % cu->header.addr_size) != 0)
4831
dwarf2_complex_location_expr_complaint ();
4833
fnp->voffset /= cu->header.addr_size;
4835
fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
4838
dwarf2_complex_location_expr_complaint ();
4842
attr = dwarf2_attr (die, DW_AT_virtuality, cu);
4843
if (attr && DW_UNSND (attr))
4845
/* GCC does this, as of 2008-08-25; PR debug/37237. */
4846
complaint (&symfile_complaints,
4847
_("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
4848
fieldname, die->offset);
4849
TYPE_CPLUS_DYNAMIC (type) = 1;
4854
/* Create the vector of member function fields, and attach it to the type. */
4857
dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
4858
struct dwarf2_cu *cu)
4860
struct fnfieldlist *flp;
4861
int total_length = 0;
4864
if (cu->language == language_ada)
4865
error ("unexpected member functions in Ada type");
4867
ALLOCATE_CPLUS_STRUCT_TYPE (type);
4868
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
4869
TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
4871
for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
4873
struct nextfnfield *nfp = flp->head;
4874
struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
4877
TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
4878
TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
4879
fn_flp->fn_fields = (struct fn_field *)
4880
TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
4881
for (k = flp->length; (k--, nfp); nfp = nfp->next)
4882
fn_flp->fn_fields[k] = nfp->fnfield;
4884
total_length += flp->length;
4887
TYPE_NFN_FIELDS (type) = fip->nfnfields;
4888
TYPE_NFN_FIELDS_TOTAL (type) = total_length;
4891
/* Returns non-zero if NAME is the name of a vtable member in CU's
4892
language, zero otherwise. */
4894
is_vtable_name (const char *name, struct dwarf2_cu *cu)
4896
static const char vptr[] = "_vptr";
4897
static const char vtable[] = "vtable";
4899
/* Look for the C++ and Java forms of the vtable. */
4900
if ((cu->language == language_java
4901
&& strncmp (name, vtable, sizeof (vtable) - 1) == 0)
4902
|| (strncmp (name, vptr, sizeof (vptr) - 1) == 0
4903
&& is_cplus_marker (name[sizeof (vptr) - 1])))
4909
/* GCC outputs unnamed structures that are really pointers to member
4910
functions, with the ABI-specified layout. If TYPE describes
4911
such a structure, smash it into a member function type.
4913
GCC shouldn't do this; it should just output pointer to member DIEs.
4914
This is GCC PR debug/28767. */
4917
quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
4919
struct type *pfn_type, *domain_type, *new_type;
4921
/* Check for a structure with no name and two children. */
4922
if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
4925
/* Check for __pfn and __delta members. */
4926
if (TYPE_FIELD_NAME (type, 0) == NULL
4927
|| strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
4928
|| TYPE_FIELD_NAME (type, 1) == NULL
4929
|| strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
4932
/* Find the type of the method. */
4933
pfn_type = TYPE_FIELD_TYPE (type, 0);
4934
if (pfn_type == NULL
4935
|| TYPE_CODE (pfn_type) != TYPE_CODE_PTR
4936
|| TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
4939
/* Look for the "this" argument. */
4940
pfn_type = TYPE_TARGET_TYPE (pfn_type);
4941
if (TYPE_NFIELDS (pfn_type) == 0
4942
/* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
4943
|| TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
4946
domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
4947
new_type = alloc_type (objfile);
4948
smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
4949
TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
4950
TYPE_VARARGS (pfn_type));
4951
smash_to_methodptr_type (type, new_type);
4954
/* Called when we find the DIE that starts a structure or union scope
4955
(definition) to process all dies that define the members of the
4958
NOTE: we need to call struct_type regardless of whether or not the
4959
DIE has an at_name attribute, since it might be an anonymous
4960
structure or union. This gets the type entered into our set of
4963
However, if the structure is incomplete (an opaque struct/union)
4964
then suppress creating a symbol table entry for it since gdb only
4965
wants to find the one with the complete definition. Note that if
4966
it is complete, we just call new_symbol, which does it's own
4967
checking about whether the struct/union is anonymous or not (and
4968
suppresses creating a symbol table entry itself). */
4970
static struct type *
4971
read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
4973
struct objfile *objfile = cu->objfile;
4975
struct attribute *attr;
4977
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4979
/* If the definition of this type lives in .debug_types, read that type.
4980
Don't follow DW_AT_specification though, that will take us back up
4981
the chain and we want to go down. */
4982
attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
4985
struct dwarf2_cu *type_cu = cu;
4986
struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
4987
/* We could just recurse on read_structure_type, but we need to call
4988
get_die_type to ensure only one type for this DIE is created.
4989
This is important, for example, because for c++ classes we need
4990
TYPE_NAME set which is only done by new_symbol. Blech. */
4991
type = read_type_die (type_die, type_cu);
4992
return set_die_type (die, type, cu);
4995
type = alloc_type (objfile);
4996
INIT_CPLUS_SPECIFIC (type);
4998
name = dwarf2_name (die, cu);
5001
if (cu->language == language_cplus
5002
|| cu->language == language_java)
5004
const char *new_prefix = determine_class_name (die, cu);
5005
TYPE_TAG_NAME (type) = (char *) new_prefix;
5009
/* The name is already allocated along with this objfile, so
5010
we don't need to duplicate it for the type. */
5011
TYPE_TAG_NAME (type) = name;
5015
if (die->tag == DW_TAG_structure_type)
5017
TYPE_CODE (type) = TYPE_CODE_STRUCT;
5019
else if (die->tag == DW_TAG_union_type)
5021
TYPE_CODE (type) = TYPE_CODE_UNION;
5025
TYPE_CODE (type) = TYPE_CODE_CLASS;
5028
if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
5029
TYPE_DECLARED_CLASS (type) = 1;
5031
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5034
TYPE_LENGTH (type) = DW_UNSND (attr);
5038
TYPE_LENGTH (type) = 0;
5041
TYPE_STUB_SUPPORTED (type) = 1;
5042
if (die_is_declaration (die, cu))
5043
TYPE_STUB (type) = 1;
5045
set_descriptive_type (type, die, cu);
5047
/* We need to add the type field to the die immediately so we don't
5048
infinitely recurse when dealing with pointers to the structure
5049
type within the structure itself. */
5050
set_die_type (die, type, cu);
5052
if (die->child != NULL && ! die_is_declaration (die, cu))
5054
struct field_info fi;
5055
struct die_info *child_die;
5057
memset (&fi, 0, sizeof (struct field_info));
5059
child_die = die->child;
5061
while (child_die && child_die->tag)
5063
if (child_die->tag == DW_TAG_member
5064
|| child_die->tag == DW_TAG_variable)
5066
/* NOTE: carlton/2002-11-05: A C++ static data member
5067
should be a DW_TAG_member that is a declaration, but
5068
all versions of G++ as of this writing (so through at
5069
least 3.2.1) incorrectly generate DW_TAG_variable
5070
tags for them instead. */
5071
dwarf2_add_field (&fi, child_die, cu);
5073
else if (child_die->tag == DW_TAG_subprogram)
5075
/* C++ member function. */
5076
dwarf2_add_member_fn (&fi, child_die, type, cu);
5078
else if (child_die->tag == DW_TAG_inheritance)
5080
/* C++ base class field. */
5081
dwarf2_add_field (&fi, child_die, cu);
5083
child_die = sibling_die (child_die);
5086
/* Attach fields and member functions to the type. */
5088
dwarf2_attach_fields_to_type (&fi, type, cu);
5091
dwarf2_attach_fn_fields_to_type (&fi, type, cu);
5093
/* Get the type which refers to the base class (possibly this
5094
class itself) which contains the vtable pointer for the current
5095
class from the DW_AT_containing_type attribute. This use of
5096
DW_AT_containing_type is a GNU extension. */
5098
if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
5100
struct type *t = die_containing_type (die, cu);
5102
TYPE_VPTR_BASETYPE (type) = t;
5107
/* Our own class provides vtbl ptr. */
5108
for (i = TYPE_NFIELDS (t) - 1;
5109
i >= TYPE_N_BASECLASSES (t);
5112
char *fieldname = TYPE_FIELD_NAME (t, i);
5114
if (is_vtable_name (fieldname, cu))
5116
TYPE_VPTR_FIELDNO (type) = i;
5121
/* Complain if virtual function table field not found. */
5122
if (i < TYPE_N_BASECLASSES (t))
5123
complaint (&symfile_complaints,
5124
_("virtual function table pointer not found when defining class '%s'"),
5125
TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
5130
TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
5133
else if (cu->producer
5134
&& strncmp (cu->producer,
5135
"IBM(R) XL C/C++ Advanced Edition", 32) == 0)
5137
/* The IBM XLC compiler does not provide direct indication
5138
of the containing type, but the vtable pointer is
5139
always named __vfp. */
5143
for (i = TYPE_NFIELDS (type) - 1;
5144
i >= TYPE_N_BASECLASSES (type);
5147
if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
5149
TYPE_VPTR_FIELDNO (type) = i;
5150
TYPE_VPTR_BASETYPE (type) = type;
5158
quirk_gcc_member_function_pointer (type, cu->objfile);
5160
do_cleanups (back_to);
5165
process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
5167
struct objfile *objfile = cu->objfile;
5168
struct die_info *child_die = die->child;
5169
struct type *this_type;
5171
this_type = get_die_type (die, cu);
5172
if (this_type == NULL)
5173
this_type = read_structure_type (die, cu);
5175
/* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
5176
snapshots) has been known to create a die giving a declaration
5177
for a class that has, as a child, a die giving a definition for a
5178
nested class. So we have to process our children even if the
5179
current die is a declaration. Normally, of course, a declaration
5180
won't have any children at all. */
5182
while (child_die != NULL && child_die->tag)
5184
if (child_die->tag == DW_TAG_member
5185
|| child_die->tag == DW_TAG_variable
5186
|| child_die->tag == DW_TAG_inheritance)
5191
process_die (child_die, cu);
5193
child_die = sibling_die (child_die);
5196
/* Do not consider external references. According to the DWARF standard,
5197
these DIEs are identified by the fact that they have no byte_size
5198
attribute, and a declaration attribute. */
5199
if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
5200
|| !die_is_declaration (die, cu))
5201
new_symbol (die, this_type, cu);
5204
/* Given a DW_AT_enumeration_type die, set its type. We do not
5205
complete the type's fields yet, or create any symbols. */
5207
static struct type *
5208
read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
5210
struct objfile *objfile = cu->objfile;
5212
struct attribute *attr;
5215
/* If the definition of this type lives in .debug_types, read that type.
5216
Don't follow DW_AT_specification though, that will take us back up
5217
the chain and we want to go down. */
5218
attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
5221
struct dwarf2_cu *type_cu = cu;
5222
struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
5223
type = read_type_die (type_die, type_cu);
5224
return set_die_type (die, type, cu);
5227
type = alloc_type (objfile);
5229
TYPE_CODE (type) = TYPE_CODE_ENUM;
5230
name = dwarf2_full_name (die, cu);
5232
TYPE_TAG_NAME (type) = (char *) name;
5234
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5237
TYPE_LENGTH (type) = DW_UNSND (attr);
5241
TYPE_LENGTH (type) = 0;
5244
/* The enumeration DIE can be incomplete. In Ada, any type can be
5245
declared as private in the package spec, and then defined only
5246
inside the package body. Such types are known as Taft Amendment
5247
Types. When another package uses such a type, an incomplete DIE
5248
may be generated by the compiler. */
5249
if (die_is_declaration (die, cu))
5250
TYPE_STUB (type) = 1;
5252
return set_die_type (die, type, cu);
5255
/* Determine the name of the type represented by DIE, which should be
5256
a named C++ or Java compound type. Return the name in question,
5257
allocated on the objfile obstack. */
5260
determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
5262
const char *new_prefix = NULL;
5264
/* If we don't have namespace debug info, guess the name by trying
5265
to demangle the names of members, just like we did in
5266
guess_structure_name. */
5267
if (!processing_has_namespace_info)
5269
struct die_info *child;
5271
for (child = die->child;
5272
child != NULL && child->tag != 0;
5273
child = sibling_die (child))
5275
if (child->tag == DW_TAG_subprogram)
5278
= language_class_name_from_physname (cu->language_defn,
5282
if (phys_prefix != NULL)
5285
= obsavestring (phys_prefix, strlen (phys_prefix),
5286
&cu->objfile->objfile_obstack);
5287
xfree (phys_prefix);
5294
if (new_prefix == NULL)
5295
new_prefix = dwarf2_full_name (die, cu);
5300
/* Given a pointer to a die which begins an enumeration, process all
5301
the dies that define the members of the enumeration, and create the
5302
symbol for the enumeration type.
5304
NOTE: We reverse the order of the element list. */
5307
process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
5309
struct objfile *objfile = cu->objfile;
5310
struct die_info *child_die;
5311
struct field *fields;
5314
int unsigned_enum = 1;
5316
struct type *this_type;
5320
this_type = get_die_type (die, cu);
5321
if (this_type == NULL)
5322
this_type = read_enumeration_type (die, cu);
5323
if (die->child != NULL)
5325
child_die = die->child;
5326
while (child_die && child_die->tag)
5328
if (child_die->tag != DW_TAG_enumerator)
5330
process_die (child_die, cu);
5334
name = dwarf2_name (child_die, cu);
5337
sym = new_symbol (child_die, this_type, cu);
5338
if (SYMBOL_VALUE (sym) < 0)
5341
if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
5343
fields = (struct field *)
5345
(num_fields + DW_FIELD_ALLOC_CHUNK)
5346
* sizeof (struct field));
5349
FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
5350
FIELD_TYPE (fields[num_fields]) = NULL;
5351
SET_FIELD_BITPOS (fields[num_fields], SYMBOL_VALUE (sym));
5352
FIELD_BITSIZE (fields[num_fields]) = 0;
5358
child_die = sibling_die (child_die);
5363
TYPE_NFIELDS (this_type) = num_fields;
5364
TYPE_FIELDS (this_type) = (struct field *)
5365
TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
5366
memcpy (TYPE_FIELDS (this_type), fields,
5367
sizeof (struct field) * num_fields);
5371
TYPE_UNSIGNED (this_type) = 1;
5374
new_symbol (die, this_type, cu);
5377
/* Extract all information from a DW_TAG_array_type DIE and put it in
5378
the DIE's type field. For now, this only handles one dimensional
5381
static struct type *
5382
read_array_type (struct die_info *die, struct dwarf2_cu *cu)
5384
struct objfile *objfile = cu->objfile;
5385
struct die_info *child_die;
5386
struct type *type = NULL;
5387
struct type *element_type, *range_type, *index_type;
5388
struct type **range_types = NULL;
5389
struct attribute *attr;
5391
struct cleanup *back_to;
5394
element_type = die_type (die, cu);
5396
/* Irix 6.2 native cc creates array types without children for
5397
arrays with unspecified length. */
5398
if (die->child == NULL)
5400
index_type = objfile_type (objfile)->builtin_int;
5401
range_type = create_range_type (NULL, index_type, 0, -1);
5402
type = create_array_type (NULL, element_type, range_type);
5403
return set_die_type (die, type, cu);
5406
back_to = make_cleanup (null_cleanup, NULL);
5407
child_die = die->child;
5408
while (child_die && child_die->tag)
5410
if (child_die->tag == DW_TAG_subrange_type)
5412
struct type *child_type = read_type_die (child_die, cu);
5413
if (child_type != NULL)
5415
/* The range type was succesfully read. Save it for
5416
the array type creation. */
5417
if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
5419
range_types = (struct type **)
5420
xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
5421
* sizeof (struct type *));
5423
make_cleanup (free_current_contents, &range_types);
5425
range_types[ndim++] = child_type;
5428
child_die = sibling_die (child_die);
5431
/* Dwarf2 dimensions are output from left to right, create the
5432
necessary array types in backwards order. */
5434
type = element_type;
5436
if (read_array_order (die, cu) == DW_ORD_col_major)
5440
type = create_array_type (NULL, type, range_types[i++]);
5445
type = create_array_type (NULL, type, range_types[ndim]);
5448
/* Understand Dwarf2 support for vector types (like they occur on
5449
the PowerPC w/ AltiVec). Gcc just adds another attribute to the
5450
array type. This is not part of the Dwarf2/3 standard yet, but a
5451
custom vendor extension. The main difference between a regular
5452
array and the vector variant is that vectors are passed by value
5454
attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
5456
make_vector_type (type);
5458
name = dwarf2_name (die, cu);
5460
TYPE_NAME (type) = name;
5462
set_descriptive_type (type, die, cu);
5464
do_cleanups (back_to);
5466
/* Install the type in the die. */
5467
return set_die_type (die, type, cu);
5470
static enum dwarf_array_dim_ordering
5471
read_array_order (struct die_info *die, struct dwarf2_cu *cu)
5473
struct attribute *attr;
5475
attr = dwarf2_attr (die, DW_AT_ordering, cu);
5477
if (attr) return DW_SND (attr);
5480
GNU F77 is a special case, as at 08/2004 array type info is the
5481
opposite order to the dwarf2 specification, but data is still
5482
laid out as per normal fortran.
5484
FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
5488
if (cu->language == language_fortran
5489
&& cu->producer && strstr (cu->producer, "GNU F77"))
5491
return DW_ORD_row_major;
5494
switch (cu->language_defn->la_array_ordering)
5496
case array_column_major:
5497
return DW_ORD_col_major;
5498
case array_row_major:
5500
return DW_ORD_row_major;
5504
/* Extract all information from a DW_TAG_set_type DIE and put it in
5505
the DIE's type field. */
5507
static struct type *
5508
read_set_type (struct die_info *die, struct dwarf2_cu *cu)
5510
struct type *set_type = create_set_type (NULL, die_type (die, cu));
5512
return set_die_type (die, set_type, cu);
5515
/* First cut: install each common block member as a global variable. */
5518
read_common_block (struct die_info *die, struct dwarf2_cu *cu)
5520
struct die_info *child_die;
5521
struct attribute *attr;
5523
CORE_ADDR base = (CORE_ADDR) 0;
5525
attr = dwarf2_attr (die, DW_AT_location, cu);
5528
/* Support the .debug_loc offsets */
5529
if (attr_form_is_block (attr))
5531
base = decode_locdesc (DW_BLOCK (attr), cu);
5533
else if (attr_form_is_section_offset (attr))
5535
dwarf2_complex_location_expr_complaint ();
5539
dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5540
"common block member");
5543
if (die->child != NULL)
5545
child_die = die->child;
5546
while (child_die && child_die->tag)
5548
sym = new_symbol (child_die, NULL, cu);
5549
attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
5552
CORE_ADDR byte_offset = 0;
5554
if (attr_form_is_section_offset (attr))
5555
dwarf2_complex_location_expr_complaint ();
5556
else if (attr_form_is_constant (attr))
5557
byte_offset = dwarf2_get_attr_constant_value (attr, 0);
5558
else if (attr_form_is_block (attr))
5559
byte_offset = decode_locdesc (DW_BLOCK (attr), cu);
5561
dwarf2_complex_location_expr_complaint ();
5563
SYMBOL_VALUE_ADDRESS (sym) = base + byte_offset;
5564
add_symbol_to_list (sym, &global_symbols);
5566
child_die = sibling_die (child_die);
5571
/* Create a type for a C++ namespace. */
5573
static struct type *
5574
read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
5576
struct objfile *objfile = cu->objfile;
5577
const char *previous_prefix, *name;
5581
/* For extensions, reuse the type of the original namespace. */
5582
if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
5584
struct die_info *ext_die;
5585
struct dwarf2_cu *ext_cu = cu;
5586
ext_die = dwarf2_extension (die, &ext_cu);
5587
type = read_type_die (ext_die, ext_cu);
5588
return set_die_type (die, type, cu);
5591
name = namespace_name (die, &is_anonymous, cu);
5593
/* Now build the name of the current namespace. */
5595
previous_prefix = determine_prefix (die, cu);
5596
if (previous_prefix[0] != '\0')
5597
name = typename_concat (&objfile->objfile_obstack,
5598
previous_prefix, name, cu);
5600
/* Create the type. */
5601
type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
5603
TYPE_NAME (type) = (char *) name;
5604
TYPE_TAG_NAME (type) = TYPE_NAME (type);
5606
set_die_type (die, type, cu);
5611
/* Read a C++ namespace. */
5614
read_namespace (struct die_info *die, struct dwarf2_cu *cu)
5616
struct objfile *objfile = cu->objfile;
5620
/* Add a symbol associated to this if we haven't seen the namespace
5621
before. Also, add a using directive if it's an anonymous
5624
if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
5628
type = read_type_die (die, cu);
5629
new_symbol (die, type, cu);
5631
name = namespace_name (die, &is_anonymous, cu);
5634
const char *previous_prefix = determine_prefix (die, cu);
5635
cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL);
5639
if (die->child != NULL)
5641
struct die_info *child_die = die->child;
5643
while (child_die && child_die->tag)
5645
process_die (child_die, cu);
5646
child_die = sibling_die (child_die);
5651
/* Read a Fortran module. */
5654
read_module (struct die_info *die, struct dwarf2_cu *cu)
5656
struct die_info *child_die = die->child;
5658
/* FIXME: Support the separate Fortran module namespaces. */
5660
while (child_die && child_die->tag)
5662
process_die (child_die, cu);
5663
child_die = sibling_die (child_die);
5667
/* Return the name of the namespace represented by DIE. Set
5668
*IS_ANONYMOUS to tell whether or not the namespace is an anonymous
5672
namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
5674
struct die_info *current_die;
5675
const char *name = NULL;
5677
/* Loop through the extensions until we find a name. */
5679
for (current_die = die;
5680
current_die != NULL;
5681
current_die = dwarf2_extension (die, &cu))
5683
name = dwarf2_name (current_die, cu);
5688
/* Is it an anonymous namespace? */
5690
*is_anonymous = (name == NULL);
5692
name = "(anonymous namespace)";
5697
/* Extract all information from a DW_TAG_pointer_type DIE and add to
5698
the user defined type vector. */
5700
static struct type *
5701
read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
5703
struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
5704
struct comp_unit_head *cu_header = &cu->header;
5706
struct attribute *attr_byte_size;
5707
struct attribute *attr_address_class;
5708
int byte_size, addr_class;
5710
type = lookup_pointer_type (die_type (die, cu));
5712
attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
5714
byte_size = DW_UNSND (attr_byte_size);
5716
byte_size = cu_header->addr_size;
5718
attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
5719
if (attr_address_class)
5720
addr_class = DW_UNSND (attr_address_class);
5722
addr_class = DW_ADDR_none;
5724
/* If the pointer size or address class is different than the
5725
default, create a type variant marked as such and set the
5726
length accordingly. */
5727
if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
5729
if (gdbarch_address_class_type_flags_p (gdbarch))
5733
type_flags = gdbarch_address_class_type_flags
5734
(gdbarch, byte_size, addr_class);
5735
gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
5737
type = make_type_with_address_space (type, type_flags);
5739
else if (TYPE_LENGTH (type) != byte_size)
5741
complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
5744
/* Should we also complain about unhandled address classes? */
5748
TYPE_LENGTH (type) = byte_size;
5749
return set_die_type (die, type, cu);
5752
/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
5753
the user defined type vector. */
5755
static struct type *
5756
read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
5758
struct objfile *objfile = cu->objfile;
5760
struct type *to_type;
5761
struct type *domain;
5763
to_type = die_type (die, cu);
5764
domain = die_containing_type (die, cu);
5766
if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
5767
type = lookup_methodptr_type (to_type);
5769
type = lookup_memberptr_type (to_type, domain);
5771
return set_die_type (die, type, cu);
5774
/* Extract all information from a DW_TAG_reference_type DIE and add to
5775
the user defined type vector. */
5777
static struct type *
5778
read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
5780
struct comp_unit_head *cu_header = &cu->header;
5782
struct attribute *attr;
5784
type = lookup_reference_type (die_type (die, cu));
5785
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5788
TYPE_LENGTH (type) = DW_UNSND (attr);
5792
TYPE_LENGTH (type) = cu_header->addr_size;
5794
return set_die_type (die, type, cu);
5797
static struct type *
5798
read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
5800
struct type *base_type, *cv_type;
5802
base_type = die_type (die, cu);
5803
cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
5804
return set_die_type (die, cv_type, cu);
5807
static struct type *
5808
read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
5810
struct type *base_type, *cv_type;
5812
base_type = die_type (die, cu);
5813
cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
5814
return set_die_type (die, cv_type, cu);
5817
/* Extract all information from a DW_TAG_string_type DIE and add to
5818
the user defined type vector. It isn't really a user defined type,
5819
but it behaves like one, with other DIE's using an AT_user_def_type
5820
attribute to reference it. */
5822
static struct type *
5823
read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
5825
struct objfile *objfile = cu->objfile;
5826
struct gdbarch *gdbarch = get_objfile_arch (objfile);
5827
struct type *type, *range_type, *index_type, *char_type;
5828
struct attribute *attr;
5829
unsigned int length;
5831
attr = dwarf2_attr (die, DW_AT_string_length, cu);
5834
length = DW_UNSND (attr);
5838
/* check for the DW_AT_byte_size attribute */
5839
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5842
length = DW_UNSND (attr);
5850
index_type = objfile_type (objfile)->builtin_int;
5851
range_type = create_range_type (NULL, index_type, 1, length);
5852
char_type = language_string_char_type (cu->language_defn, gdbarch);
5853
type = create_string_type (NULL, char_type, range_type);
5855
return set_die_type (die, type, cu);
5858
/* Handle DIES due to C code like:
5862
int (*funcp)(int a, long l);
5866
('funcp' generates a DW_TAG_subroutine_type DIE)
5869
static struct type *
5870
read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
5872
struct type *type; /* Type that this function returns */
5873
struct type *ftype; /* Function that returns above type */
5874
struct attribute *attr;
5876
type = die_type (die, cu);
5877
ftype = lookup_function_type (type);
5879
/* All functions in C++, Pascal and Java have prototypes. */
5880
attr = dwarf2_attr (die, DW_AT_prototyped, cu);
5881
if ((attr && (DW_UNSND (attr) != 0))
5882
|| cu->language == language_cplus
5883
|| cu->language == language_java
5884
|| cu->language == language_pascal)
5885
TYPE_PROTOTYPED (ftype) = 1;
5887
/* Store the calling convention in the type if it's available in
5888
the subroutine die. Otherwise set the calling convention to
5889
the default value DW_CC_normal. */
5890
attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
5891
TYPE_CALLING_CONVENTION (ftype) = attr ? DW_UNSND (attr) : DW_CC_normal;
5893
/* We need to add the subroutine type to the die immediately so
5894
we don't infinitely recurse when dealing with parameters
5895
declared as the same subroutine type. */
5896
set_die_type (die, ftype, cu);
5898
if (die->child != NULL)
5900
struct die_info *child_die;
5904
/* Count the number of parameters.
5905
FIXME: GDB currently ignores vararg functions, but knows about
5906
vararg member functions. */
5907
child_die = die->child;
5908
while (child_die && child_die->tag)
5910
if (child_die->tag == DW_TAG_formal_parameter)
5912
else if (child_die->tag == DW_TAG_unspecified_parameters)
5913
TYPE_VARARGS (ftype) = 1;
5914
child_die = sibling_die (child_die);
5917
/* Allocate storage for parameters and fill them in. */
5918
TYPE_NFIELDS (ftype) = nparams;
5919
TYPE_FIELDS (ftype) = (struct field *)
5920
TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
5922
child_die = die->child;
5923
while (child_die && child_die->tag)
5925
if (child_die->tag == DW_TAG_formal_parameter)
5927
/* Dwarf2 has no clean way to discern C++ static and non-static
5928
member functions. G++ helps GDB by marking the first
5929
parameter for non-static member functions (which is the
5930
this pointer) as artificial. We pass this information
5931
to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
5932
attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
5934
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
5936
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
5937
TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
5940
child_die = sibling_die (child_die);
5947
static struct type *
5948
read_typedef (struct die_info *die, struct dwarf2_cu *cu)
5950
struct objfile *objfile = cu->objfile;
5951
struct attribute *attr;
5952
const char *name = NULL;
5953
struct type *this_type;
5955
name = dwarf2_full_name (die, cu);
5956
this_type = init_type (TYPE_CODE_TYPEDEF, 0,
5957
TYPE_FLAG_TARGET_STUB, NULL, objfile);
5958
TYPE_NAME (this_type) = (char *) name;
5959
set_die_type (die, this_type, cu);
5960
TYPE_TARGET_TYPE (this_type) = die_type (die, cu);
5964
/* Find a representation of a given base type and install
5965
it in the TYPE field of the die. */
5967
static struct type *
5968
read_base_type (struct die_info *die, struct dwarf2_cu *cu)
5970
struct objfile *objfile = cu->objfile;
5972
struct attribute *attr;
5973
int encoding = 0, size = 0;
5975
enum type_code code = TYPE_CODE_INT;
5977
struct type *target_type = NULL;
5979
attr = dwarf2_attr (die, DW_AT_encoding, cu);
5982
encoding = DW_UNSND (attr);
5984
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5987
size = DW_UNSND (attr);
5989
name = dwarf2_name (die, cu);
5992
complaint (&symfile_complaints,
5993
_("DW_AT_name missing from DW_TAG_base_type"));
5998
case DW_ATE_address:
5999
/* Turn DW_ATE_address into a void * pointer. */
6000
code = TYPE_CODE_PTR;
6001
type_flags |= TYPE_FLAG_UNSIGNED;
6002
target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
6004
case DW_ATE_boolean:
6005
code = TYPE_CODE_BOOL;
6006
type_flags |= TYPE_FLAG_UNSIGNED;
6008
case DW_ATE_complex_float:
6009
code = TYPE_CODE_COMPLEX;
6010
target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
6012
case DW_ATE_decimal_float:
6013
code = TYPE_CODE_DECFLOAT;
6016
code = TYPE_CODE_FLT;
6020
case DW_ATE_unsigned:
6021
type_flags |= TYPE_FLAG_UNSIGNED;
6023
case DW_ATE_signed_char:
6024
if (cu->language == language_ada || cu->language == language_m2
6025
|| cu->language == language_pascal)
6026
code = TYPE_CODE_CHAR;
6028
case DW_ATE_unsigned_char:
6029
if (cu->language == language_ada || cu->language == language_m2
6030
|| cu->language == language_pascal)
6031
code = TYPE_CODE_CHAR;
6032
type_flags |= TYPE_FLAG_UNSIGNED;
6035
complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
6036
dwarf_type_encoding_name (encoding));
6040
type = init_type (code, size, type_flags, NULL, objfile);
6041
TYPE_NAME (type) = name;
6042
TYPE_TARGET_TYPE (type) = target_type;
6044
if (name && strcmp (name, "char") == 0)
6045
TYPE_NOSIGN (type) = 1;
6047
return set_die_type (die, type, cu);
6050
/* Read the given DW_AT_subrange DIE. */
6052
static struct type *
6053
read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
6055
struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
6056
struct type *base_type;
6057
struct type *range_type;
6058
struct attribute *attr;
6062
LONGEST negative_mask;
6064
base_type = die_type (die, cu);
6065
if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
6067
complaint (&symfile_complaints,
6068
_("DW_AT_type missing from DW_TAG_subrange_type"));
6070
= init_type (TYPE_CODE_INT, gdbarch_addr_bit (gdbarch) / 8,
6071
0, NULL, cu->objfile);
6074
if (cu->language == language_fortran)
6076
/* FORTRAN implies a lower bound of 1, if not given. */
6080
/* FIXME: For variable sized arrays either of these could be
6081
a variable rather than a constant value. We'll allow it,
6082
but we don't know how to handle it. */
6083
attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
6085
low = dwarf2_get_attr_constant_value (attr, 0);
6087
attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
6090
if (attr->form == DW_FORM_block1)
6092
/* GCC encodes arrays with unspecified or dynamic length
6093
with a DW_FORM_block1 attribute.
6094
FIXME: GDB does not yet know how to handle dynamic
6095
arrays properly, treat them as arrays with unspecified
6098
FIXME: jimb/2003-09-22: GDB does not really know
6099
how to handle arrays of unspecified length
6100
either; we just represent them as zero-length
6101
arrays. Choose an appropriate upper bound given
6102
the lower bound we've computed above. */
6106
high = dwarf2_get_attr_constant_value (attr, 1);
6110
(LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
6111
if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
6112
low |= negative_mask;
6113
if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
6114
high |= negative_mask;
6116
range_type = create_range_type (NULL, base_type, low, high);
6118
name = dwarf2_name (die, cu);
6120
TYPE_NAME (range_type) = name;
6122
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
6124
TYPE_LENGTH (range_type) = DW_UNSND (attr);
6126
set_descriptive_type (range_type, die, cu);
6128
return set_die_type (die, range_type, cu);
6131
static struct type *
6132
read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
6136
/* For now, we only support the C meaning of an unspecified type: void. */
6138
type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
6139
TYPE_NAME (type) = dwarf2_name (die, cu);
6141
return set_die_type (die, type, cu);
6144
/* Trivial hash function for die_info: the hash value of a DIE
6145
is its offset in .debug_info for this objfile. */
6148
die_hash (const void *item)
6150
const struct die_info *die = item;
6154
/* Trivial comparison function for die_info structures: two DIEs
6155
are equal if they have the same offset. */
6158
die_eq (const void *item_lhs, const void *item_rhs)
6160
const struct die_info *die_lhs = item_lhs;
6161
const struct die_info *die_rhs = item_rhs;
6162
return die_lhs->offset == die_rhs->offset;
6165
/* Read a whole compilation unit into a linked list of dies. */
6167
static struct die_info *
6168
read_comp_unit (gdb_byte *info_ptr, struct dwarf2_cu *cu)
6170
struct die_reader_specs reader_specs;
6172
gdb_assert (cu->die_hash == NULL);
6174
= htab_create_alloc_ex (cu->header.length / 12,
6178
&cu->comp_unit_obstack,
6179
hashtab_obstack_allocate,
6180
dummy_obstack_deallocate);
6182
init_cu_die_reader (&reader_specs, cu);
6184
return read_die_and_children (&reader_specs, info_ptr, &info_ptr, NULL);
6187
/* Main entry point for reading a DIE and all children.
6188
Read the DIE and dump it if requested. */
6190
static struct die_info *
6191
read_die_and_children (const struct die_reader_specs *reader,
6193
gdb_byte **new_info_ptr,
6194
struct die_info *parent)
6196
struct die_info *result = read_die_and_children_1 (reader, info_ptr,
6197
new_info_ptr, parent);
6199
if (dwarf2_die_debug)
6201
fprintf_unfiltered (gdb_stdlog,
6202
"\nRead die from %s of %s:\n",
6203
reader->buffer == dwarf2_per_objfile->info.buffer
6205
: reader->buffer == dwarf2_per_objfile->types.buffer
6207
: "unknown section",
6208
reader->abfd->filename);
6209
dump_die (result, dwarf2_die_debug);
6215
/* Read a single die and all its descendents. Set the die's sibling
6216
field to NULL; set other fields in the die correctly, and set all
6217
of the descendents' fields correctly. Set *NEW_INFO_PTR to the
6218
location of the info_ptr after reading all of those dies. PARENT
6219
is the parent of the die in question. */
6221
static struct die_info *
6222
read_die_and_children_1 (const struct die_reader_specs *reader,
6224
gdb_byte **new_info_ptr,
6225
struct die_info *parent)
6227
struct die_info *die;
6231
cur_ptr = read_full_die (reader, &die, info_ptr, &has_children);
6234
*new_info_ptr = cur_ptr;
6237
store_in_ref_table (die, reader->cu);
6240
die->child = read_die_and_siblings (reader, cur_ptr, new_info_ptr, die);
6244
*new_info_ptr = cur_ptr;
6247
die->sibling = NULL;
6248
die->parent = parent;
6252
/* Read a die, all of its descendents, and all of its siblings; set
6253
all of the fields of all of the dies correctly. Arguments are as
6254
in read_die_and_children. */
6256
static struct die_info *
6257
read_die_and_siblings (const struct die_reader_specs *reader,
6259
gdb_byte **new_info_ptr,
6260
struct die_info *parent)
6262
struct die_info *first_die, *last_sibling;
6266
first_die = last_sibling = NULL;
6270
struct die_info *die
6271
= read_die_and_children_1 (reader, cur_ptr, &cur_ptr, parent);
6275
*new_info_ptr = cur_ptr;
6282
last_sibling->sibling = die;
6288
/* Read the die from the .debug_info section buffer. Set DIEP to
6289
point to a newly allocated die with its information, except for its
6290
child, sibling, and parent fields. Set HAS_CHILDREN to tell
6291
whether the die has children or not. */
6294
read_full_die (const struct die_reader_specs *reader,
6295
struct die_info **diep, gdb_byte *info_ptr,
6298
unsigned int abbrev_number, bytes_read, i, offset;
6299
struct abbrev_info *abbrev;
6300
struct die_info *die;
6301
struct dwarf2_cu *cu = reader->cu;
6302
bfd *abfd = reader->abfd;
6304
offset = info_ptr - reader->buffer;
6305
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
6306
info_ptr += bytes_read;
6314
abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
6316
error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6318
bfd_get_filename (abfd));
6320
die = dwarf_alloc_die (cu, abbrev->num_attrs);
6321
die->offset = offset;
6322
die->tag = abbrev->tag;
6323
die->abbrev = abbrev_number;
6325
die->num_attrs = abbrev->num_attrs;
6327
for (i = 0; i < abbrev->num_attrs; ++i)
6328
info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
6329
abfd, info_ptr, cu);
6332
*has_children = abbrev->has_children;
6336
/* In DWARF version 2, the description of the debugging information is
6337
stored in a separate .debug_abbrev section. Before we read any
6338
dies from a section we read in all abbreviations and install them
6339
in a hash table. This function also sets flags in CU describing
6340
the data found in the abbrev table. */
6343
dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
6345
struct comp_unit_head *cu_header = &cu->header;
6346
gdb_byte *abbrev_ptr;
6347
struct abbrev_info *cur_abbrev;
6348
unsigned int abbrev_number, bytes_read, abbrev_name;
6349
unsigned int abbrev_form, hash_number;
6350
struct attr_abbrev *cur_attrs;
6351
unsigned int allocated_attrs;
6353
/* Initialize dwarf2 abbrevs */
6354
obstack_init (&cu->abbrev_obstack);
6355
cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
6357
* sizeof (struct abbrev_info *)));
6358
memset (cu->dwarf2_abbrevs, 0,
6359
ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
6361
abbrev_ptr = dwarf2_per_objfile->abbrev.buffer + cu_header->abbrev_offset;
6362
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6363
abbrev_ptr += bytes_read;
6365
allocated_attrs = ATTR_ALLOC_CHUNK;
6366
cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
6368
/* loop until we reach an abbrev number of 0 */
6369
while (abbrev_number)
6371
cur_abbrev = dwarf_alloc_abbrev (cu);
6373
/* read in abbrev header */
6374
cur_abbrev->number = abbrev_number;
6375
cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6376
abbrev_ptr += bytes_read;
6377
cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
6380
if (cur_abbrev->tag == DW_TAG_namespace)
6381
cu->has_namespace_info = 1;
6383
/* now read in declarations */
6384
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6385
abbrev_ptr += bytes_read;
6386
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6387
abbrev_ptr += bytes_read;
6390
if (cur_abbrev->num_attrs == allocated_attrs)
6392
allocated_attrs += ATTR_ALLOC_CHUNK;
6394
= xrealloc (cur_attrs, (allocated_attrs
6395
* sizeof (struct attr_abbrev)));
6398
/* Record whether this compilation unit might have
6399
inter-compilation-unit references. If we don't know what form
6400
this attribute will have, then it might potentially be a
6401
DW_FORM_ref_addr, so we conservatively expect inter-CU
6404
if (abbrev_form == DW_FORM_ref_addr
6405
|| abbrev_form == DW_FORM_indirect)
6406
cu->has_form_ref_addr = 1;
6408
cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
6409
cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
6410
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6411
abbrev_ptr += bytes_read;
6412
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6413
abbrev_ptr += bytes_read;
6416
cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
6417
(cur_abbrev->num_attrs
6418
* sizeof (struct attr_abbrev)));
6419
memcpy (cur_abbrev->attrs, cur_attrs,
6420
cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
6422
hash_number = abbrev_number % ABBREV_HASH_SIZE;
6423
cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
6424
cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
6426
/* Get next abbreviation.
6427
Under Irix6 the abbreviations for a compilation unit are not
6428
always properly terminated with an abbrev number of 0.
6429
Exit loop if we encounter an abbreviation which we have
6430
already read (which means we are about to read the abbreviations
6431
for the next compile unit) or if the end of the abbreviation
6432
table is reached. */
6433
if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev.buffer)
6434
>= dwarf2_per_objfile->abbrev.size)
6436
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
6437
abbrev_ptr += bytes_read;
6438
if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
6445
/* Release the memory used by the abbrev table for a compilation unit. */
6448
dwarf2_free_abbrev_table (void *ptr_to_cu)
6450
struct dwarf2_cu *cu = ptr_to_cu;
6452
obstack_free (&cu->abbrev_obstack, NULL);
6453
cu->dwarf2_abbrevs = NULL;
6456
/* Lookup an abbrev_info structure in the abbrev hash table. */
6458
static struct abbrev_info *
6459
dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
6461
unsigned int hash_number;
6462
struct abbrev_info *abbrev;
6464
hash_number = number % ABBREV_HASH_SIZE;
6465
abbrev = cu->dwarf2_abbrevs[hash_number];
6469
if (abbrev->number == number)
6472
abbrev = abbrev->next;
6477
/* Returns nonzero if TAG represents a type that we might generate a partial
6481
is_type_tag_for_partial (int tag)
6486
/* Some types that would be reasonable to generate partial symbols for,
6487
that we don't at present. */
6488
case DW_TAG_array_type:
6489
case DW_TAG_file_type:
6490
case DW_TAG_ptr_to_member_type:
6491
case DW_TAG_set_type:
6492
case DW_TAG_string_type:
6493
case DW_TAG_subroutine_type:
6495
case DW_TAG_base_type:
6496
case DW_TAG_class_type:
6497
case DW_TAG_interface_type:
6498
case DW_TAG_enumeration_type:
6499
case DW_TAG_structure_type:
6500
case DW_TAG_subrange_type:
6501
case DW_TAG_typedef:
6502
case DW_TAG_union_type:
6509
/* Load all DIEs that are interesting for partial symbols into memory. */
6511
static struct partial_die_info *
6512
load_partial_dies (bfd *abfd, gdb_byte *buffer, gdb_byte *info_ptr,
6513
int building_psymtab, struct dwarf2_cu *cu)
6515
struct partial_die_info *part_die;
6516
struct partial_die_info *parent_die, *last_die, *first_die = NULL;
6517
struct abbrev_info *abbrev;
6518
unsigned int bytes_read;
6519
unsigned int load_all = 0;
6521
int nesting_level = 1;
6526
if (cu->per_cu && cu->per_cu->load_all_dies)
6530
= htab_create_alloc_ex (cu->header.length / 12,
6534
&cu->comp_unit_obstack,
6535
hashtab_obstack_allocate,
6536
dummy_obstack_deallocate);
6538
part_die = obstack_alloc (&cu->comp_unit_obstack,
6539
sizeof (struct partial_die_info));
6543
abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
6545
/* A NULL abbrev means the end of a series of children. */
6548
if (--nesting_level == 0)
6550
/* PART_DIE was probably the last thing allocated on the
6551
comp_unit_obstack, so we could call obstack_free
6552
here. We don't do that because the waste is small,
6553
and will be cleaned up when we're done with this
6554
compilation unit. This way, we're also more robust
6555
against other users of the comp_unit_obstack. */
6558
info_ptr += bytes_read;
6559
last_die = parent_die;
6560
parent_die = parent_die->die_parent;
6564
/* Check whether this DIE is interesting enough to save. Normally
6565
we would not be interested in members here, but there may be
6566
later variables referencing them via DW_AT_specification (for
6569
&& !is_type_tag_for_partial (abbrev->tag)
6570
&& abbrev->tag != DW_TAG_enumerator
6571
&& abbrev->tag != DW_TAG_subprogram
6572
&& abbrev->tag != DW_TAG_lexical_block
6573
&& abbrev->tag != DW_TAG_variable
6574
&& abbrev->tag != DW_TAG_namespace
6575
&& abbrev->tag != DW_TAG_member)
6577
/* Otherwise we skip to the next sibling, if any. */
6578
info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
6582
info_ptr = read_partial_die (part_die, abbrev, bytes_read, abfd,
6583
buffer, info_ptr, cu);
6585
/* This two-pass algorithm for processing partial symbols has a
6586
high cost in cache pressure. Thus, handle some simple cases
6587
here which cover the majority of C partial symbols. DIEs
6588
which neither have specification tags in them, nor could have
6589
specification tags elsewhere pointing at them, can simply be
6590
processed and discarded.
6592
This segment is also optional; scan_partial_symbols and
6593
add_partial_symbol will handle these DIEs if we chain
6594
them in normally. When compilers which do not emit large
6595
quantities of duplicate debug information are more common,
6596
this code can probably be removed. */
6598
/* Any complete simple types at the top level (pretty much all
6599
of them, for a language without namespaces), can be processed
6601
if (parent_die == NULL
6602
&& part_die->has_specification == 0
6603
&& part_die->is_declaration == 0
6604
&& (part_die->tag == DW_TAG_typedef
6605
|| part_die->tag == DW_TAG_base_type
6606
|| part_die->tag == DW_TAG_subrange_type))
6608
if (building_psymtab && part_die->name != NULL)
6609
add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
6610
VAR_DOMAIN, LOC_TYPEDEF,
6611
&cu->objfile->static_psymbols,
6612
0, (CORE_ADDR) 0, cu->language, cu->objfile);
6613
info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
6617
/* If we're at the second level, and we're an enumerator, and
6618
our parent has no specification (meaning possibly lives in a
6619
namespace elsewhere), then we can add the partial symbol now
6620
instead of queueing it. */
6621
if (part_die->tag == DW_TAG_enumerator
6622
&& parent_die != NULL
6623
&& parent_die->die_parent == NULL
6624
&& parent_die->tag == DW_TAG_enumeration_type
6625
&& parent_die->has_specification == 0)
6627
if (part_die->name == NULL)
6628
complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
6629
else if (building_psymtab)
6630
add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
6631
VAR_DOMAIN, LOC_CONST,
6632
(cu->language == language_cplus
6633
|| cu->language == language_java)
6634
? &cu->objfile->global_psymbols
6635
: &cu->objfile->static_psymbols,
6636
0, (CORE_ADDR) 0, cu->language, cu->objfile);
6638
info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
6642
/* We'll save this DIE so link it in. */
6643
part_die->die_parent = parent_die;
6644
part_die->die_sibling = NULL;
6645
part_die->die_child = NULL;
6647
if (last_die && last_die == parent_die)
6648
last_die->die_child = part_die;
6650
last_die->die_sibling = part_die;
6652
last_die = part_die;
6654
if (first_die == NULL)
6655
first_die = part_die;
6657
/* Maybe add the DIE to the hash table. Not all DIEs that we
6658
find interesting need to be in the hash table, because we
6659
also have the parent/sibling/child chains; only those that we
6660
might refer to by offset later during partial symbol reading.
6662
For now this means things that might have be the target of a
6663
DW_AT_specification, DW_AT_abstract_origin, or
6664
DW_AT_extension. DW_AT_extension will refer only to
6665
namespaces; DW_AT_abstract_origin refers to functions (and
6666
many things under the function DIE, but we do not recurse
6667
into function DIEs during partial symbol reading) and
6668
possibly variables as well; DW_AT_specification refers to
6669
declarations. Declarations ought to have the DW_AT_declaration
6670
flag. It happens that GCC forgets to put it in sometimes, but
6671
only for functions, not for types.
6673
Adding more things than necessary to the hash table is harmless
6674
except for the performance cost. Adding too few will result in
6675
wasted time in find_partial_die, when we reread the compilation
6676
unit with load_all_dies set. */
6679
|| abbrev->tag == DW_TAG_subprogram
6680
|| abbrev->tag == DW_TAG_variable
6681
|| abbrev->tag == DW_TAG_namespace
6682
|| part_die->is_declaration)
6686
slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
6687
part_die->offset, INSERT);
6691
part_die = obstack_alloc (&cu->comp_unit_obstack,
6692
sizeof (struct partial_die_info));
6694
/* For some DIEs we want to follow their children (if any). For C
6695
we have no reason to follow the children of structures; for other
6696
languages we have to, both so that we can get at method physnames
6697
to infer fully qualified class names, and for DW_AT_specification.
6699
For Ada, we need to scan the children of subprograms and lexical
6700
blocks as well because Ada allows the definition of nested
6701
entities that could be interesting for the debugger, such as
6702
nested subprograms for instance. */
6703
if (last_die->has_children
6705
|| last_die->tag == DW_TAG_namespace
6706
|| last_die->tag == DW_TAG_enumeration_type
6707
|| (cu->language != language_c
6708
&& (last_die->tag == DW_TAG_class_type
6709
|| last_die->tag == DW_TAG_interface_type
6710
|| last_die->tag == DW_TAG_structure_type
6711
|| last_die->tag == DW_TAG_union_type))
6712
|| (cu->language == language_ada
6713
&& (last_die->tag == DW_TAG_subprogram
6714
|| last_die->tag == DW_TAG_lexical_block))))
6717
parent_die = last_die;
6721
/* Otherwise we skip to the next sibling, if any. */
6722
info_ptr = locate_pdi_sibling (last_die, buffer, info_ptr, abfd, cu);
6724
/* Back to the top, do it again. */
6728
/* Read a minimal amount of information into the minimal die structure. */
6731
read_partial_die (struct partial_die_info *part_die,
6732
struct abbrev_info *abbrev,
6733
unsigned int abbrev_len, bfd *abfd,
6734
gdb_byte *buffer, gdb_byte *info_ptr,
6735
struct dwarf2_cu *cu)
6737
unsigned int bytes_read, i;
6738
struct attribute attr;
6739
int has_low_pc_attr = 0;
6740
int has_high_pc_attr = 0;
6742
memset (part_die, 0, sizeof (struct partial_die_info));
6744
part_die->offset = info_ptr - buffer;
6746
info_ptr += abbrev_len;
6751
part_die->tag = abbrev->tag;
6752
part_die->has_children = abbrev->has_children;
6754
for (i = 0; i < abbrev->num_attrs; ++i)
6756
info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
6758
/* Store the data if it is of an attribute we want to keep in a
6759
partial symbol table. */
6763
switch (part_die->tag)
6765
case DW_TAG_compile_unit:
6766
case DW_TAG_type_unit:
6767
/* Compilation units have a DW_AT_name that is a filename, not
6768
a source language identifier. */
6769
case DW_TAG_enumeration_type:
6770
case DW_TAG_enumerator:
6771
/* These tags always have simple identifiers already; no need
6772
to canonicalize them. */
6773
part_die->name = DW_STRING (&attr);
6777
= dwarf2_canonicalize_name (DW_STRING (&attr), cu,
6778
&cu->objfile->objfile_obstack);
6782
case DW_AT_MIPS_linkage_name:
6783
part_die->name = DW_STRING (&attr);
6786
has_low_pc_attr = 1;
6787
part_die->lowpc = DW_ADDR (&attr);
6790
has_high_pc_attr = 1;
6791
part_die->highpc = DW_ADDR (&attr);
6793
case DW_AT_location:
6794
/* Support the .debug_loc offsets */
6795
if (attr_form_is_block (&attr))
6797
part_die->locdesc = DW_BLOCK (&attr);
6799
else if (attr_form_is_section_offset (&attr))
6801
dwarf2_complex_location_expr_complaint ();
6805
dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6806
"partial symbol information");
6809
case DW_AT_external:
6810
part_die->is_external = DW_UNSND (&attr);
6812
case DW_AT_declaration:
6813
part_die->is_declaration = DW_UNSND (&attr);
6816
part_die->has_type = 1;
6818
case DW_AT_abstract_origin:
6819
case DW_AT_specification:
6820
case DW_AT_extension:
6821
part_die->has_specification = 1;
6822
part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
6825
/* Ignore absolute siblings, they might point outside of
6826
the current compile unit. */
6827
if (attr.form == DW_FORM_ref_addr)
6828
complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
6830
part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr);
6832
case DW_AT_byte_size:
6833
part_die->has_byte_size = 1;
6835
case DW_AT_calling_convention:
6836
/* DWARF doesn't provide a way to identify a program's source-level
6837
entry point. DW_AT_calling_convention attributes are only meant
6838
to describe functions' calling conventions.
6840
However, because it's a necessary piece of information in
6841
Fortran, and because DW_CC_program is the only piece of debugging
6842
information whose definition refers to a 'main program' at all,
6843
several compilers have begun marking Fortran main programs with
6844
DW_CC_program --- even when those functions use the standard
6845
calling conventions.
6847
So until DWARF specifies a way to provide this information and
6848
compilers pick up the new representation, we'll support this
6850
if (DW_UNSND (&attr) == DW_CC_program
6851
&& cu->language == language_fortran)
6852
set_main_name (part_die->name);
6859
/* When using the GNU linker, .gnu.linkonce. sections are used to
6860
eliminate duplicate copies of functions and vtables and such.
6861
The linker will arbitrarily choose one and discard the others.
6862
The AT_*_pc values for such functions refer to local labels in
6863
these sections. If the section from that file was discarded, the
6864
labels are not in the output, so the relocs get a value of 0.
6865
If this is a discarded function, mark the pc bounds as invalid,
6866
so that GDB will ignore it. */
6867
if (has_low_pc_attr && has_high_pc_attr
6868
&& part_die->lowpc < part_die->highpc
6869
&& (part_die->lowpc != 0
6870
|| dwarf2_per_objfile->has_section_at_zero))
6871
part_die->has_pc_info = 1;
6876
/* Find a cached partial DIE at OFFSET in CU. */
6878
static struct partial_die_info *
6879
find_partial_die_in_comp_unit (unsigned int offset, struct dwarf2_cu *cu)
6881
struct partial_die_info *lookup_die = NULL;
6882
struct partial_die_info part_die;
6884
part_die.offset = offset;
6885
lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
6890
/* Find a partial DIE at OFFSET, which may or may not be in CU,
6891
except in the case of .debug_types DIEs which do not reference
6892
outside their CU (they do however referencing other types via
6895
static struct partial_die_info *
6896
find_partial_die (unsigned int offset, struct dwarf2_cu *cu)
6898
struct dwarf2_per_cu_data *per_cu = NULL;
6899
struct partial_die_info *pd = NULL;
6901
if (cu->per_cu->from_debug_types)
6903
pd = find_partial_die_in_comp_unit (offset, cu);
6909
if (offset_in_cu_p (&cu->header, offset))
6911
pd = find_partial_die_in_comp_unit (offset, cu);
6916
per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
6918
if (per_cu->cu == NULL)
6920
load_partial_comp_unit (per_cu, cu->objfile);
6921
per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
6922
dwarf2_per_objfile->read_in_chain = per_cu;
6925
per_cu->cu->last_used = 0;
6926
pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
6928
if (pd == NULL && per_cu->load_all_dies == 0)
6930
struct cleanup *back_to;
6931
struct partial_die_info comp_unit_die;
6932
struct abbrev_info *abbrev;
6933
unsigned int bytes_read;
6936
per_cu->load_all_dies = 1;
6938
/* Re-read the DIEs. */
6939
back_to = make_cleanup (null_cleanup, 0);
6940
if (per_cu->cu->dwarf2_abbrevs == NULL)
6942
dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
6943
make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
6945
info_ptr = (dwarf2_per_objfile->info.buffer
6946
+ per_cu->cu->header.offset
6947
+ per_cu->cu->header.first_die_offset);
6948
abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
6949
info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
6950
per_cu->cu->objfile->obfd,
6951
dwarf2_per_objfile->info.buffer, info_ptr,
6953
if (comp_unit_die.has_children)
6954
load_partial_dies (per_cu->cu->objfile->obfd,
6955
dwarf2_per_objfile->info.buffer, info_ptr,
6957
do_cleanups (back_to);
6959
pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
6965
internal_error (__FILE__, __LINE__,
6966
_("could not find partial DIE 0x%x in cache [from module %s]\n"),
6967
offset, bfd_get_filename (cu->objfile->obfd));
6971
/* Adjust PART_DIE before generating a symbol for it. This function
6972
may set the is_external flag or change the DIE's name. */
6975
fixup_partial_die (struct partial_die_info *part_die,
6976
struct dwarf2_cu *cu)
6978
/* If we found a reference attribute and the DIE has no name, try
6979
to find a name in the referred to DIE. */
6981
if (part_die->name == NULL && part_die->has_specification)
6983
struct partial_die_info *spec_die;
6985
spec_die = find_partial_die (part_die->spec_offset, cu);
6987
fixup_partial_die (spec_die, cu);
6991
part_die->name = spec_die->name;
6993
/* Copy DW_AT_external attribute if it is set. */
6994
if (spec_die->is_external)
6995
part_die->is_external = spec_die->is_external;
6999
/* Set default names for some unnamed DIEs. */
7000
if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
7001
|| part_die->tag == DW_TAG_class_type))
7002
part_die->name = "(anonymous class)";
7004
if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
7005
part_die->name = "(anonymous namespace)";
7007
if (part_die->tag == DW_TAG_structure_type
7008
|| part_die->tag == DW_TAG_class_type
7009
|| part_die->tag == DW_TAG_union_type)
7010
guess_structure_name (part_die, cu);
7013
/* Read an attribute value described by an attribute form. */
7016
read_attribute_value (struct attribute *attr, unsigned form,
7017
bfd *abfd, gdb_byte *info_ptr,
7018
struct dwarf2_cu *cu)
7020
struct comp_unit_head *cu_header = &cu->header;
7021
unsigned int bytes_read;
7022
struct dwarf_block *blk;
7027
case DW_FORM_ref_addr:
7028
if (cu->header.version == 2)
7029
DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
7031
DW_ADDR (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
7032
info_ptr += bytes_read;
7035
DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
7036
info_ptr += bytes_read;
7038
case DW_FORM_block2:
7039
blk = dwarf_alloc_block (cu);
7040
blk->size = read_2_bytes (abfd, info_ptr);
7042
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
7043
info_ptr += blk->size;
7044
DW_BLOCK (attr) = blk;
7046
case DW_FORM_block4:
7047
blk = dwarf_alloc_block (cu);
7048
blk->size = read_4_bytes (abfd, info_ptr);
7050
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
7051
info_ptr += blk->size;
7052
DW_BLOCK (attr) = blk;
7055
DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
7059
DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
7063
DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
7066
case DW_FORM_string:
7067
DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
7068
DW_STRING_IS_CANONICAL (attr) = 0;
7069
info_ptr += bytes_read;
7072
DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
7074
DW_STRING_IS_CANONICAL (attr) = 0;
7075
info_ptr += bytes_read;
7078
blk = dwarf_alloc_block (cu);
7079
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7080
info_ptr += bytes_read;
7081
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
7082
info_ptr += blk->size;
7083
DW_BLOCK (attr) = blk;
7085
case DW_FORM_block1:
7086
blk = dwarf_alloc_block (cu);
7087
blk->size = read_1_byte (abfd, info_ptr);
7089
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
7090
info_ptr += blk->size;
7091
DW_BLOCK (attr) = blk;
7094
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
7098
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
7102
DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
7103
info_ptr += bytes_read;
7106
DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7107
info_ptr += bytes_read;
7110
DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
7114
DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
7118
DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
7122
DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
7126
/* Convert the signature to something we can record in DW_UNSND
7128
NOTE: This is NULL if the type wasn't found. */
7129
DW_SIGNATURED_TYPE (attr) =
7130
lookup_signatured_type (cu->objfile, read_8_bytes (abfd, info_ptr));
7133
case DW_FORM_ref_udata:
7134
DW_ADDR (attr) = (cu->header.offset
7135
+ read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
7136
info_ptr += bytes_read;
7138
case DW_FORM_indirect:
7139
form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7140
info_ptr += bytes_read;
7141
info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
7144
error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
7145
dwarf_form_name (form),
7146
bfd_get_filename (abfd));
7149
/* We have seen instances where the compiler tried to emit a byte
7150
size attribute of -1 which ended up being encoded as an unsigned
7151
0xffffffff. Although 0xffffffff is technically a valid size value,
7152
an object of this size seems pretty unlikely so we can relatively
7153
safely treat these cases as if the size attribute was invalid and
7154
treat them as zero by default. */
7155
if (attr->name == DW_AT_byte_size
7156
&& form == DW_FORM_data4
7157
&& DW_UNSND (attr) >= 0xffffffff)
7160
(&symfile_complaints,
7161
_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
7162
hex_string (DW_UNSND (attr)));
7163
DW_UNSND (attr) = 0;
7169
/* Read an attribute described by an abbreviated attribute. */
7172
read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
7173
bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
7175
attr->name = abbrev->name;
7176
return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
7179
/* read dwarf information from a buffer */
7182
read_1_byte (bfd *abfd, gdb_byte *buf)
7184
return bfd_get_8 (abfd, buf);
7188
read_1_signed_byte (bfd *abfd, gdb_byte *buf)
7190
return bfd_get_signed_8 (abfd, buf);
7194
read_2_bytes (bfd *abfd, gdb_byte *buf)
7196
return bfd_get_16 (abfd, buf);
7200
read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
7202
return bfd_get_signed_16 (abfd, buf);
7206
read_4_bytes (bfd *abfd, gdb_byte *buf)
7208
return bfd_get_32 (abfd, buf);
7212
read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
7214
return bfd_get_signed_32 (abfd, buf);
7218
read_8_bytes (bfd *abfd, gdb_byte *buf)
7220
return bfd_get_64 (abfd, buf);
7224
read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
7225
unsigned int *bytes_read)
7227
struct comp_unit_head *cu_header = &cu->header;
7228
CORE_ADDR retval = 0;
7230
if (cu_header->signed_addr_p)
7232
switch (cu_header->addr_size)
7235
retval = bfd_get_signed_16 (abfd, buf);
7238
retval = bfd_get_signed_32 (abfd, buf);
7241
retval = bfd_get_signed_64 (abfd, buf);
7244
internal_error (__FILE__, __LINE__,
7245
_("read_address: bad switch, signed [in module %s]"),
7246
bfd_get_filename (abfd));
7251
switch (cu_header->addr_size)
7254
retval = bfd_get_16 (abfd, buf);
7257
retval = bfd_get_32 (abfd, buf);
7260
retval = bfd_get_64 (abfd, buf);
7263
internal_error (__FILE__, __LINE__,
7264
_("read_address: bad switch, unsigned [in module %s]"),
7265
bfd_get_filename (abfd));
7269
*bytes_read = cu_header->addr_size;
7273
/* Read the initial length from a section. The (draft) DWARF 3
7274
specification allows the initial length to take up either 4 bytes
7275
or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
7276
bytes describe the length and all offsets will be 8 bytes in length
7279
An older, non-standard 64-bit format is also handled by this
7280
function. The older format in question stores the initial length
7281
as an 8-byte quantity without an escape value. Lengths greater
7282
than 2^32 aren't very common which means that the initial 4 bytes
7283
is almost always zero. Since a length value of zero doesn't make
7284
sense for the 32-bit format, this initial zero can be considered to
7285
be an escape value which indicates the presence of the older 64-bit
7286
format. As written, the code can't detect (old format) lengths
7287
greater than 4GB. If it becomes necessary to handle lengths
7288
somewhat larger than 4GB, we could allow other small values (such
7289
as the non-sensical values of 1, 2, and 3) to also be used as
7290
escape values indicating the presence of the old format.
7292
The value returned via bytes_read should be used to increment the
7293
relevant pointer after calling read_initial_length().
7295
[ Note: read_initial_length() and read_offset() are based on the
7296
document entitled "DWARF Debugging Information Format", revision
7297
3, draft 8, dated November 19, 2001. This document was obtained
7300
http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
7302
This document is only a draft and is subject to change. (So beware.)
7304
Details regarding the older, non-standard 64-bit format were
7305
determined empirically by examining 64-bit ELF files produced by
7306
the SGI toolchain on an IRIX 6.5 machine.
7308
- Kevin, July 16, 2002
7312
read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read)
7314
LONGEST length = bfd_get_32 (abfd, buf);
7316
if (length == 0xffffffff)
7318
length = bfd_get_64 (abfd, buf + 4);
7321
else if (length == 0)
7323
/* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
7324
length = bfd_get_64 (abfd, buf);
7335
/* Cover function for read_initial_length.
7336
Returns the length of the object at BUF, and stores the size of the
7337
initial length in *BYTES_READ and stores the size that offsets will be in
7339
If the initial length size is not equivalent to that specified in
7340
CU_HEADER then issue a complaint.
7341
This is useful when reading non-comp-unit headers. */
7344
read_checked_initial_length_and_offset (bfd *abfd, gdb_byte *buf,
7345
const struct comp_unit_head *cu_header,
7346
unsigned int *bytes_read,
7347
unsigned int *offset_size)
7349
LONGEST length = read_initial_length (abfd, buf, bytes_read);
7351
gdb_assert (cu_header->initial_length_size == 4
7352
|| cu_header->initial_length_size == 8
7353
|| cu_header->initial_length_size == 12);
7355
if (cu_header->initial_length_size != *bytes_read)
7356
complaint (&symfile_complaints,
7357
_("intermixed 32-bit and 64-bit DWARF sections"));
7359
*offset_size = (*bytes_read == 4) ? 4 : 8;
7363
/* Read an offset from the data stream. The size of the offset is
7364
given by cu_header->offset_size. */
7367
read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
7368
unsigned int *bytes_read)
7370
LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
7371
*bytes_read = cu_header->offset_size;
7375
/* Read an offset from the data stream. */
7378
read_offset_1 (bfd *abfd, gdb_byte *buf, unsigned int offset_size)
7382
switch (offset_size)
7385
retval = bfd_get_32 (abfd, buf);
7388
retval = bfd_get_64 (abfd, buf);
7391
internal_error (__FILE__, __LINE__,
7392
_("read_offset_1: bad switch [in module %s]"),
7393
bfd_get_filename (abfd));
7400
read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
7402
/* If the size of a host char is 8 bits, we can return a pointer
7403
to the buffer, otherwise we have to copy the data to a buffer
7404
allocated on the temporary obstack. */
7405
gdb_assert (HOST_CHAR_BIT == 8);
7410
read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
7412
/* If the size of a host char is 8 bits, we can return a pointer
7413
to the string, otherwise we have to copy the string to a buffer
7414
allocated on the temporary obstack. */
7415
gdb_assert (HOST_CHAR_BIT == 8);
7418
*bytes_read_ptr = 1;
7421
*bytes_read_ptr = strlen ((char *) buf) + 1;
7422
return (char *) buf;
7426
read_indirect_string (bfd *abfd, gdb_byte *buf,
7427
const struct comp_unit_head *cu_header,
7428
unsigned int *bytes_read_ptr)
7430
LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
7432
if (dwarf2_per_objfile->str.buffer == NULL)
7434
error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
7435
bfd_get_filename (abfd));
7438
if (str_offset >= dwarf2_per_objfile->str.size)
7440
error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
7441
bfd_get_filename (abfd));
7444
gdb_assert (HOST_CHAR_BIT == 8);
7445
if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
7447
return (char *) (dwarf2_per_objfile->str.buffer + str_offset);
7450
static unsigned long
7451
read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
7453
unsigned long result;
7454
unsigned int num_read;
7464
byte = bfd_get_8 (abfd, buf);
7467
result |= ((unsigned long)(byte & 127) << shift);
7468
if ((byte & 128) == 0)
7474
*bytes_read_ptr = num_read;
7479
read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
7482
int i, shift, num_read;
7491
byte = bfd_get_8 (abfd, buf);
7494
result |= ((long)(byte & 127) << shift);
7496
if ((byte & 128) == 0)
7501
if ((shift < 8 * sizeof (result)) && (byte & 0x40))
7502
result |= -(((long)1) << shift);
7503
*bytes_read_ptr = num_read;
7507
/* Return a pointer to just past the end of an LEB128 number in BUF. */
7510
skip_leb128 (bfd *abfd, gdb_byte *buf)
7516
byte = bfd_get_8 (abfd, buf);
7518
if ((byte & 128) == 0)
7524
set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
7531
cu->language = language_c;
7533
case DW_LANG_C_plus_plus:
7534
cu->language = language_cplus;
7536
case DW_LANG_Fortran77:
7537
case DW_LANG_Fortran90:
7538
case DW_LANG_Fortran95:
7539
cu->language = language_fortran;
7541
case DW_LANG_Mips_Assembler:
7542
cu->language = language_asm;
7545
cu->language = language_java;
7549
cu->language = language_ada;
7551
case DW_LANG_Modula2:
7552
cu->language = language_m2;
7554
case DW_LANG_Pascal83:
7555
cu->language = language_pascal;
7558
cu->language = language_objc;
7560
case DW_LANG_Cobol74:
7561
case DW_LANG_Cobol85:
7563
cu->language = language_minimal;
7566
cu->language_defn = language_def (cu->language);
7569
/* Return the named attribute or NULL if not there. */
7571
static struct attribute *
7572
dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
7575
struct attribute *spec = NULL;
7577
for (i = 0; i < die->num_attrs; ++i)
7579
if (die->attrs[i].name == name)
7580
return &die->attrs[i];
7581
if (die->attrs[i].name == DW_AT_specification
7582
|| die->attrs[i].name == DW_AT_abstract_origin)
7583
spec = &die->attrs[i];
7588
die = follow_die_ref (die, spec, &cu);
7589
return dwarf2_attr (die, name, cu);
7595
/* Return the named attribute or NULL if not there,
7596
but do not follow DW_AT_specification, etc.
7597
This is for use in contexts where we're reading .debug_types dies.
7598
Following DW_AT_specification, DW_AT_abstract_origin will take us
7599
back up the chain, and we want to go down. */
7601
static struct attribute *
7602
dwarf2_attr_no_follow (struct die_info *die, unsigned int name,
7603
struct dwarf2_cu *cu)
7607
for (i = 0; i < die->num_attrs; ++i)
7608
if (die->attrs[i].name == name)
7609
return &die->attrs[i];
7614
/* Return non-zero iff the attribute NAME is defined for the given DIE,
7615
and holds a non-zero value. This function should only be used for
7616
DW_FORM_flag attributes. */
7619
dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
7621
struct attribute *attr = dwarf2_attr (die, name, cu);
7623
return (attr && DW_UNSND (attr));
7627
die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
7629
/* A DIE is a declaration if it has a DW_AT_declaration attribute
7630
which value is non-zero. However, we have to be careful with
7631
DIEs having a DW_AT_specification attribute, because dwarf2_attr()
7632
(via dwarf2_flag_true_p) follows this attribute. So we may
7633
end up accidently finding a declaration attribute that belongs
7634
to a different DIE referenced by the specification attribute,
7635
even though the given DIE does not have a declaration attribute. */
7636
return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
7637
&& dwarf2_attr (die, DW_AT_specification, cu) == NULL);
7640
/* Return the die giving the specification for DIE, if there is
7641
one. *SPEC_CU is the CU containing DIE on input, and the CU
7642
containing the return value on output. If there is no
7643
specification, but there is an abstract origin, that is
7646
static struct die_info *
7647
die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
7649
struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
7652
if (spec_attr == NULL)
7653
spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
7655
if (spec_attr == NULL)
7658
return follow_die_ref (die, spec_attr, spec_cu);
7661
/* Free the line_header structure *LH, and any arrays and strings it
7664
free_line_header (struct line_header *lh)
7666
if (lh->standard_opcode_lengths)
7667
xfree (lh->standard_opcode_lengths);
7669
/* Remember that all the lh->file_names[i].name pointers are
7670
pointers into debug_line_buffer, and don't need to be freed. */
7672
xfree (lh->file_names);
7674
/* Similarly for the include directory names. */
7675
if (lh->include_dirs)
7676
xfree (lh->include_dirs);
7682
/* Add an entry to LH's include directory table. */
7684
add_include_dir (struct line_header *lh, char *include_dir)
7686
/* Grow the array if necessary. */
7687
if (lh->include_dirs_size == 0)
7689
lh->include_dirs_size = 1; /* for testing */
7690
lh->include_dirs = xmalloc (lh->include_dirs_size
7691
* sizeof (*lh->include_dirs));
7693
else if (lh->num_include_dirs >= lh->include_dirs_size)
7695
lh->include_dirs_size *= 2;
7696
lh->include_dirs = xrealloc (lh->include_dirs,
7697
(lh->include_dirs_size
7698
* sizeof (*lh->include_dirs)));
7701
lh->include_dirs[lh->num_include_dirs++] = include_dir;
7705
/* Add an entry to LH's file name table. */
7707
add_file_name (struct line_header *lh,
7709
unsigned int dir_index,
7710
unsigned int mod_time,
7711
unsigned int length)
7713
struct file_entry *fe;
7715
/* Grow the array if necessary. */
7716
if (lh->file_names_size == 0)
7718
lh->file_names_size = 1; /* for testing */
7719
lh->file_names = xmalloc (lh->file_names_size
7720
* sizeof (*lh->file_names));
7722
else if (lh->num_file_names >= lh->file_names_size)
7724
lh->file_names_size *= 2;
7725
lh->file_names = xrealloc (lh->file_names,
7726
(lh->file_names_size
7727
* sizeof (*lh->file_names)));
7730
fe = &lh->file_names[lh->num_file_names++];
7732
fe->dir_index = dir_index;
7733
fe->mod_time = mod_time;
7734
fe->length = length;
7740
/* Read the statement program header starting at OFFSET in
7741
.debug_line, according to the endianness of ABFD. Return a pointer
7742
to a struct line_header, allocated using xmalloc.
7744
NOTE: the strings in the include directory and file name tables of
7745
the returned object point into debug_line_buffer, and must not be
7747
static struct line_header *
7748
dwarf_decode_line_header (unsigned int offset, bfd *abfd,
7749
struct dwarf2_cu *cu)
7751
struct cleanup *back_to;
7752
struct line_header *lh;
7754
unsigned int bytes_read, offset_size;
7756
char *cur_dir, *cur_file;
7758
if (dwarf2_per_objfile->line.buffer == NULL)
7760
complaint (&symfile_complaints, _("missing .debug_line section"));
7764
/* Make sure that at least there's room for the total_length field.
7765
That could be 12 bytes long, but we're just going to fudge that. */
7766
if (offset + 4 >= dwarf2_per_objfile->line.size)
7768
dwarf2_statement_list_fits_in_line_number_section_complaint ();
7772
lh = xmalloc (sizeof (*lh));
7773
memset (lh, 0, sizeof (*lh));
7774
back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
7777
line_ptr = dwarf2_per_objfile->line.buffer + offset;
7779
/* Read in the header. */
7781
read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
7782
&bytes_read, &offset_size);
7783
line_ptr += bytes_read;
7784
if (line_ptr + lh->total_length > (dwarf2_per_objfile->line.buffer
7785
+ dwarf2_per_objfile->line.size))
7787
dwarf2_statement_list_fits_in_line_number_section_complaint ();
7790
lh->statement_program_end = line_ptr + lh->total_length;
7791
lh->version = read_2_bytes (abfd, line_ptr);
7793
lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
7794
line_ptr += offset_size;
7795
lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
7797
lh->default_is_stmt = read_1_byte (abfd, line_ptr);
7799
lh->line_base = read_1_signed_byte (abfd, line_ptr);
7801
lh->line_range = read_1_byte (abfd, line_ptr);
7803
lh->opcode_base = read_1_byte (abfd, line_ptr);
7805
lh->standard_opcode_lengths
7806
= xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
7808
lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
7809
for (i = 1; i < lh->opcode_base; ++i)
7811
lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
7815
/* Read directory table. */
7816
while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
7818
line_ptr += bytes_read;
7819
add_include_dir (lh, cur_dir);
7821
line_ptr += bytes_read;
7823
/* Read file name table. */
7824
while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
7826
unsigned int dir_index, mod_time, length;
7828
line_ptr += bytes_read;
7829
dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
7830
line_ptr += bytes_read;
7831
mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
7832
line_ptr += bytes_read;
7833
length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
7834
line_ptr += bytes_read;
7836
add_file_name (lh, cur_file, dir_index, mod_time, length);
7838
line_ptr += bytes_read;
7839
lh->statement_program_start = line_ptr;
7841
if (line_ptr > (dwarf2_per_objfile->line.buffer
7842
+ dwarf2_per_objfile->line.size))
7843
complaint (&symfile_complaints,
7844
_("line number info header doesn't fit in `.debug_line' section"));
7846
discard_cleanups (back_to);
7850
/* This function exists to work around a bug in certain compilers
7851
(particularly GCC 2.95), in which the first line number marker of a
7852
function does not show up until after the prologue, right before
7853
the second line number marker. This function shifts ADDRESS down
7854
to the beginning of the function if necessary, and is called on
7855
addresses passed to record_line. */
7858
check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
7860
struct function_range *fn;
7862
/* Find the function_range containing address. */
7867
cu->cached_fn = cu->first_fn;
7871
if (fn->lowpc <= address && fn->highpc > address)
7877
while (fn && fn != cu->cached_fn)
7878
if (fn->lowpc <= address && fn->highpc > address)
7888
if (address != fn->lowpc)
7889
complaint (&symfile_complaints,
7890
_("misplaced first line number at 0x%lx for '%s'"),
7891
(unsigned long) address, fn->name);
7896
/* Decode the Line Number Program (LNP) for the given line_header
7897
structure and CU. The actual information extracted and the type
7898
of structures created from the LNP depends on the value of PST.
7900
1. If PST is NULL, then this procedure uses the data from the program
7901
to create all necessary symbol tables, and their linetables.
7902
The compilation directory of the file is passed in COMP_DIR,
7903
and must not be NULL.
7905
2. If PST is not NULL, this procedure reads the program to determine
7906
the list of files included by the unit represented by PST, and
7907
builds all the associated partial symbol tables. In this case,
7908
the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
7909
is not used to compute the full name of the symtab, and therefore
7910
omitting it when building the partial symtab does not introduce
7911
the potential for inconsistency - a partial symtab and its associated
7912
symbtab having a different fullname -). */
7915
dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
7916
struct dwarf2_cu *cu, struct partial_symtab *pst)
7918
gdb_byte *line_ptr, *extended_end;
7920
unsigned int bytes_read, extended_len;
7921
unsigned char op_code, extended_op, adj_opcode;
7923
struct objfile *objfile = cu->objfile;
7924
struct gdbarch *gdbarch = get_objfile_arch (objfile);
7925
const int decode_for_pst_p = (pst != NULL);
7926
struct subfile *last_subfile = NULL, *first_subfile = current_subfile;
7928
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7930
line_ptr = lh->statement_program_start;
7931
line_end = lh->statement_program_end;
7933
/* Read the statement sequences until there's nothing left. */
7934
while (line_ptr < line_end)
7936
/* state machine registers */
7937
CORE_ADDR address = 0;
7938
unsigned int file = 1;
7939
unsigned int line = 1;
7940
unsigned int column = 0;
7941
int is_stmt = lh->default_is_stmt;
7942
int basic_block = 0;
7943
int end_sequence = 0;
7946
if (!decode_for_pst_p && lh->num_file_names >= file)
7948
/* Start a subfile for the current file of the state machine. */
7949
/* lh->include_dirs and lh->file_names are 0-based, but the
7950
directory and file name numbers in the statement program
7952
struct file_entry *fe = &lh->file_names[file - 1];
7956
dir = lh->include_dirs[fe->dir_index - 1];
7958
dwarf2_start_subfile (fe->name, dir, comp_dir);
7961
/* Decode the table. */
7962
while (!end_sequence)
7964
op_code = read_1_byte (abfd, line_ptr);
7966
if (line_ptr > line_end)
7968
dwarf2_debug_line_missing_end_sequence_complaint ();
7972
if (op_code >= lh->opcode_base)
7974
/* Special operand. */
7975
adj_opcode = op_code - lh->opcode_base;
7976
address += (adj_opcode / lh->line_range)
7977
* lh->minimum_instruction_length;
7978
line += lh->line_base + (adj_opcode % lh->line_range);
7979
if (lh->num_file_names < file || file == 0)
7980
dwarf2_debug_line_missing_file_complaint ();
7983
lh->file_names[file - 1].included_p = 1;
7984
if (!decode_for_pst_p && is_stmt)
7986
if (last_subfile != current_subfile)
7988
addr = gdbarch_addr_bits_remove (gdbarch, address);
7990
record_line (last_subfile, 0, addr);
7991
last_subfile = current_subfile;
7993
/* Append row to matrix using current values. */
7994
addr = check_cu_functions (address, cu);
7995
addr = gdbarch_addr_bits_remove (gdbarch, addr);
7996
record_line (current_subfile, line, addr);
8001
else switch (op_code)
8003
case DW_LNS_extended_op:
8004
extended_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8005
line_ptr += bytes_read;
8006
extended_end = line_ptr + extended_len;
8007
extended_op = read_1_byte (abfd, line_ptr);
8009
switch (extended_op)
8011
case DW_LNE_end_sequence:
8014
case DW_LNE_set_address:
8015
address = read_address (abfd, line_ptr, cu, &bytes_read);
8016
line_ptr += bytes_read;
8017
address += baseaddr;
8019
case DW_LNE_define_file:
8022
unsigned int dir_index, mod_time, length;
8024
cur_file = read_string (abfd, line_ptr, &bytes_read);
8025
line_ptr += bytes_read;
8027
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8028
line_ptr += bytes_read;
8030
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8031
line_ptr += bytes_read;
8033
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8034
line_ptr += bytes_read;
8035
add_file_name (lh, cur_file, dir_index, mod_time, length);
8038
case DW_LNE_set_discriminator:
8039
/* The discriminator is not interesting to the debugger;
8041
line_ptr = extended_end;
8044
complaint (&symfile_complaints,
8045
_("mangled .debug_line section"));
8048
/* Make sure that we parsed the extended op correctly. If e.g.
8049
we expected a different address size than the producer used,
8050
we may have read the wrong number of bytes. */
8051
if (line_ptr != extended_end)
8053
complaint (&symfile_complaints,
8054
_("mangled .debug_line section"));
8059
if (lh->num_file_names < file || file == 0)
8060
dwarf2_debug_line_missing_file_complaint ();
8063
lh->file_names[file - 1].included_p = 1;
8064
if (!decode_for_pst_p && is_stmt)
8066
if (last_subfile != current_subfile)
8068
addr = gdbarch_addr_bits_remove (gdbarch, address);
8070
record_line (last_subfile, 0, addr);
8071
last_subfile = current_subfile;
8073
addr = check_cu_functions (address, cu);
8074
addr = gdbarch_addr_bits_remove (gdbarch, addr);
8075
record_line (current_subfile, line, addr);
8080
case DW_LNS_advance_pc:
8081
address += lh->minimum_instruction_length
8082
* read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8083
line_ptr += bytes_read;
8085
case DW_LNS_advance_line:
8086
line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
8087
line_ptr += bytes_read;
8089
case DW_LNS_set_file:
8091
/* The arrays lh->include_dirs and lh->file_names are
8092
0-based, but the directory and file name numbers in
8093
the statement program are 1-based. */
8094
struct file_entry *fe;
8097
file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8098
line_ptr += bytes_read;
8099
if (lh->num_file_names < file || file == 0)
8100
dwarf2_debug_line_missing_file_complaint ();
8103
fe = &lh->file_names[file - 1];
8105
dir = lh->include_dirs[fe->dir_index - 1];
8106
if (!decode_for_pst_p)
8108
last_subfile = current_subfile;
8109
dwarf2_start_subfile (fe->name, dir, comp_dir);
8114
case DW_LNS_set_column:
8115
column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8116
line_ptr += bytes_read;
8118
case DW_LNS_negate_stmt:
8119
is_stmt = (!is_stmt);
8121
case DW_LNS_set_basic_block:
8124
/* Add to the address register of the state machine the
8125
address increment value corresponding to special opcode
8126
255. I.e., this value is scaled by the minimum
8127
instruction length since special opcode 255 would have
8128
scaled the the increment. */
8129
case DW_LNS_const_add_pc:
8130
address += (lh->minimum_instruction_length
8131
* ((255 - lh->opcode_base) / lh->line_range));
8133
case DW_LNS_fixed_advance_pc:
8134
address += read_2_bytes (abfd, line_ptr);
8139
/* Unknown standard opcode, ignore it. */
8142
for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
8144
(void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
8145
line_ptr += bytes_read;
8150
if (lh->num_file_names < file || file == 0)
8151
dwarf2_debug_line_missing_file_complaint ();
8154
lh->file_names[file - 1].included_p = 1;
8155
if (!decode_for_pst_p)
8157
addr = gdbarch_addr_bits_remove (gdbarch, address);
8158
record_line (current_subfile, 0, addr);
8163
if (decode_for_pst_p)
8167
/* Now that we're done scanning the Line Header Program, we can
8168
create the psymtab of each included file. */
8169
for (file_index = 0; file_index < lh->num_file_names; file_index++)
8170
if (lh->file_names[file_index].included_p == 1)
8172
const struct file_entry fe = lh->file_names [file_index];
8173
char *include_name = fe.name;
8174
char *dir_name = NULL;
8175
char *pst_filename = pst->filename;
8178
dir_name = lh->include_dirs[fe.dir_index - 1];
8180
if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
8182
include_name = concat (dir_name, SLASH_STRING,
8183
include_name, (char *)NULL);
8184
make_cleanup (xfree, include_name);
8187
if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
8189
pst_filename = concat (pst->dirname, SLASH_STRING,
8190
pst_filename, (char *)NULL);
8191
make_cleanup (xfree, pst_filename);
8194
if (strcmp (include_name, pst_filename) != 0)
8195
dwarf2_create_include_psymtab (include_name, pst, objfile);
8200
/* Make sure a symtab is created for every file, even files
8201
which contain only variables (i.e. no code with associated
8205
struct file_entry *fe;
8207
for (i = 0; i < lh->num_file_names; i++)
8210
fe = &lh->file_names[i];
8212
dir = lh->include_dirs[fe->dir_index - 1];
8213
dwarf2_start_subfile (fe->name, dir, comp_dir);
8215
/* Skip the main file; we don't need it, and it must be
8216
allocated last, so that it will show up before the
8217
non-primary symtabs in the objfile's symtab list. */
8218
if (current_subfile == first_subfile)
8221
if (current_subfile->symtab == NULL)
8222
current_subfile->symtab = allocate_symtab (current_subfile->name,
8224
fe->symtab = current_subfile->symtab;
8229
/* Start a subfile for DWARF. FILENAME is the name of the file and
8230
DIRNAME the name of the source directory which contains FILENAME
8231
or NULL if not known. COMP_DIR is the compilation directory for the
8232
linetable's compilation unit or NULL if not known.
8233
This routine tries to keep line numbers from identical absolute and
8234
relative file names in a common subfile.
8236
Using the `list' example from the GDB testsuite, which resides in
8237
/srcdir and compiling it with Irix6.2 cc in /compdir using a filename
8238
of /srcdir/list0.c yields the following debugging information for list0.c:
8240
DW_AT_name: /srcdir/list0.c
8241
DW_AT_comp_dir: /compdir
8242
files.files[0].name: list0.h
8243
files.files[0].dir: /srcdir
8244
files.files[1].name: list0.c
8245
files.files[1].dir: /srcdir
8247
The line number information for list0.c has to end up in a single
8248
subfile, so that `break /srcdir/list0.c:1' works as expected.
8249
start_subfile will ensure that this happens provided that we pass the
8250
concatenation of files.files[1].dir and files.files[1].name as the
8254
dwarf2_start_subfile (char *filename, char *dirname, char *comp_dir)
8258
/* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
8259
`start_symtab' will always pass the contents of DW_AT_comp_dir as
8260
second argument to start_subfile. To be consistent, we do the
8261
same here. In order not to lose the line information directory,
8262
we concatenate it to the filename when it makes sense.
8263
Note that the Dwarf3 standard says (speaking of filenames in line
8264
information): ``The directory index is ignored for file names
8265
that represent full path names''. Thus ignoring dirname in the
8266
`else' branch below isn't an issue. */
8268
if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
8269
fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
8271
fullname = filename;
8273
start_subfile (fullname, comp_dir);
8275
if (fullname != filename)
8280
var_decode_location (struct attribute *attr, struct symbol *sym,
8281
struct dwarf2_cu *cu)
8283
struct objfile *objfile = cu->objfile;
8284
struct comp_unit_head *cu_header = &cu->header;
8286
/* NOTE drow/2003-01-30: There used to be a comment and some special
8287
code here to turn a symbol with DW_AT_external and a
8288
SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
8289
necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
8290
with some versions of binutils) where shared libraries could have
8291
relocations against symbols in their debug information - the
8292
minimal symbol would have the right address, but the debug info
8293
would not. It's no longer necessary, because we will explicitly
8294
apply relocations when we read in the debug information now. */
8296
/* A DW_AT_location attribute with no contents indicates that a
8297
variable has been optimized away. */
8298
if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
8300
SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
8304
/* Handle one degenerate form of location expression specially, to
8305
preserve GDB's previous behavior when section offsets are
8306
specified. If this is just a DW_OP_addr then mark this symbol
8309
if (attr_form_is_block (attr)
8310
&& DW_BLOCK (attr)->size == 1 + cu_header->addr_size
8311
&& DW_BLOCK (attr)->data[0] == DW_OP_addr)
8315
SYMBOL_VALUE_ADDRESS (sym) =
8316
read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
8317
SYMBOL_CLASS (sym) = LOC_STATIC;
8318
fixup_symbol_section (sym, objfile);
8319
SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
8320
SYMBOL_SECTION (sym));
8324
/* NOTE drow/2002-01-30: It might be worthwhile to have a static
8325
expression evaluator, and use LOC_COMPUTED only when necessary
8326
(i.e. when the value of a register or memory location is
8327
referenced, or a thread-local block, etc.). Then again, it might
8328
not be worthwhile. I'm assuming that it isn't unless performance
8329
or memory numbers show me otherwise. */
8331
dwarf2_symbol_mark_computed (attr, sym, cu);
8332
SYMBOL_CLASS (sym) = LOC_COMPUTED;
8335
/* Given a pointer to a DWARF information entry, figure out if we need
8336
to make a symbol table entry for it, and if so, create a new entry
8337
and return a pointer to it.
8338
If TYPE is NULL, determine symbol type from the die, otherwise
8339
used the passed type. */
8341
static struct symbol *
8342
new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
8344
struct objfile *objfile = cu->objfile;
8345
struct symbol *sym = NULL;
8347
struct attribute *attr = NULL;
8348
struct attribute *attr2 = NULL;
8350
int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
8352
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8354
if (die->tag != DW_TAG_namespace)
8355
name = dwarf2_linkage_name (die, cu);
8357
name = TYPE_NAME (type);
8361
sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
8362
sizeof (struct symbol));
8363
OBJSTAT (objfile, n_syms++);
8364
memset (sym, 0, sizeof (struct symbol));
8366
/* Cache this symbol's name and the name's demangled form (if any). */
8367
SYMBOL_LANGUAGE (sym) = cu->language;
8368
SYMBOL_SET_NAMES (sym, name, strlen (name), 0, objfile);
8370
/* Default assumptions.
8371
Use the passed type or decode it from the die. */
8372
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
8373
SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
8375
SYMBOL_TYPE (sym) = type;
8377
SYMBOL_TYPE (sym) = die_type (die, cu);
8378
attr = dwarf2_attr (die,
8379
inlined_func ? DW_AT_call_line : DW_AT_decl_line,
8383
SYMBOL_LINE (sym) = DW_UNSND (attr);
8386
attr = dwarf2_attr (die,
8387
inlined_func ? DW_AT_call_file : DW_AT_decl_file,
8391
int file_index = DW_UNSND (attr);
8392
if (cu->line_header == NULL
8393
|| file_index > cu->line_header->num_file_names)
8394
complaint (&symfile_complaints,
8395
_("file index out of range"));
8396
else if (file_index > 0)
8398
struct file_entry *fe;
8399
fe = &cu->line_header->file_names[file_index - 1];
8400
SYMBOL_SYMTAB (sym) = fe->symtab;
8407
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
8410
SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
8412
SYMBOL_CLASS (sym) = LOC_LABEL;
8414
case DW_TAG_subprogram:
8415
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8417
SYMBOL_CLASS (sym) = LOC_BLOCK;
8418
attr2 = dwarf2_attr (die, DW_AT_external, cu);
8419
if ((attr2 && (DW_UNSND (attr2) != 0))
8420
|| cu->language == language_ada)
8422
/* Subprograms marked external are stored as a global symbol.
8423
Ada subprograms, whether marked external or not, are always
8424
stored as a global symbol, because we want to be able to
8425
access them globally. For instance, we want to be able
8426
to break on a nested subprogram without having to
8427
specify the context. */
8428
add_symbol_to_list (sym, &global_symbols);
8432
add_symbol_to_list (sym, cu->list_in_scope);
8435
case DW_TAG_inlined_subroutine:
8436
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
8438
SYMBOL_CLASS (sym) = LOC_BLOCK;
8439
SYMBOL_INLINED (sym) = 1;
8440
/* Do not add the symbol to any lists. It will be found via
8441
BLOCK_FUNCTION from the blockvector. */
8443
case DW_TAG_variable:
8444
/* Compilation with minimal debug info may result in variables
8445
with missing type entries. Change the misleading `void' type
8446
to something sensible. */
8447
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
8449
= objfile_type (objfile)->nodebug_data_symbol;
8451
attr = dwarf2_attr (die, DW_AT_const_value, cu);
8454
dwarf2_const_value (attr, sym, cu);
8455
attr2 = dwarf2_attr (die, DW_AT_external, cu);
8456
if (attr2 && (DW_UNSND (attr2) != 0))
8457
add_symbol_to_list (sym, &global_symbols);
8459
add_symbol_to_list (sym, cu->list_in_scope);
8462
attr = dwarf2_attr (die, DW_AT_location, cu);
8465
var_decode_location (attr, sym, cu);
8466
attr2 = dwarf2_attr (die, DW_AT_external, cu);
8467
if (attr2 && (DW_UNSND (attr2) != 0))
8468
add_symbol_to_list (sym, &global_symbols);
8470
add_symbol_to_list (sym, cu->list_in_scope);
8474
/* We do not know the address of this symbol.
8475
If it is an external symbol and we have type information
8476
for it, enter the symbol as a LOC_UNRESOLVED symbol.
8477
The address of the variable will then be determined from
8478
the minimal symbol table whenever the variable is
8480
attr2 = dwarf2_attr (die, DW_AT_external, cu);
8481
if (attr2 && (DW_UNSND (attr2) != 0)
8482
&& dwarf2_attr (die, DW_AT_type, cu) != NULL)
8484
struct pending **list_to_add;
8486
/* A variable with DW_AT_external is never static, but it
8487
may be block-scoped. */
8488
list_to_add = (cu->list_in_scope == &file_symbols
8489
? &global_symbols : cu->list_in_scope);
8491
SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
8492
add_symbol_to_list (sym, list_to_add);
8494
else if (!die_is_declaration (die, cu))
8496
/* Use the default LOC_OPTIMIZED_OUT class. */
8497
gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
8498
add_symbol_to_list (sym, cu->list_in_scope);
8502
case DW_TAG_formal_parameter:
8503
/* If we are inside a function, mark this as an argument. If
8504
not, we might be looking at an argument to an inlined function
8505
when we do not have enough information to show inlined frames;
8506
pretend it's a local variable in that case so that the user can
8508
if (context_stack_depth > 0
8509
&& context_stack[context_stack_depth - 1].name != NULL)
8510
SYMBOL_IS_ARGUMENT (sym) = 1;
8511
attr = dwarf2_attr (die, DW_AT_location, cu);
8514
var_decode_location (attr, sym, cu);
8516
attr = dwarf2_attr (die, DW_AT_const_value, cu);
8519
dwarf2_const_value (attr, sym, cu);
8521
add_symbol_to_list (sym, cu->list_in_scope);
8523
case DW_TAG_unspecified_parameters:
8524
/* From varargs functions; gdb doesn't seem to have any
8525
interest in this information, so just ignore it for now.
8528
case DW_TAG_class_type:
8529
case DW_TAG_interface_type:
8530
case DW_TAG_structure_type:
8531
case DW_TAG_union_type:
8532
case DW_TAG_set_type:
8533
case DW_TAG_enumeration_type:
8534
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
8535
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
8537
/* Make sure that the symbol includes appropriate enclosing
8538
classes/namespaces in its name. These are calculated in
8539
read_structure_type, and the correct name is saved in
8542
if (cu->language == language_cplus
8543
|| cu->language == language_java)
8545
struct type *type = SYMBOL_TYPE (sym);
8547
if (TYPE_TAG_NAME (type) != NULL)
8549
/* FIXME: carlton/2003-11-10: Should this use
8550
SYMBOL_SET_NAMES instead? (The same problem also
8551
arises further down in this function.) */
8552
/* The type's name is already allocated along with
8553
this objfile, so we don't need to duplicate it
8555
SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
8560
/* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
8561
really ever be static objects: otherwise, if you try
8562
to, say, break of a class's method and you're in a file
8563
which doesn't mention that class, it won't work unless
8564
the check for all static symbols in lookup_symbol_aux
8565
saves you. See the OtherFileClass tests in
8566
gdb.c++/namespace.exp. */
8568
struct pending **list_to_add;
8570
list_to_add = (cu->list_in_scope == &file_symbols
8571
&& (cu->language == language_cplus
8572
|| cu->language == language_java)
8573
? &global_symbols : cu->list_in_scope);
8575
add_symbol_to_list (sym, list_to_add);
8577
/* The semantics of C++ state that "struct foo { ... }" also
8578
defines a typedef for "foo". A Java class declaration also
8579
defines a typedef for the class. */
8580
if (cu->language == language_cplus
8581
|| cu->language == language_java
8582
|| cu->language == language_ada)
8584
/* The symbol's name is already allocated along with
8585
this objfile, so we don't need to duplicate it for
8587
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
8588
TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
8592
case DW_TAG_typedef:
8593
SYMBOL_LINKAGE_NAME (sym) = (char *) dwarf2_full_name (die, cu);
8594
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
8595
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
8596
add_symbol_to_list (sym, cu->list_in_scope);
8598
case DW_TAG_base_type:
8599
case DW_TAG_subrange_type:
8600
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
8601
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
8602
add_symbol_to_list (sym, cu->list_in_scope);
8604
case DW_TAG_enumerator:
8605
SYMBOL_LINKAGE_NAME (sym) = (char *) dwarf2_full_name (die, cu);
8606
attr = dwarf2_attr (die, DW_AT_const_value, cu);
8609
dwarf2_const_value (attr, sym, cu);
8612
/* NOTE: carlton/2003-11-10: See comment above in the
8613
DW_TAG_class_type, etc. block. */
8615
struct pending **list_to_add;
8617
list_to_add = (cu->list_in_scope == &file_symbols
8618
&& (cu->language == language_cplus
8619
|| cu->language == language_java)
8620
? &global_symbols : cu->list_in_scope);
8622
add_symbol_to_list (sym, list_to_add);
8625
case DW_TAG_namespace:
8626
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
8627
add_symbol_to_list (sym, &global_symbols);
8630
/* Not a tag we recognize. Hopefully we aren't processing
8631
trash data, but since we must specifically ignore things
8632
we don't recognize, there is nothing else we should do at
8634
complaint (&symfile_complaints, _("unsupported tag: '%s'"),
8635
dwarf_tag_name (die->tag));
8639
/* For the benefit of old versions of GCC, check for anonymous
8640
namespaces based on the demangled name. */
8641
if (!processing_has_namespace_info
8642
&& cu->language == language_cplus
8643
&& dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu) != NULL)
8644
cp_scan_for_anonymous_namespaces (sym);
8649
/* Copy constant value from an attribute to a symbol. */
8652
dwarf2_const_value (struct attribute *attr, struct symbol *sym,
8653
struct dwarf2_cu *cu)
8655
struct objfile *objfile = cu->objfile;
8656
struct comp_unit_head *cu_header = &cu->header;
8657
enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
8658
BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
8659
struct dwarf_block *blk;
8664
if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
8665
dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym),
8666
cu_header->addr_size,
8667
TYPE_LENGTH (SYMBOL_TYPE
8669
SYMBOL_VALUE_BYTES (sym) =
8670
obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
8671
/* NOTE: cagney/2003-05-09: In-lined store_address call with
8672
it's body - store_unsigned_integer. */
8673
store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
8674
byte_order, DW_ADDR (attr));
8675
SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
8677
case DW_FORM_string:
8679
/* DW_STRING is already allocated on the obstack, point directly
8681
SYMBOL_VALUE_BYTES (sym) = (gdb_byte *) DW_STRING (attr);
8682
SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
8684
case DW_FORM_block1:
8685
case DW_FORM_block2:
8686
case DW_FORM_block4:
8688
blk = DW_BLOCK (attr);
8689
if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
8690
dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym),
8692
TYPE_LENGTH (SYMBOL_TYPE
8694
SYMBOL_VALUE_BYTES (sym) =
8695
obstack_alloc (&objfile->objfile_obstack, blk->size);
8696
memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
8697
SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
8700
/* The DW_AT_const_value attributes are supposed to carry the
8701
symbol's value "represented as it would be on the target
8702
architecture." By the time we get here, it's already been
8703
converted to host endianness, so we just need to sign- or
8704
zero-extend it as appropriate. */
8706
dwarf2_const_value_data (attr, sym, 8);
8709
dwarf2_const_value_data (attr, sym, 16);
8712
dwarf2_const_value_data (attr, sym, 32);
8715
dwarf2_const_value_data (attr, sym, 64);
8719
SYMBOL_VALUE (sym) = DW_SND (attr);
8720
SYMBOL_CLASS (sym) = LOC_CONST;
8724
SYMBOL_VALUE (sym) = DW_UNSND (attr);
8725
SYMBOL_CLASS (sym) = LOC_CONST;
8729
complaint (&symfile_complaints,
8730
_("unsupported const value attribute form: '%s'"),
8731
dwarf_form_name (attr->form));
8732
SYMBOL_VALUE (sym) = 0;
8733
SYMBOL_CLASS (sym) = LOC_CONST;
8739
/* Given an attr with a DW_FORM_dataN value in host byte order, sign-
8740
or zero-extend it as appropriate for the symbol's type. */
8742
dwarf2_const_value_data (struct attribute *attr,
8746
LONGEST l = DW_UNSND (attr);
8748
if (bits < sizeof (l) * 8)
8750
if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
8751
l &= ((LONGEST) 1 << bits) - 1;
8753
l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
8756
SYMBOL_VALUE (sym) = l;
8757
SYMBOL_CLASS (sym) = LOC_CONST;
8761
/* Return the type of the die in question using its DW_AT_type attribute. */
8763
static struct type *
8764
die_type (struct die_info *die, struct dwarf2_cu *cu)
8767
struct attribute *type_attr;
8768
struct die_info *type_die;
8770
type_attr = dwarf2_attr (die, DW_AT_type, cu);
8773
/* A missing DW_AT_type represents a void type. */
8774
return objfile_type (cu->objfile)->builtin_void;
8777
type_die = follow_die_ref_or_sig (die, type_attr, &cu);
8779
type = tag_type_to_type (type_die, cu);
8782
dump_die_for_error (type_die);
8783
error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8789
/* True iff CU's producer generates GNAT Ada auxiliary information
8790
that allows to find parallel types through that information instead
8791
of having to do expensive parallel lookups by type name. */
8794
need_gnat_info (struct dwarf2_cu *cu)
8796
/* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
8797
of GNAT produces this auxiliary information, without any indication
8798
that it is produced. Part of enhancing the FSF version of GNAT
8799
to produce that information will be to put in place an indicator
8800
that we can use in order to determine whether the descriptive type
8801
info is available or not. One suggestion that has been made is
8802
to use a new attribute, attached to the CU die. For now, assume
8803
that the descriptive type info is not available. */
8808
/* Return the auxiliary type of the die in question using its
8809
DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
8810
attribute is not present. */
8812
static struct type *
8813
die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
8816
struct attribute *type_attr;
8817
struct die_info *type_die;
8819
type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
8823
type_die = follow_die_ref (die, type_attr, &cu);
8824
type = tag_type_to_type (type_die, cu);
8827
dump_die_for_error (type_die);
8828
error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8834
/* If DIE has a descriptive_type attribute, then set the TYPE's
8835
descriptive type accordingly. */
8838
set_descriptive_type (struct type *type, struct die_info *die,
8839
struct dwarf2_cu *cu)
8841
struct type *descriptive_type = die_descriptive_type (die, cu);
8843
if (descriptive_type)
8845
ALLOCATE_GNAT_AUX_TYPE (type);
8846
TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
8850
/* Return the containing type of the die in question using its
8851
DW_AT_containing_type attribute. */
8853
static struct type *
8854
die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
8856
struct type *type = NULL;
8857
struct attribute *type_attr;
8858
struct die_info *type_die = NULL;
8860
type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
8863
type_die = follow_die_ref_or_sig (die, type_attr, &cu);
8864
type = tag_type_to_type (type_die, cu);
8869
dump_die_for_error (type_die);
8870
error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
8876
static struct type *
8877
tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
8879
struct type *this_type;
8881
this_type = read_type_die (die, cu);
8884
dump_die_for_error (die);
8885
error (_("Dwarf Error: Cannot find type of die [in module %s]"),
8891
static struct type *
8892
read_type_die (struct die_info *die, struct dwarf2_cu *cu)
8894
struct type *this_type;
8896
this_type = get_die_type (die, cu);
8902
case DW_TAG_class_type:
8903
case DW_TAG_interface_type:
8904
case DW_TAG_structure_type:
8905
case DW_TAG_union_type:
8906
this_type = read_structure_type (die, cu);
8908
case DW_TAG_enumeration_type:
8909
this_type = read_enumeration_type (die, cu);
8911
case DW_TAG_subprogram:
8912
case DW_TAG_subroutine_type:
8913
case DW_TAG_inlined_subroutine:
8914
this_type = read_subroutine_type (die, cu);
8916
case DW_TAG_array_type:
8917
this_type = read_array_type (die, cu);
8919
case DW_TAG_set_type:
8920
this_type = read_set_type (die, cu);
8922
case DW_TAG_pointer_type:
8923
this_type = read_tag_pointer_type (die, cu);
8925
case DW_TAG_ptr_to_member_type:
8926
this_type = read_tag_ptr_to_member_type (die, cu);
8928
case DW_TAG_reference_type:
8929
this_type = read_tag_reference_type (die, cu);
8931
case DW_TAG_const_type:
8932
this_type = read_tag_const_type (die, cu);
8934
case DW_TAG_volatile_type:
8935
this_type = read_tag_volatile_type (die, cu);
8937
case DW_TAG_string_type:
8938
this_type = read_tag_string_type (die, cu);
8940
case DW_TAG_typedef:
8941
this_type = read_typedef (die, cu);
8943
case DW_TAG_subrange_type:
8944
this_type = read_subrange_type (die, cu);
8946
case DW_TAG_base_type:
8947
this_type = read_base_type (die, cu);
8949
case DW_TAG_unspecified_type:
8950
this_type = read_unspecified_type (die, cu);
8952
case DW_TAG_namespace:
8953
this_type = read_namespace_type (die, cu);
8956
complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
8957
dwarf_tag_name (die->tag));
8964
/* Return the name of the namespace/class that DIE is defined within,
8965
or "" if we can't tell. The caller should not xfree the result.
8967
For example, if we're within the method foo() in the following
8977
then determine_prefix on foo's die will return "N::C". */
8980
determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
8982
struct die_info *parent, *spec_die;
8983
struct dwarf2_cu *spec_cu;
8984
struct type *parent_type;
8986
if (cu->language != language_cplus
8987
&& cu->language != language_java)
8990
/* We have to be careful in the presence of DW_AT_specification.
8991
For example, with GCC 3.4, given the code
8995
// Definition of N::foo.
8999
then we'll have a tree of DIEs like this:
9001
1: DW_TAG_compile_unit
9002
2: DW_TAG_namespace // N
9003
3: DW_TAG_subprogram // declaration of N::foo
9004
4: DW_TAG_subprogram // definition of N::foo
9005
DW_AT_specification // refers to die #3
9007
Thus, when processing die #4, we have to pretend that we're in
9008
the context of its DW_AT_specification, namely the contex of die
9011
spec_die = die_specification (die, &spec_cu);
9012
if (spec_die == NULL)
9013
parent = die->parent;
9016
parent = spec_die->parent;
9023
switch (parent->tag)
9025
case DW_TAG_namespace:
9026
parent_type = read_type_die (parent, cu);
9027
/* We give a name to even anonymous namespaces. */
9028
return TYPE_TAG_NAME (parent_type);
9029
case DW_TAG_class_type:
9030
case DW_TAG_interface_type:
9031
case DW_TAG_structure_type:
9032
case DW_TAG_union_type:
9033
parent_type = read_type_die (parent, cu);
9034
if (TYPE_TAG_NAME (parent_type) != NULL)
9035
return TYPE_TAG_NAME (parent_type);
9037
/* An anonymous structure is only allowed non-static data
9038
members; no typedefs, no member functions, et cetera.
9039
So it does not need a prefix. */
9042
return determine_prefix (parent, cu);
9046
/* Return a newly-allocated string formed by concatenating PREFIX and
9047
SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
9048
simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
9049
perform an obconcat, otherwise allocate storage for the result. The CU argument
9050
is used to determine the language and hence, the appropriate separator. */
9052
#define MAX_SEP_LEN 2 /* sizeof ("::") */
9055
typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
9056
struct dwarf2_cu *cu)
9060
if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
9062
else if (cu->language == language_java)
9074
char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
9075
strcpy (retval, prefix);
9076
strcat (retval, sep);
9077
strcat (retval, suffix);
9082
/* We have an obstack. */
9083
return obconcat (obs, prefix, sep, suffix);
9087
/* Return sibling of die, NULL if no sibling. */
9089
static struct die_info *
9090
sibling_die (struct die_info *die)
9092
return die->sibling;
9095
/* Get linkage name of a die, return NULL if not found. */
9098
dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
9100
struct attribute *attr;
9102
attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
9103
if (attr && DW_STRING (attr))
9104
return DW_STRING (attr);
9105
return dwarf2_name (die, cu);
9108
/* Get name of a die, return NULL if not found. */
9111
dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu,
9112
struct obstack *obstack)
9114
if (name && cu->language == language_cplus)
9116
char *canon_name = cp_canonicalize_string (name);
9118
if (canon_name != NULL)
9120
if (strcmp (canon_name, name) != 0)
9121
name = obsavestring (canon_name, strlen (canon_name),
9130
/* Get name of a die, return NULL if not found. */
9133
dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
9135
struct attribute *attr;
9137
attr = dwarf2_attr (die, DW_AT_name, cu);
9138
if (!attr || !DW_STRING (attr))
9143
case DW_TAG_compile_unit:
9144
/* Compilation units have a DW_AT_name that is a filename, not
9145
a source language identifier. */
9146
case DW_TAG_enumeration_type:
9147
case DW_TAG_enumerator:
9148
/* These tags always have simple identifiers already; no need
9149
to canonicalize them. */
9150
return DW_STRING (attr);
9152
if (!DW_STRING_IS_CANONICAL (attr))
9155
= dwarf2_canonicalize_name (DW_STRING (attr), cu,
9156
&cu->objfile->objfile_obstack);
9157
DW_STRING_IS_CANONICAL (attr) = 1;
9159
return DW_STRING (attr);
9163
/* Return the die that this die in an extension of, or NULL if there
9164
is none. *EXT_CU is the CU containing DIE on input, and the CU
9165
containing the return value on output. */
9167
static struct die_info *
9168
dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
9170
struct attribute *attr;
9172
attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
9176
return follow_die_ref (die, attr, ext_cu);
9179
/* Convert a DIE tag into its string name. */
9182
dwarf_tag_name (unsigned tag)
9186
case DW_TAG_padding:
9187
return "DW_TAG_padding";
9188
case DW_TAG_array_type:
9189
return "DW_TAG_array_type";
9190
case DW_TAG_class_type:
9191
return "DW_TAG_class_type";
9192
case DW_TAG_entry_point:
9193
return "DW_TAG_entry_point";
9194
case DW_TAG_enumeration_type:
9195
return "DW_TAG_enumeration_type";
9196
case DW_TAG_formal_parameter:
9197
return "DW_TAG_formal_parameter";
9198
case DW_TAG_imported_declaration:
9199
return "DW_TAG_imported_declaration";
9201
return "DW_TAG_label";
9202
case DW_TAG_lexical_block:
9203
return "DW_TAG_lexical_block";
9205
return "DW_TAG_member";
9206
case DW_TAG_pointer_type:
9207
return "DW_TAG_pointer_type";
9208
case DW_TAG_reference_type:
9209
return "DW_TAG_reference_type";
9210
case DW_TAG_compile_unit:
9211
return "DW_TAG_compile_unit";
9212
case DW_TAG_string_type:
9213
return "DW_TAG_string_type";
9214
case DW_TAG_structure_type:
9215
return "DW_TAG_structure_type";
9216
case DW_TAG_subroutine_type:
9217
return "DW_TAG_subroutine_type";
9218
case DW_TAG_typedef:
9219
return "DW_TAG_typedef";
9220
case DW_TAG_union_type:
9221
return "DW_TAG_union_type";
9222
case DW_TAG_unspecified_parameters:
9223
return "DW_TAG_unspecified_parameters";
9224
case DW_TAG_variant:
9225
return "DW_TAG_variant";
9226
case DW_TAG_common_block:
9227
return "DW_TAG_common_block";
9228
case DW_TAG_common_inclusion:
9229
return "DW_TAG_common_inclusion";
9230
case DW_TAG_inheritance:
9231
return "DW_TAG_inheritance";
9232
case DW_TAG_inlined_subroutine:
9233
return "DW_TAG_inlined_subroutine";
9235
return "DW_TAG_module";
9236
case DW_TAG_ptr_to_member_type:
9237
return "DW_TAG_ptr_to_member_type";
9238
case DW_TAG_set_type:
9239
return "DW_TAG_set_type";
9240
case DW_TAG_subrange_type:
9241
return "DW_TAG_subrange_type";
9242
case DW_TAG_with_stmt:
9243
return "DW_TAG_with_stmt";
9244
case DW_TAG_access_declaration:
9245
return "DW_TAG_access_declaration";
9246
case DW_TAG_base_type:
9247
return "DW_TAG_base_type";
9248
case DW_TAG_catch_block:
9249
return "DW_TAG_catch_block";
9250
case DW_TAG_const_type:
9251
return "DW_TAG_const_type";
9252
case DW_TAG_constant:
9253
return "DW_TAG_constant";
9254
case DW_TAG_enumerator:
9255
return "DW_TAG_enumerator";
9256
case DW_TAG_file_type:
9257
return "DW_TAG_file_type";
9259
return "DW_TAG_friend";
9260
case DW_TAG_namelist:
9261
return "DW_TAG_namelist";
9262
case DW_TAG_namelist_item:
9263
return "DW_TAG_namelist_item";
9264
case DW_TAG_packed_type:
9265
return "DW_TAG_packed_type";
9266
case DW_TAG_subprogram:
9267
return "DW_TAG_subprogram";
9268
case DW_TAG_template_type_param:
9269
return "DW_TAG_template_type_param";
9270
case DW_TAG_template_value_param:
9271
return "DW_TAG_template_value_param";
9272
case DW_TAG_thrown_type:
9273
return "DW_TAG_thrown_type";
9274
case DW_TAG_try_block:
9275
return "DW_TAG_try_block";
9276
case DW_TAG_variant_part:
9277
return "DW_TAG_variant_part";
9278
case DW_TAG_variable:
9279
return "DW_TAG_variable";
9280
case DW_TAG_volatile_type:
9281
return "DW_TAG_volatile_type";
9282
case DW_TAG_dwarf_procedure:
9283
return "DW_TAG_dwarf_procedure";
9284
case DW_TAG_restrict_type:
9285
return "DW_TAG_restrict_type";
9286
case DW_TAG_interface_type:
9287
return "DW_TAG_interface_type";
9288
case DW_TAG_namespace:
9289
return "DW_TAG_namespace";
9290
case DW_TAG_imported_module:
9291
return "DW_TAG_imported_module";
9292
case DW_TAG_unspecified_type:
9293
return "DW_TAG_unspecified_type";
9294
case DW_TAG_partial_unit:
9295
return "DW_TAG_partial_unit";
9296
case DW_TAG_imported_unit:
9297
return "DW_TAG_imported_unit";
9298
case DW_TAG_condition:
9299
return "DW_TAG_condition";
9300
case DW_TAG_shared_type:
9301
return "DW_TAG_shared_type";
9302
case DW_TAG_type_unit:
9303
return "DW_TAG_type_unit";
9304
case DW_TAG_MIPS_loop:
9305
return "DW_TAG_MIPS_loop";
9306
case DW_TAG_HP_array_descriptor:
9307
return "DW_TAG_HP_array_descriptor";
9308
case DW_TAG_format_label:
9309
return "DW_TAG_format_label";
9310
case DW_TAG_function_template:
9311
return "DW_TAG_function_template";
9312
case DW_TAG_class_template:
9313
return "DW_TAG_class_template";
9314
case DW_TAG_GNU_BINCL:
9315
return "DW_TAG_GNU_BINCL";
9316
case DW_TAG_GNU_EINCL:
9317
return "DW_TAG_GNU_EINCL";
9318
case DW_TAG_upc_shared_type:
9319
return "DW_TAG_upc_shared_type";
9320
case DW_TAG_upc_strict_type:
9321
return "DW_TAG_upc_strict_type";
9322
case DW_TAG_upc_relaxed_type:
9323
return "DW_TAG_upc_relaxed_type";
9324
case DW_TAG_PGI_kanji_type:
9325
return "DW_TAG_PGI_kanji_type";
9326
case DW_TAG_PGI_interface_block:
9327
return "DW_TAG_PGI_interface_block";
9329
return "DW_TAG_<unknown>";
9333
/* Convert a DWARF attribute code into its string name. */
9336
dwarf_attr_name (unsigned attr)
9341
return "DW_AT_sibling";
9342
case DW_AT_location:
9343
return "DW_AT_location";
9345
return "DW_AT_name";
9346
case DW_AT_ordering:
9347
return "DW_AT_ordering";
9348
case DW_AT_subscr_data:
9349
return "DW_AT_subscr_data";
9350
case DW_AT_byte_size:
9351
return "DW_AT_byte_size";
9352
case DW_AT_bit_offset:
9353
return "DW_AT_bit_offset";
9354
case DW_AT_bit_size:
9355
return "DW_AT_bit_size";
9356
case DW_AT_element_list:
9357
return "DW_AT_element_list";
9358
case DW_AT_stmt_list:
9359
return "DW_AT_stmt_list";
9361
return "DW_AT_low_pc";
9363
return "DW_AT_high_pc";
9364
case DW_AT_language:
9365
return "DW_AT_language";
9367
return "DW_AT_member";
9369
return "DW_AT_discr";
9370
case DW_AT_discr_value:
9371
return "DW_AT_discr_value";
9372
case DW_AT_visibility:
9373
return "DW_AT_visibility";
9375
return "DW_AT_import";
9376
case DW_AT_string_length:
9377
return "DW_AT_string_length";
9378
case DW_AT_common_reference:
9379
return "DW_AT_common_reference";
9380
case DW_AT_comp_dir:
9381
return "DW_AT_comp_dir";
9382
case DW_AT_const_value:
9383
return "DW_AT_const_value";
9384
case DW_AT_containing_type:
9385
return "DW_AT_containing_type";
9386
case DW_AT_default_value:
9387
return "DW_AT_default_value";
9389
return "DW_AT_inline";
9390
case DW_AT_is_optional:
9391
return "DW_AT_is_optional";
9392
case DW_AT_lower_bound:
9393
return "DW_AT_lower_bound";
9394
case DW_AT_producer:
9395
return "DW_AT_producer";
9396
case DW_AT_prototyped:
9397
return "DW_AT_prototyped";
9398
case DW_AT_return_addr:
9399
return "DW_AT_return_addr";
9400
case DW_AT_start_scope:
9401
return "DW_AT_start_scope";
9402
case DW_AT_bit_stride:
9403
return "DW_AT_bit_stride";
9404
case DW_AT_upper_bound:
9405
return "DW_AT_upper_bound";
9406
case DW_AT_abstract_origin:
9407
return "DW_AT_abstract_origin";
9408
case DW_AT_accessibility:
9409
return "DW_AT_accessibility";
9410
case DW_AT_address_class:
9411
return "DW_AT_address_class";
9412
case DW_AT_artificial:
9413
return "DW_AT_artificial";
9414
case DW_AT_base_types:
9415
return "DW_AT_base_types";
9416
case DW_AT_calling_convention:
9417
return "DW_AT_calling_convention";
9419
return "DW_AT_count";
9420
case DW_AT_data_member_location:
9421
return "DW_AT_data_member_location";
9422
case DW_AT_decl_column:
9423
return "DW_AT_decl_column";
9424
case DW_AT_decl_file:
9425
return "DW_AT_decl_file";
9426
case DW_AT_decl_line:
9427
return "DW_AT_decl_line";
9428
case DW_AT_declaration:
9429
return "DW_AT_declaration";
9430
case DW_AT_discr_list:
9431
return "DW_AT_discr_list";
9432
case DW_AT_encoding:
9433
return "DW_AT_encoding";
9434
case DW_AT_external:
9435
return "DW_AT_external";
9436
case DW_AT_frame_base:
9437
return "DW_AT_frame_base";
9439
return "DW_AT_friend";
9440
case DW_AT_identifier_case:
9441
return "DW_AT_identifier_case";
9442
case DW_AT_macro_info:
9443
return "DW_AT_macro_info";
9444
case DW_AT_namelist_items:
9445
return "DW_AT_namelist_items";
9446
case DW_AT_priority:
9447
return "DW_AT_priority";
9449
return "DW_AT_segment";
9450
case DW_AT_specification:
9451
return "DW_AT_specification";
9452
case DW_AT_static_link:
9453
return "DW_AT_static_link";
9455
return "DW_AT_type";
9456
case DW_AT_use_location:
9457
return "DW_AT_use_location";
9458
case DW_AT_variable_parameter:
9459
return "DW_AT_variable_parameter";
9460
case DW_AT_virtuality:
9461
return "DW_AT_virtuality";
9462
case DW_AT_vtable_elem_location:
9463
return "DW_AT_vtable_elem_location";
9464
/* DWARF 3 values. */
9465
case DW_AT_allocated:
9466
return "DW_AT_allocated";
9467
case DW_AT_associated:
9468
return "DW_AT_associated";
9469
case DW_AT_data_location:
9470
return "DW_AT_data_location";
9471
case DW_AT_byte_stride:
9472
return "DW_AT_byte_stride";
9473
case DW_AT_entry_pc:
9474
return "DW_AT_entry_pc";
9475
case DW_AT_use_UTF8:
9476
return "DW_AT_use_UTF8";
9477
case DW_AT_extension:
9478
return "DW_AT_extension";
9480
return "DW_AT_ranges";
9481
case DW_AT_trampoline:
9482
return "DW_AT_trampoline";
9483
case DW_AT_call_column:
9484
return "DW_AT_call_column";
9485
case DW_AT_call_file:
9486
return "DW_AT_call_file";
9487
case DW_AT_call_line:
9488
return "DW_AT_call_line";
9489
case DW_AT_description:
9490
return "DW_AT_description";
9491
case DW_AT_binary_scale:
9492
return "DW_AT_binary_scale";
9493
case DW_AT_decimal_scale:
9494
return "DW_AT_decimal_scale";
9496
return "DW_AT_small";
9497
case DW_AT_decimal_sign:
9498
return "DW_AT_decimal_sign";
9499
case DW_AT_digit_count:
9500
return "DW_AT_digit_count";
9501
case DW_AT_picture_string:
9502
return "DW_AT_picture_string";
9504
return "DW_AT_mutable";
9505
case DW_AT_threads_scaled:
9506
return "DW_AT_threads_scaled";
9507
case DW_AT_explicit:
9508
return "DW_AT_explicit";
9509
case DW_AT_object_pointer:
9510
return "DW_AT_object_pointer";
9511
case DW_AT_endianity:
9512
return "DW_AT_endianity";
9513
case DW_AT_elemental:
9514
return "DW_AT_elemental";
9516
return "DW_AT_pure";
9517
case DW_AT_recursive:
9518
return "DW_AT_recursive";
9519
/* DWARF 4 values. */
9520
case DW_AT_signature:
9521
return "DW_AT_signature";
9522
/* SGI/MIPS extensions. */
9523
#ifdef MIPS /* collides with DW_AT_HP_block_index */
9524
case DW_AT_MIPS_fde:
9525
return "DW_AT_MIPS_fde";
9527
case DW_AT_MIPS_loop_begin:
9528
return "DW_AT_MIPS_loop_begin";
9529
case DW_AT_MIPS_tail_loop_begin:
9530
return "DW_AT_MIPS_tail_loop_begin";
9531
case DW_AT_MIPS_epilog_begin:
9532
return "DW_AT_MIPS_epilog_begin";
9533
case DW_AT_MIPS_loop_unroll_factor:
9534
return "DW_AT_MIPS_loop_unroll_factor";
9535
case DW_AT_MIPS_software_pipeline_depth:
9536
return "DW_AT_MIPS_software_pipeline_depth";
9537
case DW_AT_MIPS_linkage_name:
9538
return "DW_AT_MIPS_linkage_name";
9539
case DW_AT_MIPS_stride:
9540
return "DW_AT_MIPS_stride";
9541
case DW_AT_MIPS_abstract_name:
9542
return "DW_AT_MIPS_abstract_name";
9543
case DW_AT_MIPS_clone_origin:
9544
return "DW_AT_MIPS_clone_origin";
9545
case DW_AT_MIPS_has_inlines:
9546
return "DW_AT_MIPS_has_inlines";
9547
/* HP extensions. */
9548
#ifndef MIPS /* collides with DW_AT_MIPS_fde */
9549
case DW_AT_HP_block_index:
9550
return "DW_AT_HP_block_index";
9552
case DW_AT_HP_unmodifiable:
9553
return "DW_AT_HP_unmodifiable";
9554
case DW_AT_HP_actuals_stmt_list:
9555
return "DW_AT_HP_actuals_stmt_list";
9556
case DW_AT_HP_proc_per_section:
9557
return "DW_AT_HP_proc_per_section";
9558
case DW_AT_HP_raw_data_ptr:
9559
return "DW_AT_HP_raw_data_ptr";
9560
case DW_AT_HP_pass_by_reference:
9561
return "DW_AT_HP_pass_by_reference";
9562
case DW_AT_HP_opt_level:
9563
return "DW_AT_HP_opt_level";
9564
case DW_AT_HP_prof_version_id:
9565
return "DW_AT_HP_prof_version_id";
9566
case DW_AT_HP_opt_flags:
9567
return "DW_AT_HP_opt_flags";
9568
case DW_AT_HP_cold_region_low_pc:
9569
return "DW_AT_HP_cold_region_low_pc";
9570
case DW_AT_HP_cold_region_high_pc:
9571
return "DW_AT_HP_cold_region_high_pc";
9572
case DW_AT_HP_all_variables_modifiable:
9573
return "DW_AT_HP_all_variables_modifiable";
9574
case DW_AT_HP_linkage_name:
9575
return "DW_AT_HP_linkage_name";
9576
case DW_AT_HP_prof_flags:
9577
return "DW_AT_HP_prof_flags";
9578
/* GNU extensions. */
9579
case DW_AT_sf_names:
9580
return "DW_AT_sf_names";
9581
case DW_AT_src_info:
9582
return "DW_AT_src_info";
9583
case DW_AT_mac_info:
9584
return "DW_AT_mac_info";
9585
case DW_AT_src_coords:
9586
return "DW_AT_src_coords";
9587
case DW_AT_body_begin:
9588
return "DW_AT_body_begin";
9589
case DW_AT_body_end:
9590
return "DW_AT_body_end";
9591
case DW_AT_GNU_vector:
9592
return "DW_AT_GNU_vector";
9593
/* VMS extensions. */
9594
case DW_AT_VMS_rtnbeg_pd_address:
9595
return "DW_AT_VMS_rtnbeg_pd_address";
9596
/* UPC extension. */
9597
case DW_AT_upc_threads_scaled:
9598
return "DW_AT_upc_threads_scaled";
9599
/* PGI (STMicroelectronics) extensions. */
9600
case DW_AT_PGI_lbase:
9601
return "DW_AT_PGI_lbase";
9602
case DW_AT_PGI_soffset:
9603
return "DW_AT_PGI_soffset";
9604
case DW_AT_PGI_lstride:
9605
return "DW_AT_PGI_lstride";
9607
return "DW_AT_<unknown>";
9611
/* Convert a DWARF value form code into its string name. */
9614
dwarf_form_name (unsigned form)
9619
return "DW_FORM_addr";
9620
case DW_FORM_block2:
9621
return "DW_FORM_block2";
9622
case DW_FORM_block4:
9623
return "DW_FORM_block4";
9625
return "DW_FORM_data2";
9627
return "DW_FORM_data4";
9629
return "DW_FORM_data8";
9630
case DW_FORM_string:
9631
return "DW_FORM_string";
9633
return "DW_FORM_block";
9634
case DW_FORM_block1:
9635
return "DW_FORM_block1";
9637
return "DW_FORM_data1";
9639
return "DW_FORM_flag";
9641
return "DW_FORM_sdata";
9643
return "DW_FORM_strp";
9645
return "DW_FORM_udata";
9646
case DW_FORM_ref_addr:
9647
return "DW_FORM_ref_addr";
9649
return "DW_FORM_ref1";
9651
return "DW_FORM_ref2";
9653
return "DW_FORM_ref4";
9655
return "DW_FORM_ref8";
9656
case DW_FORM_ref_udata:
9657
return "DW_FORM_ref_udata";
9658
case DW_FORM_indirect:
9659
return "DW_FORM_indirect";
9660
case DW_FORM_sec_offset:
9661
return "DW_FORM_sec_offset";
9662
case DW_FORM_exprloc:
9663
return "DW_FORM_exprloc";
9664
case DW_FORM_flag_present:
9665
return "DW_FORM_flag_present";
9667
return "DW_FORM_sig8";
9669
return "DW_FORM_<unknown>";
9673
/* Convert a DWARF stack opcode into its string name. */
9676
dwarf_stack_op_name (unsigned op)
9681
return "DW_OP_addr";
9683
return "DW_OP_deref";
9685
return "DW_OP_const1u";
9687
return "DW_OP_const1s";
9689
return "DW_OP_const2u";
9691
return "DW_OP_const2s";
9693
return "DW_OP_const4u";
9695
return "DW_OP_const4s";
9697
return "DW_OP_const8u";
9699
return "DW_OP_const8s";
9701
return "DW_OP_constu";
9703
return "DW_OP_consts";
9707
return "DW_OP_drop";
9709
return "DW_OP_over";
9711
return "DW_OP_pick";
9713
return "DW_OP_swap";
9717
return "DW_OP_xderef";
9725
return "DW_OP_minus";
9737
return "DW_OP_plus";
9738
case DW_OP_plus_uconst:
9739
return "DW_OP_plus_uconst";
9745
return "DW_OP_shra";
9763
return "DW_OP_skip";
9765
return "DW_OP_lit0";
9767
return "DW_OP_lit1";
9769
return "DW_OP_lit2";
9771
return "DW_OP_lit3";
9773
return "DW_OP_lit4";
9775
return "DW_OP_lit5";
9777
return "DW_OP_lit6";
9779
return "DW_OP_lit7";
9781
return "DW_OP_lit8";
9783
return "DW_OP_lit9";
9785
return "DW_OP_lit10";
9787
return "DW_OP_lit11";
9789
return "DW_OP_lit12";
9791
return "DW_OP_lit13";
9793
return "DW_OP_lit14";
9795
return "DW_OP_lit15";
9797
return "DW_OP_lit16";
9799
return "DW_OP_lit17";
9801
return "DW_OP_lit18";
9803
return "DW_OP_lit19";
9805
return "DW_OP_lit20";
9807
return "DW_OP_lit21";
9809
return "DW_OP_lit22";
9811
return "DW_OP_lit23";
9813
return "DW_OP_lit24";
9815
return "DW_OP_lit25";
9817
return "DW_OP_lit26";
9819
return "DW_OP_lit27";
9821
return "DW_OP_lit28";
9823
return "DW_OP_lit29";
9825
return "DW_OP_lit30";
9827
return "DW_OP_lit31";
9829
return "DW_OP_reg0";
9831
return "DW_OP_reg1";
9833
return "DW_OP_reg2";
9835
return "DW_OP_reg3";
9837
return "DW_OP_reg4";
9839
return "DW_OP_reg5";
9841
return "DW_OP_reg6";
9843
return "DW_OP_reg7";
9845
return "DW_OP_reg8";
9847
return "DW_OP_reg9";
9849
return "DW_OP_reg10";
9851
return "DW_OP_reg11";
9853
return "DW_OP_reg12";
9855
return "DW_OP_reg13";
9857
return "DW_OP_reg14";
9859
return "DW_OP_reg15";
9861
return "DW_OP_reg16";
9863
return "DW_OP_reg17";
9865
return "DW_OP_reg18";
9867
return "DW_OP_reg19";
9869
return "DW_OP_reg20";
9871
return "DW_OP_reg21";
9873
return "DW_OP_reg22";
9875
return "DW_OP_reg23";
9877
return "DW_OP_reg24";
9879
return "DW_OP_reg25";
9881
return "DW_OP_reg26";
9883
return "DW_OP_reg27";
9885
return "DW_OP_reg28";
9887
return "DW_OP_reg29";
9889
return "DW_OP_reg30";
9891
return "DW_OP_reg31";
9893
return "DW_OP_breg0";
9895
return "DW_OP_breg1";
9897
return "DW_OP_breg2";
9899
return "DW_OP_breg3";
9901
return "DW_OP_breg4";
9903
return "DW_OP_breg5";
9905
return "DW_OP_breg6";
9907
return "DW_OP_breg7";
9909
return "DW_OP_breg8";
9911
return "DW_OP_breg9";
9913
return "DW_OP_breg10";
9915
return "DW_OP_breg11";
9917
return "DW_OP_breg12";
9919
return "DW_OP_breg13";
9921
return "DW_OP_breg14";
9923
return "DW_OP_breg15";
9925
return "DW_OP_breg16";
9927
return "DW_OP_breg17";
9929
return "DW_OP_breg18";
9931
return "DW_OP_breg19";
9933
return "DW_OP_breg20";
9935
return "DW_OP_breg21";
9937
return "DW_OP_breg22";
9939
return "DW_OP_breg23";
9941
return "DW_OP_breg24";
9943
return "DW_OP_breg25";
9945
return "DW_OP_breg26";
9947
return "DW_OP_breg27";
9949
return "DW_OP_breg28";
9951
return "DW_OP_breg29";
9953
return "DW_OP_breg30";
9955
return "DW_OP_breg31";
9957
return "DW_OP_regx";
9959
return "DW_OP_fbreg";
9961
return "DW_OP_bregx";
9963
return "DW_OP_piece";
9964
case DW_OP_deref_size:
9965
return "DW_OP_deref_size";
9966
case DW_OP_xderef_size:
9967
return "DW_OP_xderef_size";
9970
/* DWARF 3 extensions. */
9971
case DW_OP_push_object_address:
9972
return "DW_OP_push_object_address";
9974
return "DW_OP_call2";
9976
return "DW_OP_call4";
9977
case DW_OP_call_ref:
9978
return "DW_OP_call_ref";
9979
/* GNU extensions. */
9980
case DW_OP_form_tls_address:
9981
return "DW_OP_form_tls_address";
9982
case DW_OP_call_frame_cfa:
9983
return "DW_OP_call_frame_cfa";
9984
case DW_OP_bit_piece:
9985
return "DW_OP_bit_piece";
9986
case DW_OP_GNU_push_tls_address:
9987
return "DW_OP_GNU_push_tls_address";
9988
case DW_OP_GNU_uninit:
9989
return "DW_OP_GNU_uninit";
9990
/* HP extensions. */
9991
case DW_OP_HP_is_value:
9992
return "DW_OP_HP_is_value";
9993
case DW_OP_HP_fltconst4:
9994
return "DW_OP_HP_fltconst4";
9995
case DW_OP_HP_fltconst8:
9996
return "DW_OP_HP_fltconst8";
9997
case DW_OP_HP_mod_range:
9998
return "DW_OP_HP_mod_range";
9999
case DW_OP_HP_unmod_range:
10000
return "DW_OP_HP_unmod_range";
10002
return "DW_OP_HP_tls";
10004
return "OP_<unknown>";
10009
dwarf_bool_name (unsigned mybool)
10017
/* Convert a DWARF type code into its string name. */
10020
dwarf_type_encoding_name (unsigned enc)
10025
return "DW_ATE_void";
10026
case DW_ATE_address:
10027
return "DW_ATE_address";
10028
case DW_ATE_boolean:
10029
return "DW_ATE_boolean";
10030
case DW_ATE_complex_float:
10031
return "DW_ATE_complex_float";
10033
return "DW_ATE_float";
10034
case DW_ATE_signed:
10035
return "DW_ATE_signed";
10036
case DW_ATE_signed_char:
10037
return "DW_ATE_signed_char";
10038
case DW_ATE_unsigned:
10039
return "DW_ATE_unsigned";
10040
case DW_ATE_unsigned_char:
10041
return "DW_ATE_unsigned_char";
10043
case DW_ATE_imaginary_float:
10044
return "DW_ATE_imaginary_float";
10045
case DW_ATE_packed_decimal:
10046
return "DW_ATE_packed_decimal";
10047
case DW_ATE_numeric_string:
10048
return "DW_ATE_numeric_string";
10049
case DW_ATE_edited:
10050
return "DW_ATE_edited";
10051
case DW_ATE_signed_fixed:
10052
return "DW_ATE_signed_fixed";
10053
case DW_ATE_unsigned_fixed:
10054
return "DW_ATE_unsigned_fixed";
10055
case DW_ATE_decimal_float:
10056
return "DW_ATE_decimal_float";
10057
/* HP extensions. */
10058
case DW_ATE_HP_float80:
10059
return "DW_ATE_HP_float80";
10060
case DW_ATE_HP_complex_float80:
10061
return "DW_ATE_HP_complex_float80";
10062
case DW_ATE_HP_float128:
10063
return "DW_ATE_HP_float128";
10064
case DW_ATE_HP_complex_float128:
10065
return "DW_ATE_HP_complex_float128";
10066
case DW_ATE_HP_floathpintel:
10067
return "DW_ATE_HP_floathpintel";
10068
case DW_ATE_HP_imaginary_float80:
10069
return "DW_ATE_HP_imaginary_float80";
10070
case DW_ATE_HP_imaginary_float128:
10071
return "DW_ATE_HP_imaginary_float128";
10073
return "DW_ATE_<unknown>";
10077
/* Convert a DWARF call frame info operation to its string name. */
10081
dwarf_cfi_name (unsigned cfi_opc)
10085
case DW_CFA_advance_loc:
10086
return "DW_CFA_advance_loc";
10087
case DW_CFA_offset:
10088
return "DW_CFA_offset";
10089
case DW_CFA_restore:
10090
return "DW_CFA_restore";
10092
return "DW_CFA_nop";
10093
case DW_CFA_set_loc:
10094
return "DW_CFA_set_loc";
10095
case DW_CFA_advance_loc1:
10096
return "DW_CFA_advance_loc1";
10097
case DW_CFA_advance_loc2:
10098
return "DW_CFA_advance_loc2";
10099
case DW_CFA_advance_loc4:
10100
return "DW_CFA_advance_loc4";
10101
case DW_CFA_offset_extended:
10102
return "DW_CFA_offset_extended";
10103
case DW_CFA_restore_extended:
10104
return "DW_CFA_restore_extended";
10105
case DW_CFA_undefined:
10106
return "DW_CFA_undefined";
10107
case DW_CFA_same_value:
10108
return "DW_CFA_same_value";
10109
case DW_CFA_register:
10110
return "DW_CFA_register";
10111
case DW_CFA_remember_state:
10112
return "DW_CFA_remember_state";
10113
case DW_CFA_restore_state:
10114
return "DW_CFA_restore_state";
10115
case DW_CFA_def_cfa:
10116
return "DW_CFA_def_cfa";
10117
case DW_CFA_def_cfa_register:
10118
return "DW_CFA_def_cfa_register";
10119
case DW_CFA_def_cfa_offset:
10120
return "DW_CFA_def_cfa_offset";
10122
case DW_CFA_def_cfa_expression:
10123
return "DW_CFA_def_cfa_expression";
10124
case DW_CFA_expression:
10125
return "DW_CFA_expression";
10126
case DW_CFA_offset_extended_sf:
10127
return "DW_CFA_offset_extended_sf";
10128
case DW_CFA_def_cfa_sf:
10129
return "DW_CFA_def_cfa_sf";
10130
case DW_CFA_def_cfa_offset_sf:
10131
return "DW_CFA_def_cfa_offset_sf";
10132
case DW_CFA_val_offset:
10133
return "DW_CFA_val_offset";
10134
case DW_CFA_val_offset_sf:
10135
return "DW_CFA_val_offset_sf";
10136
case DW_CFA_val_expression:
10137
return "DW_CFA_val_expression";
10138
/* SGI/MIPS specific. */
10139
case DW_CFA_MIPS_advance_loc8:
10140
return "DW_CFA_MIPS_advance_loc8";
10141
/* GNU extensions. */
10142
case DW_CFA_GNU_window_save:
10143
return "DW_CFA_GNU_window_save";
10144
case DW_CFA_GNU_args_size:
10145
return "DW_CFA_GNU_args_size";
10146
case DW_CFA_GNU_negative_offset_extended:
10147
return "DW_CFA_GNU_negative_offset_extended";
10149
return "DW_CFA_<unknown>";
10155
dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
10159
print_spaces (indent, f);
10160
fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
10161
dwarf_tag_name (die->tag), die->abbrev, die->offset);
10163
if (die->parent != NULL)
10165
print_spaces (indent, f);
10166
fprintf_unfiltered (f, " parent at offset: 0x%x\n",
10167
die->parent->offset);
10170
print_spaces (indent, f);
10171
fprintf_unfiltered (f, " has children: %s\n",
10172
dwarf_bool_name (die->child != NULL));
10174
print_spaces (indent, f);
10175
fprintf_unfiltered (f, " attributes:\n");
10177
for (i = 0; i < die->num_attrs; ++i)
10179
print_spaces (indent, f);
10180
fprintf_unfiltered (f, " %s (%s) ",
10181
dwarf_attr_name (die->attrs[i].name),
10182
dwarf_form_name (die->attrs[i].form));
10184
switch (die->attrs[i].form)
10186
case DW_FORM_ref_addr:
10188
fprintf_unfiltered (f, "address: ");
10189
fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
10191
case DW_FORM_block2:
10192
case DW_FORM_block4:
10193
case DW_FORM_block:
10194
case DW_FORM_block1:
10195
fprintf_unfiltered (f, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
10200
fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
10201
(long) (DW_ADDR (&die->attrs[i])));
10203
case DW_FORM_data1:
10204
case DW_FORM_data2:
10205
case DW_FORM_data4:
10206
case DW_FORM_data8:
10207
case DW_FORM_udata:
10208
case DW_FORM_sdata:
10209
fprintf_unfiltered (f, "constant: %s",
10210
pulongest (DW_UNSND (&die->attrs[i])));
10213
if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL)
10214
fprintf_unfiltered (f, "signatured type, offset: 0x%x",
10215
DW_SIGNATURED_TYPE (&die->attrs[i])->offset);
10217
fprintf_unfiltered (f, "signatured type, offset: unknown");
10219
case DW_FORM_string:
10221
fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
10222
DW_STRING (&die->attrs[i])
10223
? DW_STRING (&die->attrs[i]) : "",
10224
DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
10227
if (DW_UNSND (&die->attrs[i]))
10228
fprintf_unfiltered (f, "flag: TRUE");
10230
fprintf_unfiltered (f, "flag: FALSE");
10232
case DW_FORM_indirect:
10233
/* the reader will have reduced the indirect form to
10234
the "base form" so this form should not occur */
10235
fprintf_unfiltered (f, "unexpected attribute form: DW_FORM_indirect");
10238
fprintf_unfiltered (f, "unsupported attribute form: %d.",
10239
die->attrs[i].form);
10242
fprintf_unfiltered (f, "\n");
10247
dump_die_for_error (struct die_info *die)
10249
dump_die_shallow (gdb_stderr, 0, die);
10253
dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
10255
int indent = level * 4;
10257
gdb_assert (die != NULL);
10259
if (level >= max_level)
10262
dump_die_shallow (f, indent, die);
10264
if (die->child != NULL)
10266
print_spaces (indent, f);
10267
fprintf_unfiltered (f, " Children:");
10268
if (level + 1 < max_level)
10270
fprintf_unfiltered (f, "\n");
10271
dump_die_1 (f, level + 1, max_level, die->child);
10275
fprintf_unfiltered (f, " [not printed, max nesting level reached]\n");
10279
if (die->sibling != NULL && level > 0)
10281
dump_die_1 (f, level, max_level, die->sibling);
10285
/* This is called from the pdie macro in gdbinit.in.
10286
It's not static so gcc will keep a copy callable from gdb. */
10289
dump_die (struct die_info *die, int max_level)
10291
dump_die_1 (gdb_stdlog, 0, max_level, die);
10295
store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
10299
slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset, INSERT);
10305
is_ref_attr (struct attribute *attr)
10307
switch (attr->form)
10309
case DW_FORM_ref_addr:
10314
case DW_FORM_ref_udata:
10321
static unsigned int
10322
dwarf2_get_ref_die_offset (struct attribute *attr)
10324
if (is_ref_attr (attr))
10325
return DW_ADDR (attr);
10327
complaint (&symfile_complaints,
10328
_("unsupported die ref attribute form: '%s'"),
10329
dwarf_form_name (attr->form));
10333
/* Return the constant value held by ATTR. Return DEFAULT_VALUE if
10334
* the value held by the attribute is not constant. */
10337
dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
10339
if (attr->form == DW_FORM_sdata)
10340
return DW_SND (attr);
10341
else if (attr->form == DW_FORM_udata
10342
|| attr->form == DW_FORM_data1
10343
|| attr->form == DW_FORM_data2
10344
|| attr->form == DW_FORM_data4
10345
|| attr->form == DW_FORM_data8)
10346
return DW_UNSND (attr);
10349
complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
10350
dwarf_form_name (attr->form));
10351
return default_value;
10355
/* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
10356
unit and add it to our queue.
10357
The result is non-zero if PER_CU was queued, otherwise the result is zero
10358
meaning either PER_CU is already queued or it is already loaded. */
10361
maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
10362
struct dwarf2_per_cu_data *per_cu)
10364
/* Mark the dependence relation so that we don't flush PER_CU
10366
dwarf2_add_dependence (this_cu, per_cu);
10368
/* If it's already on the queue, we have nothing to do. */
10369
if (per_cu->queued)
10372
/* If the compilation unit is already loaded, just mark it as
10374
if (per_cu->cu != NULL)
10376
per_cu->cu->last_used = 0;
10380
/* Add it to the queue. */
10381
queue_comp_unit (per_cu, this_cu->objfile);
10386
/* Follow reference or signature attribute ATTR of SRC_DIE.
10387
On entry *REF_CU is the CU of SRC_DIE.
10388
On exit *REF_CU is the CU of the result. */
10390
static struct die_info *
10391
follow_die_ref_or_sig (struct die_info *src_die, struct attribute *attr,
10392
struct dwarf2_cu **ref_cu)
10394
struct die_info *die;
10396
if (is_ref_attr (attr))
10397
die = follow_die_ref (src_die, attr, ref_cu);
10398
else if (attr->form == DW_FORM_sig8)
10399
die = follow_die_sig (src_die, attr, ref_cu);
10402
dump_die_for_error (src_die);
10403
error (_("Dwarf Error: Expected reference attribute [in module %s]"),
10404
(*ref_cu)->objfile->name);
10410
/* Follow reference attribute ATTR of SRC_DIE.
10411
On entry *REF_CU is the CU of SRC_DIE.
10412
On exit *REF_CU is the CU of the result. */
10414
static struct die_info *
10415
follow_die_ref (struct die_info *src_die, struct attribute *attr,
10416
struct dwarf2_cu **ref_cu)
10418
struct die_info *die;
10419
unsigned int offset;
10420
struct die_info temp_die;
10421
struct dwarf2_cu *target_cu, *cu = *ref_cu;
10423
gdb_assert (cu->per_cu != NULL);
10425
offset = dwarf2_get_ref_die_offset (attr);
10427
if (cu->per_cu->from_debug_types)
10429
/* .debug_types CUs cannot reference anything outside their CU.
10430
If they need to, they have to reference a signatured type via
10432
if (! offset_in_cu_p (&cu->header, offset))
10436
else if (! offset_in_cu_p (&cu->header, offset))
10438
struct dwarf2_per_cu_data *per_cu;
10439
per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
10441
/* If necessary, add it to the queue and load its DIEs. */
10442
if (maybe_queue_comp_unit (cu, per_cu))
10443
load_full_comp_unit (per_cu, cu->objfile);
10445
target_cu = per_cu->cu;
10450
*ref_cu = target_cu;
10451
temp_die.offset = offset;
10452
die = htab_find_with_hash (target_cu->die_hash, &temp_die, offset);
10458
error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
10459
"at 0x%x [in module %s]"),
10460
offset, src_die->offset, cu->objfile->name);
10463
/* Follow the signature attribute ATTR in SRC_DIE.
10464
On entry *REF_CU is the CU of SRC_DIE.
10465
On exit *REF_CU is the CU of the result. */
10467
static struct die_info *
10468
follow_die_sig (struct die_info *src_die, struct attribute *attr,
10469
struct dwarf2_cu **ref_cu)
10471
struct objfile *objfile = (*ref_cu)->objfile;
10472
struct die_info temp_die;
10473
struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
10474
struct dwarf2_cu *sig_cu;
10475
struct die_info *die;
10477
/* sig_type will be NULL if the signatured type is missing from
10479
if (sig_type == NULL)
10480
error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
10481
"at 0x%x [in module %s]"),
10482
src_die->offset, objfile->name);
10484
/* If necessary, add it to the queue and load its DIEs. */
10486
if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu))
10487
read_signatured_type (objfile, sig_type);
10489
gdb_assert (sig_type->per_cu.cu != NULL);
10491
sig_cu = sig_type->per_cu.cu;
10492
temp_die.offset = sig_cu->header.offset + sig_type->type_offset;
10493
die = htab_find_with_hash (sig_cu->die_hash, &temp_die, temp_die.offset);
10500
error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
10501
"at 0x%x [in module %s]"),
10502
sig_type->type_offset, src_die->offset, objfile->name);
10505
/* Given an offset of a signatured type, return its signatured_type. */
10507
static struct signatured_type *
10508
lookup_signatured_type_at_offset (struct objfile *objfile, unsigned int offset)
10510
gdb_byte *info_ptr = dwarf2_per_objfile->types.buffer + offset;
10511
unsigned int length, initial_length_size;
10512
unsigned int sig_offset;
10513
struct signatured_type find_entry, *type_sig;
10515
length = read_initial_length (objfile->obfd, info_ptr, &initial_length_size);
10516
sig_offset = (initial_length_size
10518
+ (initial_length_size == 4 ? 4 : 8) /*debug_abbrev_offset*/
10519
+ 1 /*address_size*/);
10520
find_entry.signature = bfd_get_64 (objfile->obfd, info_ptr + sig_offset);
10521
type_sig = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
10523
/* This is only used to lookup previously recorded types.
10524
If we didn't find it, it's our bug. */
10525
gdb_assert (type_sig != NULL);
10526
gdb_assert (offset == type_sig->offset);
10531
/* Read in signatured type at OFFSET and build its CU and die(s). */
10534
read_signatured_type_at_offset (struct objfile *objfile,
10535
unsigned int offset)
10537
struct signatured_type *type_sig;
10539
/* We have the section offset, but we need the signature to do the
10540
hash table lookup. */
10541
type_sig = lookup_signatured_type_at_offset (objfile, offset);
10543
gdb_assert (type_sig->per_cu.cu == NULL);
10545
read_signatured_type (objfile, type_sig);
10547
gdb_assert (type_sig->per_cu.cu != NULL);
10550
/* Read in a signatured type and build its CU and DIEs. */
10553
read_signatured_type (struct objfile *objfile,
10554
struct signatured_type *type_sig)
10556
gdb_byte *types_ptr = dwarf2_per_objfile->types.buffer + type_sig->offset;
10557
struct die_reader_specs reader_specs;
10558
struct dwarf2_cu *cu;
10559
ULONGEST signature;
10560
struct cleanup *back_to, *free_cu_cleanup;
10561
struct attribute *attr;
10563
gdb_assert (type_sig->per_cu.cu == NULL);
10565
cu = xmalloc (sizeof (struct dwarf2_cu));
10566
memset (cu, 0, sizeof (struct dwarf2_cu));
10567
obstack_init (&cu->comp_unit_obstack);
10568
cu->objfile = objfile;
10569
type_sig->per_cu.cu = cu;
10570
cu->per_cu = &type_sig->per_cu;
10572
/* If an error occurs while loading, release our storage. */
10573
free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
10575
types_ptr = read_type_comp_unit_head (&cu->header, &signature,
10576
types_ptr, objfile->obfd);
10577
gdb_assert (signature == type_sig->signature);
10580
= htab_create_alloc_ex (cu->header.length / 12,
10584
&cu->comp_unit_obstack,
10585
hashtab_obstack_allocate,
10586
dummy_obstack_deallocate);
10588
dwarf2_read_abbrevs (cu->objfile->obfd, cu);
10589
back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
10591
init_cu_die_reader (&reader_specs, cu);
10593
cu->dies = read_die_and_children (&reader_specs, types_ptr, &types_ptr,
10596
/* We try not to read any attributes in this function, because not
10597
all objfiles needed for references have been loaded yet, and symbol
10598
table processing isn't initialized. But we have to set the CU language,
10599
or we won't be able to build types correctly. */
10600
attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
10602
set_cu_language (DW_UNSND (attr), cu);
10604
set_cu_language (language_minimal, cu);
10606
do_cleanups (back_to);
10608
/* We've successfully allocated this compilation unit. Let our caller
10609
clean it up when finished with it. */
10610
discard_cleanups (free_cu_cleanup);
10612
type_sig->per_cu.cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
10613
dwarf2_per_objfile->read_in_chain = &type_sig->per_cu;
10616
/* Decode simple location descriptions.
10617
Given a pointer to a dwarf block that defines a location, compute
10618
the location and return the value.
10620
NOTE drow/2003-11-18: This function is called in two situations
10621
now: for the address of static or global variables (partial symbols
10622
only) and for offsets into structures which are expected to be
10623
(more or less) constant. The partial symbol case should go away,
10624
and only the constant case should remain. That will let this
10625
function complain more accurately. A few special modes are allowed
10626
without complaint for global variables (for instance, global
10627
register values and thread-local values).
10629
A location description containing no operations indicates that the
10630
object is optimized out. The return value is 0 for that case.
10631
FIXME drow/2003-11-16: No callers check for this case any more; soon all
10632
callers will only want a very basic result and this can become a
10635
Note that stack[0] is unused except as a default error return.
10636
Note that stack overflow is not yet handled. */
10639
decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
10641
struct objfile *objfile = cu->objfile;
10642
struct comp_unit_head *cu_header = &cu->header;
10644
int size = blk->size;
10645
gdb_byte *data = blk->data;
10646
CORE_ADDR stack[64];
10648
unsigned int bytes_read, unsnd;
10692
stack[++stacki] = op - DW_OP_lit0;
10727
stack[++stacki] = op - DW_OP_reg0;
10729
dwarf2_complex_location_expr_complaint ();
10733
unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
10735
stack[++stacki] = unsnd;
10737
dwarf2_complex_location_expr_complaint ();
10741
stack[++stacki] = read_address (objfile->obfd, &data[i],
10746
case DW_OP_const1u:
10747
stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
10751
case DW_OP_const1s:
10752
stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
10756
case DW_OP_const2u:
10757
stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
10761
case DW_OP_const2s:
10762
stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
10766
case DW_OP_const4u:
10767
stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
10771
case DW_OP_const4s:
10772
stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
10777
stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
10783
stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
10788
stack[stacki + 1] = stack[stacki];
10793
stack[stacki - 1] += stack[stacki];
10797
case DW_OP_plus_uconst:
10798
stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
10803
stack[stacki - 1] -= stack[stacki];
10808
/* If we're not the last op, then we definitely can't encode
10809
this using GDB's address_class enum. This is valid for partial
10810
global symbols, although the variable's address will be bogus
10813
dwarf2_complex_location_expr_complaint ();
10816
case DW_OP_GNU_push_tls_address:
10817
/* The top of the stack has the offset from the beginning
10818
of the thread control block at which the variable is located. */
10819
/* Nothing should follow this operator, so the top of stack would
10821
/* This is valid for partial global symbols, but the variable's
10822
address will be bogus in the psymtab. */
10824
dwarf2_complex_location_expr_complaint ();
10827
case DW_OP_GNU_uninit:
10831
complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
10832
dwarf_stack_op_name (op));
10833
return (stack[stacki]);
10836
return (stack[stacki]);
10839
/* memory allocation interface */
10841
static struct dwarf_block *
10842
dwarf_alloc_block (struct dwarf2_cu *cu)
10844
struct dwarf_block *blk;
10846
blk = (struct dwarf_block *)
10847
obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
10851
static struct abbrev_info *
10852
dwarf_alloc_abbrev (struct dwarf2_cu *cu)
10854
struct abbrev_info *abbrev;
10856
abbrev = (struct abbrev_info *)
10857
obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
10858
memset (abbrev, 0, sizeof (struct abbrev_info));
10862
static struct die_info *
10863
dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
10865
struct die_info *die;
10866
size_t size = sizeof (struct die_info);
10869
size += (num_attrs - 1) * sizeof (struct attribute);
10871
die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
10872
memset (die, 0, sizeof (struct die_info));
10877
/* Macro support. */
10880
/* Return the full name of file number I in *LH's file name table.
10881
Use COMP_DIR as the name of the current directory of the
10882
compilation. The result is allocated using xmalloc; the caller is
10883
responsible for freeing it. */
10885
file_full_name (int file, struct line_header *lh, const char *comp_dir)
10887
/* Is the file number a valid index into the line header's file name
10888
table? Remember that file numbers start with one, not zero. */
10889
if (1 <= file && file <= lh->num_file_names)
10891
struct file_entry *fe = &lh->file_names[file - 1];
10893
if (IS_ABSOLUTE_PATH (fe->name))
10894
return xstrdup (fe->name);
10902
dir = lh->include_dirs[fe->dir_index - 1];
10908
dir_len = strlen (dir);
10909
full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
10910
strcpy (full_name, dir);
10911
full_name[dir_len] = '/';
10912
strcpy (full_name + dir_len + 1, fe->name);
10916
return xstrdup (fe->name);
10921
/* The compiler produced a bogus file number. We can at least
10922
record the macro definitions made in the file, even if we
10923
won't be able to find the file by name. */
10924
char fake_name[80];
10925
sprintf (fake_name, "<bad macro file number %d>", file);
10927
complaint (&symfile_complaints,
10928
_("bad file number in macro information (%d)"),
10931
return xstrdup (fake_name);
10936
static struct macro_source_file *
10937
macro_start_file (int file, int line,
10938
struct macro_source_file *current_file,
10939
const char *comp_dir,
10940
struct line_header *lh, struct objfile *objfile)
10942
/* The full name of this source file. */
10943
char *full_name = file_full_name (file, lh, comp_dir);
10945
/* We don't create a macro table for this compilation unit
10946
at all until we actually get a filename. */
10947
if (! pending_macros)
10948
pending_macros = new_macro_table (&objfile->objfile_obstack,
10949
objfile->macro_cache);
10951
if (! current_file)
10952
/* If we have no current file, then this must be the start_file
10953
directive for the compilation unit's main source file. */
10954
current_file = macro_set_main (pending_macros, full_name);
10956
current_file = macro_include (current_file, line, full_name);
10960
return current_file;
10964
/* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
10965
followed by a null byte. */
10967
copy_string (const char *buf, int len)
10969
char *s = xmalloc (len + 1);
10970
memcpy (s, buf, len);
10977
static const char *
10978
consume_improper_spaces (const char *p, const char *body)
10982
complaint (&symfile_complaints,
10983
_("macro definition contains spaces in formal argument list:\n`%s'"),
10995
parse_macro_definition (struct macro_source_file *file, int line,
11000
/* The body string takes one of two forms. For object-like macro
11001
definitions, it should be:
11003
<macro name> " " <definition>
11005
For function-like macro definitions, it should be:
11007
<macro name> "() " <definition>
11009
<macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
11011
Spaces may appear only where explicitly indicated, and in the
11014
The Dwarf 2 spec says that an object-like macro's name is always
11015
followed by a space, but versions of GCC around March 2002 omit
11016
the space when the macro's definition is the empty string.
11018
The Dwarf 2 spec says that there should be no spaces between the
11019
formal arguments in a function-like macro's formal argument list,
11020
but versions of GCC around March 2002 include spaces after the
11024
/* Find the extent of the macro name. The macro name is terminated
11025
by either a space or null character (for an object-like macro) or
11026
an opening paren (for a function-like macro). */
11027
for (p = body; *p; p++)
11028
if (*p == ' ' || *p == '(')
11031
if (*p == ' ' || *p == '\0')
11033
/* It's an object-like macro. */
11034
int name_len = p - body;
11035
char *name = copy_string (body, name_len);
11036
const char *replacement;
11039
replacement = body + name_len + 1;
11042
dwarf2_macro_malformed_definition_complaint (body);
11043
replacement = body + name_len;
11046
macro_define_object (file, line, name, replacement);
11050
else if (*p == '(')
11052
/* It's a function-like macro. */
11053
char *name = copy_string (body, p - body);
11056
char **argv = xmalloc (argv_size * sizeof (*argv));
11060
p = consume_improper_spaces (p, body);
11062
/* Parse the formal argument list. */
11063
while (*p && *p != ')')
11065
/* Find the extent of the current argument name. */
11066
const char *arg_start = p;
11068
while (*p && *p != ',' && *p != ')' && *p != ' ')
11071
if (! *p || p == arg_start)
11072
dwarf2_macro_malformed_definition_complaint (body);
11075
/* Make sure argv has room for the new argument. */
11076
if (argc >= argv_size)
11079
argv = xrealloc (argv, argv_size * sizeof (*argv));
11082
argv[argc++] = copy_string (arg_start, p - arg_start);
11085
p = consume_improper_spaces (p, body);
11087
/* Consume the comma, if present. */
11092
p = consume_improper_spaces (p, body);
11101
/* Perfectly formed definition, no complaints. */
11102
macro_define_function (file, line, name,
11103
argc, (const char **) argv,
11105
else if (*p == '\0')
11107
/* Complain, but do define it. */
11108
dwarf2_macro_malformed_definition_complaint (body);
11109
macro_define_function (file, line, name,
11110
argc, (const char **) argv,
11114
/* Just complain. */
11115
dwarf2_macro_malformed_definition_complaint (body);
11118
/* Just complain. */
11119
dwarf2_macro_malformed_definition_complaint (body);
11125
for (i = 0; i < argc; i++)
11131
dwarf2_macro_malformed_definition_complaint (body);
11136
dwarf_decode_macros (struct line_header *lh, unsigned int offset,
11137
char *comp_dir, bfd *abfd,
11138
struct dwarf2_cu *cu)
11140
gdb_byte *mac_ptr, *mac_end;
11141
struct macro_source_file *current_file = 0;
11142
enum dwarf_macinfo_record_type macinfo_type;
11143
int at_commandline;
11145
if (dwarf2_per_objfile->macinfo.buffer == NULL)
11147
complaint (&symfile_complaints, _("missing .debug_macinfo section"));
11151
/* First pass: Find the name of the base filename.
11152
This filename is needed in order to process all macros whose definition
11153
(or undefinition) comes from the command line. These macros are defined
11154
before the first DW_MACINFO_start_file entry, and yet still need to be
11155
associated to the base file.
11157
To determine the base file name, we scan the macro definitions until we
11158
reach the first DW_MACINFO_start_file entry. We then initialize
11159
CURRENT_FILE accordingly so that any macro definition found before the
11160
first DW_MACINFO_start_file can still be associated to the base file. */
11162
mac_ptr = dwarf2_per_objfile->macinfo.buffer + offset;
11163
mac_end = dwarf2_per_objfile->macinfo.buffer
11164
+ dwarf2_per_objfile->macinfo.size;
11168
/* Do we at least have room for a macinfo type byte? */
11169
if (mac_ptr >= mac_end)
11171
/* Complaint is printed during the second pass as GDB will probably
11172
stop the first pass earlier upon finding DW_MACINFO_start_file. */
11176
macinfo_type = read_1_byte (abfd, mac_ptr);
11179
switch (macinfo_type)
11181
/* A zero macinfo type indicates the end of the macro
11186
case DW_MACINFO_define:
11187
case DW_MACINFO_undef:
11188
/* Only skip the data by MAC_PTR. */
11190
unsigned int bytes_read;
11192
read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11193
mac_ptr += bytes_read;
11194
read_string (abfd, mac_ptr, &bytes_read);
11195
mac_ptr += bytes_read;
11199
case DW_MACINFO_start_file:
11201
unsigned int bytes_read;
11204
line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11205
mac_ptr += bytes_read;
11206
file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11207
mac_ptr += bytes_read;
11209
current_file = macro_start_file (file, line, current_file, comp_dir,
11214
case DW_MACINFO_end_file:
11215
/* No data to skip by MAC_PTR. */
11218
case DW_MACINFO_vendor_ext:
11219
/* Only skip the data by MAC_PTR. */
11221
unsigned int bytes_read;
11223
read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11224
mac_ptr += bytes_read;
11225
read_string (abfd, mac_ptr, &bytes_read);
11226
mac_ptr += bytes_read;
11233
} while (macinfo_type != 0 && current_file == NULL);
11235
/* Second pass: Process all entries.
11237
Use the AT_COMMAND_LINE flag to determine whether we are still processing
11238
command-line macro definitions/undefinitions. This flag is unset when we
11239
reach the first DW_MACINFO_start_file entry. */
11241
mac_ptr = dwarf2_per_objfile->macinfo.buffer + offset;
11243
/* Determines if GDB is still before first DW_MACINFO_start_file. If true
11244
GDB is still reading the definitions from command line. First
11245
DW_MACINFO_start_file will need to be ignored as it was already executed
11246
to create CURRENT_FILE for the main source holding also the command line
11247
definitions. On first met DW_MACINFO_start_file this flag is reset to
11248
normally execute all the remaining DW_MACINFO_start_file macinfos. */
11250
at_commandline = 1;
11254
/* Do we at least have room for a macinfo type byte? */
11255
if (mac_ptr >= mac_end)
11257
dwarf2_macros_too_long_complaint ();
11261
macinfo_type = read_1_byte (abfd, mac_ptr);
11264
switch (macinfo_type)
11266
/* A zero macinfo type indicates the end of the macro
11271
case DW_MACINFO_define:
11272
case DW_MACINFO_undef:
11274
unsigned int bytes_read;
11278
line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11279
mac_ptr += bytes_read;
11280
body = read_string (abfd, mac_ptr, &bytes_read);
11281
mac_ptr += bytes_read;
11283
if (! current_file)
11285
/* DWARF violation as no main source is present. */
11286
complaint (&symfile_complaints,
11287
_("debug info with no main source gives macro %s "
11289
macinfo_type == DW_MACINFO_define ?
11291
macinfo_type == DW_MACINFO_undef ?
11292
_("undefinition") :
11293
_("something-or-other"), line, body);
11296
if ((line == 0 && !at_commandline) || (line != 0 && at_commandline))
11297
complaint (&symfile_complaints,
11298
_("debug info gives %s macro %s with %s line %d: %s"),
11299
at_commandline ? _("command-line") : _("in-file"),
11300
macinfo_type == DW_MACINFO_define ?
11302
macinfo_type == DW_MACINFO_undef ?
11303
_("undefinition") :
11304
_("something-or-other"),
11305
line == 0 ? _("zero") : _("non-zero"), line, body);
11307
if (macinfo_type == DW_MACINFO_define)
11308
parse_macro_definition (current_file, line, body);
11309
else if (macinfo_type == DW_MACINFO_undef)
11310
macro_undef (current_file, line, body);
11314
case DW_MACINFO_start_file:
11316
unsigned int bytes_read;
11319
line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11320
mac_ptr += bytes_read;
11321
file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11322
mac_ptr += bytes_read;
11324
if ((line == 0 && !at_commandline) || (line != 0 && at_commandline))
11325
complaint (&symfile_complaints,
11326
_("debug info gives source %d included "
11327
"from %s at %s line %d"),
11328
file, at_commandline ? _("command-line") : _("file"),
11329
line == 0 ? _("zero") : _("non-zero"), line);
11331
if (at_commandline)
11333
/* This DW_MACINFO_start_file was executed in the pass one. */
11334
at_commandline = 0;
11337
current_file = macro_start_file (file, line,
11338
current_file, comp_dir,
11343
case DW_MACINFO_end_file:
11344
if (! current_file)
11345
complaint (&symfile_complaints,
11346
_("macro debug info has an unmatched `close_file' directive"));
11349
current_file = current_file->included_by;
11350
if (! current_file)
11352
enum dwarf_macinfo_record_type next_type;
11354
/* GCC circa March 2002 doesn't produce the zero
11355
type byte marking the end of the compilation
11356
unit. Complain if it's not there, but exit no
11359
/* Do we at least have room for a macinfo type byte? */
11360
if (mac_ptr >= mac_end)
11362
dwarf2_macros_too_long_complaint ();
11366
/* We don't increment mac_ptr here, so this is just
11368
next_type = read_1_byte (abfd, mac_ptr);
11369
if (next_type != 0)
11370
complaint (&symfile_complaints,
11371
_("no terminating 0-type entry for macros in `.debug_macinfo' section"));
11378
case DW_MACINFO_vendor_ext:
11380
unsigned int bytes_read;
11384
constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
11385
mac_ptr += bytes_read;
11386
string = read_string (abfd, mac_ptr, &bytes_read);
11387
mac_ptr += bytes_read;
11389
/* We don't recognize any vendor extensions. */
11393
} while (macinfo_type != 0);
11396
/* Check if the attribute's form is a DW_FORM_block*
11397
if so return true else false. */
11399
attr_form_is_block (struct attribute *attr)
11401
return (attr == NULL ? 0 :
11402
attr->form == DW_FORM_block1
11403
|| attr->form == DW_FORM_block2
11404
|| attr->form == DW_FORM_block4
11405
|| attr->form == DW_FORM_block);
11408
/* Return non-zero if ATTR's value is a section offset --- classes
11409
lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
11410
You may use DW_UNSND (attr) to retrieve such offsets.
11412
Section 7.5.4, "Attribute Encodings", explains that no attribute
11413
may have a value that belongs to more than one of these classes; it
11414
would be ambiguous if we did, because we use the same forms for all
11417
attr_form_is_section_offset (struct attribute *attr)
11419
return (attr->form == DW_FORM_data4
11420
|| attr->form == DW_FORM_data8);
11424
/* Return non-zero if ATTR's value falls in the 'constant' class, or
11425
zero otherwise. When this function returns true, you can apply
11426
dwarf2_get_attr_constant_value to it.
11428
However, note that for some attributes you must check
11429
attr_form_is_section_offset before using this test. DW_FORM_data4
11430
and DW_FORM_data8 are members of both the constant class, and of
11431
the classes that contain offsets into other debug sections
11432
(lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
11433
that, if an attribute's can be either a constant or one of the
11434
section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
11435
taken as section offsets, not constants. */
11437
attr_form_is_constant (struct attribute *attr)
11439
switch (attr->form)
11441
case DW_FORM_sdata:
11442
case DW_FORM_udata:
11443
case DW_FORM_data1:
11444
case DW_FORM_data2:
11445
case DW_FORM_data4:
11446
case DW_FORM_data8:
11454
dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
11455
struct dwarf2_cu *cu)
11457
if (attr_form_is_section_offset (attr)
11458
/* ".debug_loc" may not exist at all, or the offset may be outside
11459
the section. If so, fall through to the complaint in the
11461
&& DW_UNSND (attr) < dwarf2_per_objfile->loc.size)
11463
struct dwarf2_loclist_baton *baton;
11465
baton = obstack_alloc (&cu->objfile->objfile_obstack,
11466
sizeof (struct dwarf2_loclist_baton));
11467
baton->per_cu = cu->per_cu;
11468
gdb_assert (baton->per_cu);
11470
/* We don't know how long the location list is, but make sure we
11471
don't run off the edge of the section. */
11472
baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr);
11473
baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr);
11474
baton->base_address = cu->base_address;
11475
if (cu->base_known == 0)
11476
complaint (&symfile_complaints,
11477
_("Location list used without specifying the CU base address."));
11479
SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs;
11480
SYMBOL_LOCATION_BATON (sym) = baton;
11484
struct dwarf2_locexpr_baton *baton;
11486
baton = obstack_alloc (&cu->objfile->objfile_obstack,
11487
sizeof (struct dwarf2_locexpr_baton));
11488
baton->per_cu = cu->per_cu;
11489
gdb_assert (baton->per_cu);
11491
if (attr_form_is_block (attr))
11493
/* Note that we're just copying the block's data pointer
11494
here, not the actual data. We're still pointing into the
11495
info_buffer for SYM's objfile; right now we never release
11496
that buffer, but when we do clean up properly this may
11498
baton->size = DW_BLOCK (attr)->size;
11499
baton->data = DW_BLOCK (attr)->data;
11503
dwarf2_invalid_attrib_class_complaint ("location description",
11504
SYMBOL_NATURAL_NAME (sym));
11506
baton->data = NULL;
11509
SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
11510
SYMBOL_LOCATION_BATON (sym) = baton;
11514
/* Return the OBJFILE associated with the compilation unit CU. */
11517
dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
11519
struct objfile *objfile = per_cu->psymtab->objfile;
11521
/* Return the master objfile, so that we can report and look up the
11522
correct file containing this variable. */
11523
if (objfile->separate_debug_objfile_backlink)
11524
objfile = objfile->separate_debug_objfile_backlink;
11529
/* Return the address size given in the compilation unit header for CU. */
11532
dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
11535
return per_cu->cu->header.addr_size;
11538
/* If the CU is not currently read in, we re-read its header. */
11539
struct objfile *objfile = per_cu->psymtab->objfile;
11540
struct dwarf2_per_objfile *per_objfile
11541
= objfile_data (objfile, dwarf2_objfile_data_key);
11542
gdb_byte *info_ptr = per_objfile->info.buffer + per_cu->offset;
11544
struct comp_unit_head cu_header;
11545
memset (&cu_header, 0, sizeof cu_header);
11546
read_comp_unit_head (&cu_header, info_ptr, objfile->obfd);
11547
return cu_header.addr_size;
11551
/* Locate the .debug_info compilation unit from CU's objfile which contains
11552
the DIE at OFFSET. Raises an error on failure. */
11554
static struct dwarf2_per_cu_data *
11555
dwarf2_find_containing_comp_unit (unsigned int offset,
11556
struct objfile *objfile)
11558
struct dwarf2_per_cu_data *this_cu;
11562
high = dwarf2_per_objfile->n_comp_units - 1;
11565
int mid = low + (high - low) / 2;
11566
if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
11571
gdb_assert (low == high);
11572
if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
11575
error (_("Dwarf Error: could not find partial DIE containing "
11576
"offset 0x%lx [in module %s]"),
11577
(long) offset, bfd_get_filename (objfile->obfd));
11579
gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
11580
return dwarf2_per_objfile->all_comp_units[low-1];
11584
this_cu = dwarf2_per_objfile->all_comp_units[low];
11585
if (low == dwarf2_per_objfile->n_comp_units - 1
11586
&& offset >= this_cu->offset + this_cu->length)
11587
error (_("invalid dwarf2 offset %u"), offset);
11588
gdb_assert (offset < this_cu->offset + this_cu->length);
11593
/* Locate the compilation unit from OBJFILE which is located at exactly
11594
OFFSET. Raises an error on failure. */
11596
static struct dwarf2_per_cu_data *
11597
dwarf2_find_comp_unit (unsigned int offset, struct objfile *objfile)
11599
struct dwarf2_per_cu_data *this_cu;
11600
this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
11601
if (this_cu->offset != offset)
11602
error (_("no compilation unit with offset %u."), offset);
11606
/* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
11608
static struct dwarf2_cu *
11609
alloc_one_comp_unit (struct objfile *objfile)
11611
struct dwarf2_cu *cu = xcalloc (1, sizeof (struct dwarf2_cu));
11612
cu->objfile = objfile;
11613
obstack_init (&cu->comp_unit_obstack);
11617
/* Release one cached compilation unit, CU. We unlink it from the tree
11618
of compilation units, but we don't remove it from the read_in_chain;
11619
the caller is responsible for that.
11620
NOTE: DATA is a void * because this function is also used as a
11621
cleanup routine. */
11624
free_one_comp_unit (void *data)
11626
struct dwarf2_cu *cu = data;
11628
if (cu->per_cu != NULL)
11629
cu->per_cu->cu = NULL;
11632
obstack_free (&cu->comp_unit_obstack, NULL);
11637
/* This cleanup function is passed the address of a dwarf2_cu on the stack
11638
when we're finished with it. We can't free the pointer itself, but be
11639
sure to unlink it from the cache. Also release any associated storage
11640
and perform cache maintenance.
11642
Only used during partial symbol parsing. */
11645
free_stack_comp_unit (void *data)
11647
struct dwarf2_cu *cu = data;
11649
obstack_free (&cu->comp_unit_obstack, NULL);
11650
cu->partial_dies = NULL;
11652
if (cu->per_cu != NULL)
11654
/* This compilation unit is on the stack in our caller, so we
11655
should not xfree it. Just unlink it. */
11656
cu->per_cu->cu = NULL;
11659
/* If we had a per-cu pointer, then we may have other compilation
11660
units loaded, so age them now. */
11661
age_cached_comp_units ();
11665
/* Free all cached compilation units. */
11668
free_cached_comp_units (void *data)
11670
struct dwarf2_per_cu_data *per_cu, **last_chain;
11672
per_cu = dwarf2_per_objfile->read_in_chain;
11673
last_chain = &dwarf2_per_objfile->read_in_chain;
11674
while (per_cu != NULL)
11676
struct dwarf2_per_cu_data *next_cu;
11678
next_cu = per_cu->cu->read_in_chain;
11680
free_one_comp_unit (per_cu->cu);
11681
*last_chain = next_cu;
11687
/* Increase the age counter on each cached compilation unit, and free
11688
any that are too old. */
11691
age_cached_comp_units (void)
11693
struct dwarf2_per_cu_data *per_cu, **last_chain;
11695
dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
11696
per_cu = dwarf2_per_objfile->read_in_chain;
11697
while (per_cu != NULL)
11699
per_cu->cu->last_used ++;
11700
if (per_cu->cu->last_used <= dwarf2_max_cache_age)
11701
dwarf2_mark (per_cu->cu);
11702
per_cu = per_cu->cu->read_in_chain;
11705
per_cu = dwarf2_per_objfile->read_in_chain;
11706
last_chain = &dwarf2_per_objfile->read_in_chain;
11707
while (per_cu != NULL)
11709
struct dwarf2_per_cu_data *next_cu;
11711
next_cu = per_cu->cu->read_in_chain;
11713
if (!per_cu->cu->mark)
11715
free_one_comp_unit (per_cu->cu);
11716
*last_chain = next_cu;
11719
last_chain = &per_cu->cu->read_in_chain;
11725
/* Remove a single compilation unit from the cache. */
11728
free_one_cached_comp_unit (void *target_cu)
11730
struct dwarf2_per_cu_data *per_cu, **last_chain;
11732
per_cu = dwarf2_per_objfile->read_in_chain;
11733
last_chain = &dwarf2_per_objfile->read_in_chain;
11734
while (per_cu != NULL)
11736
struct dwarf2_per_cu_data *next_cu;
11738
next_cu = per_cu->cu->read_in_chain;
11740
if (per_cu->cu == target_cu)
11742
free_one_comp_unit (per_cu->cu);
11743
*last_chain = next_cu;
11747
last_chain = &per_cu->cu->read_in_chain;
11753
/* Release all extra memory associated with OBJFILE. */
11756
dwarf2_free_objfile (struct objfile *objfile)
11758
dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
11760
if (dwarf2_per_objfile == NULL)
11763
/* Cached DIE trees use xmalloc and the comp_unit_obstack. */
11764
free_cached_comp_units (NULL);
11766
/* Everything else should be on the objfile obstack. */
11769
/* A pair of DIE offset and GDB type pointer. We store these
11770
in a hash table separate from the DIEs, and preserve them
11771
when the DIEs are flushed out of cache. */
11773
struct dwarf2_offset_and_type
11775
unsigned int offset;
11779
/* Hash function for a dwarf2_offset_and_type. */
11782
offset_and_type_hash (const void *item)
11784
const struct dwarf2_offset_and_type *ofs = item;
11785
return ofs->offset;
11788
/* Equality function for a dwarf2_offset_and_type. */
11791
offset_and_type_eq (const void *item_lhs, const void *item_rhs)
11793
const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
11794
const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
11795
return ofs_lhs->offset == ofs_rhs->offset;
11798
/* Set the type associated with DIE to TYPE. Save it in CU's hash
11799
table if necessary. For convenience, return TYPE. */
11801
static struct type *
11802
set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
11804
struct dwarf2_offset_and_type **slot, ofs;
11806
/* For Ada types, make sure that the gnat-specific data is always
11807
initialized (if not already set). There are a few types where
11808
we should not be doing so, because the type-specific area is
11809
already used to hold some other piece of info (eg: TYPE_CODE_FLT
11810
where the type-specific area is used to store the floatformat).
11811
But this is not a problem, because the gnat-specific information
11812
is actually not needed for these types. */
11813
if (need_gnat_info (cu)
11814
&& TYPE_CODE (type) != TYPE_CODE_FUNC
11815
&& TYPE_CODE (type) != TYPE_CODE_FLT
11816
&& !HAVE_GNAT_AUX_INFO (type))
11817
INIT_GNAT_SPECIFIC (type);
11819
if (cu->type_hash == NULL)
11821
gdb_assert (cu->per_cu != NULL);
11822
cu->per_cu->type_hash
11823
= htab_create_alloc_ex (cu->header.length / 24,
11824
offset_and_type_hash,
11825
offset_and_type_eq,
11827
&cu->objfile->objfile_obstack,
11828
hashtab_obstack_allocate,
11829
dummy_obstack_deallocate);
11830
cu->type_hash = cu->per_cu->type_hash;
11833
ofs.offset = die->offset;
11835
slot = (struct dwarf2_offset_and_type **)
11836
htab_find_slot_with_hash (cu->type_hash, &ofs, ofs.offset, INSERT);
11837
*slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
11842
/* Find the type for DIE in CU's type_hash, or return NULL if DIE does
11843
not have a saved type. */
11845
static struct type *
11846
get_die_type (struct die_info *die, struct dwarf2_cu *cu)
11848
struct dwarf2_offset_and_type *slot, ofs;
11849
htab_t type_hash = cu->type_hash;
11851
if (type_hash == NULL)
11854
ofs.offset = die->offset;
11855
slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
11862
/* Add a dependence relationship from CU to REF_PER_CU. */
11865
dwarf2_add_dependence (struct dwarf2_cu *cu,
11866
struct dwarf2_per_cu_data *ref_per_cu)
11870
if (cu->dependencies == NULL)
11872
= htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
11873
NULL, &cu->comp_unit_obstack,
11874
hashtab_obstack_allocate,
11875
dummy_obstack_deallocate);
11877
slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
11879
*slot = ref_per_cu;
11882
/* Subroutine of dwarf2_mark to pass to htab_traverse.
11883
Set the mark field in every compilation unit in the
11884
cache that we must keep because we are keeping CU. */
11887
dwarf2_mark_helper (void **slot, void *data)
11889
struct dwarf2_per_cu_data *per_cu;
11891
per_cu = (struct dwarf2_per_cu_data *) *slot;
11892
if (per_cu->cu->mark)
11894
per_cu->cu->mark = 1;
11896
if (per_cu->cu->dependencies != NULL)
11897
htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
11902
/* Set the mark field in CU and in every other compilation unit in the
11903
cache that we must keep because we are keeping CU. */
11906
dwarf2_mark (struct dwarf2_cu *cu)
11911
if (cu->dependencies != NULL)
11912
htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
11916
dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
11920
per_cu->cu->mark = 0;
11921
per_cu = per_cu->cu->read_in_chain;
11925
/* Trivial hash function for partial_die_info: the hash value of a DIE
11926
is its offset in .debug_info for this objfile. */
11929
partial_die_hash (const void *item)
11931
const struct partial_die_info *part_die = item;
11932
return part_die->offset;
11935
/* Trivial comparison function for partial_die_info structures: two DIEs
11936
are equal if they have the same offset. */
11939
partial_die_eq (const void *item_lhs, const void *item_rhs)
11941
const struct partial_die_info *part_die_lhs = item_lhs;
11942
const struct partial_die_info *part_die_rhs = item_rhs;
11943
return part_die_lhs->offset == part_die_rhs->offset;
11946
static struct cmd_list_element *set_dwarf2_cmdlist;
11947
static struct cmd_list_element *show_dwarf2_cmdlist;
11950
set_dwarf2_cmd (char *args, int from_tty)
11952
help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
11956
show_dwarf2_cmd (char *args, int from_tty)
11958
cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
11961
/* If section described by INFO was mmapped, munmap it now. */
11964
munmap_section_buffer (struct dwarf2_section_info *info)
11966
if (info->was_mmapped)
11969
intptr_t begin = (intptr_t) info->buffer;
11970
intptr_t map_begin = begin & ~(pagesize - 1);
11971
size_t map_length = info->size + begin - map_begin;
11972
gdb_assert (munmap ((void *) map_begin, map_length) == 0);
11974
/* Without HAVE_MMAP, we should never be here to begin with. */
11980
/* munmap debug sections for OBJFILE, if necessary. */
11983
dwarf2_per_objfile_free (struct objfile *objfile, void *d)
11985
struct dwarf2_per_objfile *data = d;
11986
munmap_section_buffer (&data->info);
11987
munmap_section_buffer (&data->abbrev);
11988
munmap_section_buffer (&data->line);
11989
munmap_section_buffer (&data->str);
11990
munmap_section_buffer (&data->macinfo);
11991
munmap_section_buffer (&data->ranges);
11992
munmap_section_buffer (&data->loc);
11993
munmap_section_buffer (&data->frame);
11994
munmap_section_buffer (&data->eh_frame);
11997
void _initialize_dwarf2_read (void);
12000
_initialize_dwarf2_read (void)
12002
dwarf2_objfile_data_key
12003
= register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
12005
add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
12006
Set DWARF 2 specific variables.\n\
12007
Configure DWARF 2 variables such as the cache size"),
12008
&set_dwarf2_cmdlist, "maintenance set dwarf2 ",
12009
0/*allow-unknown*/, &maintenance_set_cmdlist);
12011
add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
12012
Show DWARF 2 specific variables\n\
12013
Show DWARF 2 variables such as the cache size"),
12014
&show_dwarf2_cmdlist, "maintenance show dwarf2 ",
12015
0/*allow-unknown*/, &maintenance_show_cmdlist);
12017
add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
12018
&dwarf2_max_cache_age, _("\
12019
Set the upper bound on the age of cached dwarf2 compilation units."), _("\
12020
Show the upper bound on the age of cached dwarf2 compilation units."), _("\
12021
A higher limit means that cached compilation units will be stored\n\
12022
in memory longer, and more total memory will be used. Zero disables\n\
12023
caching, which can slow down startup."),
12025
show_dwarf2_max_cache_age,
12026
&set_dwarf2_cmdlist,
12027
&show_dwarf2_cmdlist);
12029
add_setshow_zinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
12030
Set debugging of the dwarf2 DIE reader."), _("\
12031
Show debugging of the dwarf2 DIE reader."), _("\
12032
When enabled (non-zero), DIEs are dumped after they are read in.\n\
12033
The value is the maximum depth to print."),
12036
&setdebuglist, &showdebuglist);
added
removed
.pc/member-field-symtab.patch/gdb/dwarf2read.c
