1
/* DWARF 2 debugging format support for GDB.
2
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4
Free Software Foundation, Inc.
5
Copyright (c) 2004, 2005 Red Hat, Inc. All rights reserved.
7
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8
Inc. with support from Florida State University (under contract
9
with the Ada Joint Program Office), and Silicon Graphics, Inc.
10
Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11
based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12
support in dwarfread.c
14
This file is part of GDB.
16
This program is free software; you can redistribute it and/or modify
17
it under the terms of the GNU General Public License as published by
18
the Free Software Foundation; either version 2 of the License, or (at
19
your option) any later version.
21
This program is distributed in the hope that it will be useful, but
22
WITHOUT ANY WARRANTY; without even the implied warranty of
23
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24
General Public License for more details.
26
You should have received a copy of the GNU General Public License
27
along with this program; if not, write to the Free Software
28
Foundation, Inc., 59 Temple Place - Suite 330,
29
Boston, MA 02111-1307, USA. */
36
#include "elf/dwarf2.h"
39
#include "expression.h"
40
#include "filenames.h" /* for DOSish file names */
43
#include "complaints.h"
45
#include "dwarf2expr.h"
46
#include "dwarf2loc.h"
47
#include "cp-support.h"
50
#include "gdb_string.h"
51
#include "gdb_assert.h"
52
#include <sys/types.h>
54
#ifndef DWARF2_REG_TO_REGNUM
55
#define DWARF2_REG_TO_REGNUM(REG) (REG)
59
/* .debug_info header for a compilation unit
60
Because of alignment constraints, this structure has padding and cannot
61
be mapped directly onto the beginning of the .debug_info section. */
62
typedef struct comp_unit_header
64
unsigned int length; /* length of the .debug_info
66
unsigned short version; /* version number -- 2 for DWARF
68
unsigned int abbrev_offset; /* offset into .debug_abbrev section */
69
unsigned char addr_size; /* byte size of an address -- 4 */
72
#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
75
/* .debug_pubnames header
76
Because of alignment constraints, this structure has padding and cannot
77
be mapped directly onto the beginning of the .debug_info section. */
78
typedef struct pubnames_header
80
unsigned int length; /* length of the .debug_pubnames
82
unsigned char version; /* version number -- 2 for DWARF
84
unsigned int info_offset; /* offset into .debug_info section */
85
unsigned int info_size; /* byte size of .debug_info section
89
#define _ACTUAL_PUBNAMES_HEADER_SIZE 13
91
/* .debug_pubnames header
92
Because of alignment constraints, this structure has padding and cannot
93
be mapped directly onto the beginning of the .debug_info section. */
94
typedef struct aranges_header
96
unsigned int length; /* byte len of the .debug_aranges
98
unsigned short version; /* version number -- 2 for DWARF
100
unsigned int info_offset; /* offset into .debug_info section */
101
unsigned char addr_size; /* byte size of an address */
102
unsigned char seg_size; /* byte size of segment descriptor */
105
#define _ACTUAL_ARANGES_HEADER_SIZE 12
107
/* .debug_line statement program prologue
108
Because of alignment constraints, this structure has padding and cannot
109
be mapped directly onto the beginning of the .debug_info section. */
110
typedef struct statement_prologue
112
unsigned int total_length; /* byte length of the statement
114
unsigned short version; /* version number -- 2 for DWARF
116
unsigned int prologue_length; /* # bytes between prologue &
118
unsigned char minimum_instruction_length; /* byte size of
120
unsigned char default_is_stmt; /* initial value of is_stmt
123
unsigned char line_range;
124
unsigned char opcode_base; /* number assigned to first special
126
unsigned char *standard_opcode_lengths;
130
/* offsets and sizes of debugging sections */
132
static unsigned int dwarf_info_size;
133
static unsigned int dwarf_abbrev_size;
134
static unsigned int dwarf_line_size;
135
static unsigned int dwarf_pubnames_size;
136
static unsigned int dwarf_aranges_size;
137
static unsigned int dwarf_loc_size;
138
static unsigned int dwarf_macinfo_size;
139
static unsigned int dwarf_str_size;
140
static unsigned int dwarf_ranges_size;
141
unsigned int dwarf_frame_size;
142
unsigned int dwarf_eh_frame_size;
144
static asection *dwarf_info_section;
145
static asection *dwarf_abbrev_section;
146
static asection *dwarf_line_section;
147
static asection *dwarf_pubnames_section;
148
static asection *dwarf_aranges_section;
149
static asection *dwarf_loc_section;
150
static asection *dwarf_macinfo_section;
151
static asection *dwarf_str_section;
152
static asection *dwarf_ranges_section;
153
asection *dwarf_frame_section;
154
asection *dwarf_eh_frame_section;
156
/* names of the debugging sections */
158
#define INFO_SECTION ".debug_info"
159
#define ABBREV_SECTION ".debug_abbrev"
160
#define LINE_SECTION ".debug_line"
161
#define PUBNAMES_SECTION ".debug_pubnames"
162
#define ARANGES_SECTION ".debug_aranges"
163
#define LOC_SECTION ".debug_loc"
164
#define MACINFO_SECTION ".debug_macinfo"
165
#define STR_SECTION ".debug_str"
166
#define RANGES_SECTION ".debug_ranges"
167
#define FRAME_SECTION ".debug_frame"
168
#define EH_FRAME_SECTION ".eh_frame"
170
/* local data types */
172
/* We hold several abbreviation tables in memory at the same time. */
173
#ifndef ABBREV_HASH_SIZE
174
#define ABBREV_HASH_SIZE 121
177
/* The data in a compilation unit header, after target2host
178
translation, looks like this. */
179
struct comp_unit_head
181
unsigned long length;
183
unsigned int abbrev_offset;
184
unsigned char addr_size;
185
unsigned char signed_addr_p;
186
unsigned int offset_size; /* size of file offsets; either 4 or 8 */
187
unsigned int initial_length_size; /* size of the length field; either
190
/* Offset to the first byte of this compilation unit header in the
191
* .debug_info section, for resolving relative reference dies. */
195
/* Pointer to this compilation unit header in the .debug_info
200
/* Pointer to the first die of this compilatio unit. This will
201
* be the first byte following the compilation unit header. */
205
/* Pointer to the next compilation unit header in the program. */
207
struct comp_unit_head *next;
209
/* DWARF abbreviation table associated with this compilation unit */
211
struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
213
/* Base address of this compilation unit. */
215
CORE_ADDR base_address;
217
/* Non-zero if base_address has been set. */
222
/* Internal state when decoding a particular compilation unit. */
225
/* The objfile containing this compilation unit. */
226
struct objfile *objfile;
228
/* The header of the compilation unit.
230
FIXME drow/2003-11-10: Some of the things from the comp_unit_head
231
should be moved to the dwarf2_cu structure; for instance the abbrevs
233
struct comp_unit_head header;
235
struct function_range *first_fn, *last_fn, *cached_fn;
237
/* The language we are debugging. */
238
enum language language;
239
const struct language_defn *language_defn;
241
/* The generic symbol table building routines have separate lists for
242
file scope symbols and all all other scopes (local scopes). So
243
we need to select the right one to pass to add_symbol_to_list().
244
We do it by keeping a pointer to the correct list in list_in_scope.
246
FIXME: The original dwarf code just treated the file scope as the
247
first local scope, and all other local scopes as nested local
248
scopes, and worked fine. Check to see if we really need to
249
distinguish these in buildsym.c. */
250
struct pending **list_in_scope;
252
/* Maintain an array of referenced fundamental types for the current
253
compilation unit being read. For DWARF version 1, we have to construct
254
the fundamental types on the fly, since no information about the
255
fundamental types is supplied. Each such fundamental type is created by
256
calling a language dependent routine to create the type, and then a
257
pointer to that type is then placed in the array at the index specified
258
by it's FT_<TYPENAME> value. The array has a fixed size set by the
259
FT_NUM_MEMBERS compile time constant, which is the number of predefined
260
fundamental types gdb knows how to construct. */
261
struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
264
/* The line number information for a compilation unit (found in the
265
.debug_line section) begins with a "statement program header",
266
which contains the following information. */
269
unsigned int total_length;
270
unsigned short version;
271
unsigned int header_length;
272
unsigned char minimum_instruction_length;
273
unsigned char default_is_stmt;
275
unsigned char line_range;
276
unsigned char opcode_base;
278
/* standard_opcode_lengths[i] is the number of operands for the
279
standard opcode whose value is i. This means that
280
standard_opcode_lengths[0] is unused, and the last meaningful
281
element is standard_opcode_lengths[opcode_base - 1]. */
282
unsigned char *standard_opcode_lengths;
284
/* The include_directories table. NOTE! These strings are not
285
allocated with xmalloc; instead, they are pointers into
286
debug_line_buffer. If you try to free them, `free' will get
288
unsigned int num_include_dirs, include_dirs_size;
291
/* The file_names table. NOTE! These strings are not allocated
292
with xmalloc; instead, they are pointers into debug_line_buffer.
293
Don't try to free them directly. */
294
unsigned int num_file_names, file_names_size;
298
unsigned int dir_index;
299
unsigned int mod_time;
303
/* The start and end of the statement program following this
304
header. These point into dwarf_line_buffer. */
305
char *statement_program_start, *statement_program_end;
308
/* When we construct a partial symbol table entry we only
309
need this much information. */
310
struct partial_die_info
313
unsigned char has_children;
314
unsigned char is_external;
315
unsigned char is_declaration;
316
unsigned char has_type;
323
struct dwarf_block *locdesc;
324
unsigned int language;
328
/* This data structure holds the information of an abbrev. */
331
unsigned int number; /* number identifying abbrev */
332
enum dwarf_tag tag; /* dwarf tag */
333
int has_children; /* boolean */
334
unsigned int num_attrs; /* number of attributes */
335
struct attr_abbrev *attrs; /* an array of attribute descriptions */
336
struct abbrev_info *next; /* next in chain */
341
enum dwarf_attribute name;
342
enum dwarf_form form;
345
/* This data structure holds a complete die structure. */
348
enum dwarf_tag tag; /* Tag indicating type of die */
349
unsigned int abbrev; /* Abbrev number */
350
unsigned int offset; /* Offset in .debug_info section */
351
unsigned int num_attrs; /* Number of attributes */
352
struct attribute *attrs; /* An array of attributes */
353
struct die_info *next_ref; /* Next die in ref hash table */
355
/* The dies in a compilation unit form an n-ary tree. PARENT
356
points to this die's parent; CHILD points to the first child of
357
this node; and all the children of a given node are chained
358
together via their SIBLING fields, terminated by a die whose
360
struct die_info *child; /* Its first child, if any. */
361
struct die_info *sibling; /* Its next sibling, if any. */
362
struct die_info *parent; /* Its parent, if any. */
364
struct type *type; /* Cached type information */
367
/* Attributes have a name and a value */
370
enum dwarf_attribute name;
371
enum dwarf_form form;
375
struct dwarf_block *blk;
383
struct function_range
386
CORE_ADDR lowpc, highpc;
388
struct function_range *next;
391
/* Get at parts of an attribute structure */
393
#define DW_STRING(attr) ((attr)->u.str)
394
#define DW_UNSND(attr) ((attr)->u.unsnd)
395
#define DW_BLOCK(attr) ((attr)->u.blk)
396
#define DW_SND(attr) ((attr)->u.snd)
397
#define DW_ADDR(attr) ((attr)->u.addr)
399
/* Blocks are a bunch of untyped bytes. */
406
#ifndef ATTR_ALLOC_CHUNK
407
#define ATTR_ALLOC_CHUNK 4
410
/* A hash table of die offsets for following references. */
411
#ifndef REF_HASH_SIZE
412
#define REF_HASH_SIZE 1021
415
static struct die_info *die_ref_table[REF_HASH_SIZE];
417
/* Obstack for allocating temporary storage used during symbol reading. */
418
static struct obstack dwarf2_tmp_obstack;
420
/* Allocate fields for structs, unions and enums in this size. */
421
#ifndef DW_FIELD_ALLOC_CHUNK
422
#define DW_FIELD_ALLOC_CHUNK 4
425
/* Actually data from the sections. */
426
static char *dwarf_info_buffer;
427
static char *dwarf_abbrev_buffer;
428
static char *dwarf_line_buffer;
429
static char *dwarf_str_buffer;
430
static char *dwarf_macinfo_buffer;
431
static char *dwarf_ranges_buffer;
432
static char *dwarf_loc_buffer;
434
/* A zeroed version of a partial die for initialization purposes. */
435
static struct partial_die_info zeroed_partial_die;
437
/* FIXME: decode_locdesc sets these variables to describe the location
438
to the caller. These ought to be a structure or something. If
439
none of the flags are set, the object lives at the address returned
440
by decode_locdesc. */
442
static int isreg; /* Object lives in register.
443
decode_locdesc's return value is
444
the register number. */
446
/* We put a pointer to this structure in the read_symtab_private field
448
The complete dwarf information for an objfile is kept in the
449
objfile_obstack, so that absolute die references can be handled.
450
Most of the information in this structure is related to an entire
451
object file and could be passed via the sym_private field of the objfile.
452
It is however conceivable that dwarf2 might not be the only type
453
of symbols read from an object file. */
457
/* Pointer to start of dwarf info buffer for the objfile. */
459
char *dwarf_info_buffer;
461
/* Offset in dwarf_info_buffer for this compilation unit. */
463
unsigned long dwarf_info_offset;
465
/* Pointer to start of dwarf abbreviation buffer for the objfile. */
467
char *dwarf_abbrev_buffer;
469
/* Size of dwarf abbreviation section for the objfile. */
471
unsigned int dwarf_abbrev_size;
473
/* Pointer to start of dwarf line buffer for the objfile. */
475
char *dwarf_line_buffer;
477
/* Size of dwarf_line_buffer, in bytes. */
479
unsigned int dwarf_line_size;
481
/* Pointer to start of dwarf string buffer for the objfile. */
483
char *dwarf_str_buffer;
485
/* Size of dwarf string section for the objfile. */
487
unsigned int dwarf_str_size;
489
/* Pointer to start of dwarf macro buffer for the objfile. */
491
char *dwarf_macinfo_buffer;
493
/* Size of dwarf macinfo section for the objfile. */
495
unsigned int dwarf_macinfo_size;
497
/* Pointer to start of dwarf ranges buffer for the objfile. */
499
char *dwarf_ranges_buffer;
501
/* Size of dwarf ranges buffer for the objfile. */
503
unsigned int dwarf_ranges_size;
505
/* Pointer to start of dwarf locations buffer for the objfile. */
507
char *dwarf_loc_buffer;
509
/* Size of dwarf locations buffer for the objfile. */
511
unsigned int dwarf_loc_size;
514
#define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
515
#define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
516
#define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
517
#define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
518
#define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
519
#define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
520
#define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
521
#define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
522
#define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
523
#define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
524
#define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
525
#define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
526
#define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
527
#define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
528
#define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
530
/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
531
but this would require a corresponding change in unpack_field_as_long
533
static int bits_per_byte = 8;
535
/* The routines that read and process dies for a C struct or C++ class
536
pass lists of data member fields and lists of member function fields
537
in an instance of a field_info structure, as defined below. */
540
/* List of data member and baseclasses fields. */
543
struct nextfield *next;
550
/* Number of fields. */
553
/* Number of baseclasses. */
556
/* Set if the accesibility of one of the fields is not public. */
557
int non_public_fields;
559
/* Member function fields array, entries are allocated in the order they
560
are encountered in the object file. */
563
struct nextfnfield *next;
564
struct fn_field fnfield;
568
/* Member function fieldlist array, contains name of possibly overloaded
569
member function, number of overloaded member functions and a pointer
570
to the head of the member function field chain. */
575
struct nextfnfield *head;
579
/* Number of entries in the fnfieldlists array. */
583
/* Various complaints about symbol reading that don't abort the process */
586
dwarf2_statement_list_fits_in_line_number_section_complaint (void)
588
complaint (&symfile_complaints,
589
"statement list doesn't fit in .debug_line section");
593
dwarf2_complex_location_expr_complaint (void)
595
complaint (&symfile_complaints, "location expression too complex");
599
dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
602
complaint (&symfile_complaints,
603
"const value length mismatch for '%s', got %d, expected %d", arg1,
608
dwarf2_macros_too_long_complaint (void)
610
complaint (&symfile_complaints,
611
"macro info runs off end of `.debug_macinfo' section");
615
dwarf2_macro_malformed_definition_complaint (const char *arg1)
617
complaint (&symfile_complaints,
618
"macro debug info contains a malformed macro definition:\n`%s'",
623
dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
625
complaint (&symfile_complaints,
626
"invalid attribute class or form for '%s' in '%s'", arg1, arg2);
629
/* local function prototypes */
631
static void dwarf2_locate_sections (bfd *, asection *, void *);
634
static void dwarf2_build_psymtabs_easy (struct objfile *, int);
637
static void dwarf2_build_psymtabs_hard (struct objfile *, int);
639
static char *scan_partial_symbols (char *, CORE_ADDR *, CORE_ADDR *,
641
const char *namespace);
643
static void add_partial_symbol (struct partial_die_info *, struct dwarf2_cu *,
644
const char *namespace);
646
static int pdi_needs_namespace (enum dwarf_tag tag, const char *namespace);
648
static char *add_partial_namespace (struct partial_die_info *pdi,
650
CORE_ADDR *lowpc, CORE_ADDR *highpc,
651
struct dwarf2_cu *cu,
652
const char *namespace);
654
static char *add_partial_structure (struct partial_die_info *struct_pdi,
656
struct dwarf2_cu *cu,
657
const char *namespace);
659
static char *add_partial_enumeration (struct partial_die_info *enum_pdi,
661
struct dwarf2_cu *cu,
662
const char *namespace);
664
static char *locate_pdi_sibling (struct partial_die_info *orig_pdi,
667
struct dwarf2_cu *cu);
669
static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
671
static void psymtab_to_symtab_1 (struct partial_symtab *);
673
char *dwarf2_read_section (struct objfile *, asection *);
675
static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
677
static void dwarf2_empty_abbrev_table (void *);
679
static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
682
static char *read_partial_die (struct partial_die_info *,
683
bfd *, char *, struct dwarf2_cu *);
685
static char *read_full_die (struct die_info **, bfd *, char *,
686
struct dwarf2_cu *, int *);
688
static char *read_attribute (struct attribute *, struct attr_abbrev *,
689
bfd *, char *, struct dwarf2_cu *);
691
static char *read_attribute_value (struct attribute *, unsigned,
692
bfd *, char *, struct dwarf2_cu *);
694
static unsigned int read_1_byte (bfd *, char *);
696
static int read_1_signed_byte (bfd *, char *);
698
static unsigned int read_2_bytes (bfd *, char *);
700
static unsigned int read_4_bytes (bfd *, char *);
702
static unsigned long read_8_bytes (bfd *, char *);
704
static CORE_ADDR read_address (bfd *, char *ptr, struct dwarf2_cu *,
707
static LONGEST read_initial_length (bfd *, char *,
708
struct comp_unit_head *, int *bytes_read);
710
static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *,
713
static char *read_n_bytes (bfd *, char *, unsigned int);
715
static char *read_string (bfd *, char *, unsigned int *);
717
static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
720
static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
722
static long read_signed_leb128 (bfd *, char *, unsigned int *);
724
static void set_cu_language (unsigned int, struct dwarf2_cu *);
726
static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
729
static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
731
static struct die_info *die_specification (struct die_info *die,
734
static void free_line_header (struct line_header *lh);
736
static struct line_header *(dwarf_decode_line_header
737
(unsigned int offset,
738
bfd *abfd, struct dwarf2_cu *cu));
740
static void dwarf_decode_lines (struct line_header *, char *, bfd *,
743
static void dwarf2_start_subfile (char *, char *);
745
static struct symbol *new_symbol (struct die_info *, struct type *,
748
static void dwarf2_const_value (struct attribute *, struct symbol *,
751
static void dwarf2_const_value_data (struct attribute *attr,
755
static struct type *die_type (struct die_info *, struct dwarf2_cu *);
757
static struct type *die_containing_type (struct die_info *,
761
static struct type *type_at_offset (unsigned int, struct objfile *);
764
static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
766
static void read_type_die (struct die_info *, struct dwarf2_cu *);
768
static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
770
static char *typename_concat (const char *prefix, const char *suffix);
772
static void read_typedef (struct die_info *, struct dwarf2_cu *);
774
static void read_base_type (struct die_info *, struct dwarf2_cu *);
776
static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
778
static void read_file_scope (struct die_info *, struct dwarf2_cu *);
780
static void read_func_scope (struct die_info *, struct dwarf2_cu *);
782
static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
784
static int dwarf2_get_pc_bounds (struct die_info *,
785
CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
787
static void get_scope_pc_bounds (struct die_info *,
788
CORE_ADDR *, CORE_ADDR *,
791
static void dwarf2_add_field (struct field_info *, struct die_info *,
794
static void dwarf2_attach_fields_to_type (struct field_info *,
795
struct type *, struct dwarf2_cu *);
797
static void dwarf2_add_member_fn (struct field_info *,
798
struct die_info *, struct type *,
801
static void dwarf2_attach_fn_fields_to_type (struct field_info *,
802
struct type *, struct dwarf2_cu *);
804
static void read_structure_type (struct die_info *, struct dwarf2_cu *);
806
static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
808
static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
810
static void read_common_block (struct die_info *, struct dwarf2_cu *);
812
static void read_namespace (struct die_info *die, struct dwarf2_cu *);
814
static const char *namespace_name (struct die_info *die,
815
int *is_anonymous, struct dwarf2_cu *);
817
static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
819
static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
821
static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
823
static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
825
static void read_array_type (struct die_info *, struct dwarf2_cu *);
827
static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
829
static void read_tag_ptr_to_member_type (struct die_info *,
832
static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
834
static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
836
static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
838
static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
840
static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
842
static struct die_info *read_comp_unit (char *, bfd *, struct dwarf2_cu *);
844
static struct die_info *read_die_and_children (char *info_ptr, bfd *abfd,
847
struct die_info *parent);
849
static struct die_info *read_die_and_siblings (char *info_ptr, bfd *abfd,
852
struct die_info *parent);
854
static void free_die_list (struct die_info *);
856
static struct cleanup *make_cleanup_free_die_list (struct die_info *);
858
static void process_die (struct die_info *, struct dwarf2_cu *);
860
static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
862
static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
864
static struct die_info *dwarf2_extension (struct die_info *die,
867
static char *dwarf_tag_name (unsigned int);
869
static char *dwarf_attr_name (unsigned int);
871
static char *dwarf_form_name (unsigned int);
873
static char *dwarf_stack_op_name (unsigned int);
875
static char *dwarf_bool_name (unsigned int);
877
static char *dwarf_type_encoding_name (unsigned int);
880
static char *dwarf_cfi_name (unsigned int);
882
struct die_info *copy_die (struct die_info *);
885
static struct die_info *sibling_die (struct die_info *);
887
static void dump_die (struct die_info *);
889
static void dump_die_list (struct die_info *);
891
static void store_in_ref_table (unsigned int, struct die_info *);
893
static void dwarf2_empty_hash_tables (void);
895
static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
898
static int dwarf2_get_attr_constant_value (struct attribute *, int);
900
static struct die_info *follow_die_ref (unsigned int);
902
static struct type *dwarf2_fundamental_type (struct objfile *, int,
905
/* memory allocation interface */
907
static void dwarf2_free_tmp_obstack (void *);
909
static struct dwarf_block *dwarf_alloc_block (void);
911
static struct abbrev_info *dwarf_alloc_abbrev (void);
913
static struct die_info *dwarf_alloc_die (void);
915
static void initialize_cu_func_list (struct dwarf2_cu *);
917
static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
920
static void dwarf_decode_macros (struct line_header *, unsigned int,
921
char *, bfd *, struct dwarf2_cu *);
923
static int attr_form_is_block (struct attribute *);
926
dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
927
struct dwarf2_cu *cu);
929
/* Try to locate the sections we need for DWARF 2 debugging
930
information and return true if we have enough to do something. */
933
dwarf2_has_info (bfd *abfd)
935
dwarf_info_section = 0;
936
dwarf_abbrev_section = 0;
937
dwarf_line_section = 0;
938
dwarf_str_section = 0;
939
dwarf_macinfo_section = 0;
940
dwarf_frame_section = 0;
941
dwarf_eh_frame_section = 0;
942
dwarf_ranges_section = 0;
943
dwarf_loc_section = 0;
945
bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
946
return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
949
/* This function is mapped across the sections and remembers the
950
offset and size of each of the debugging sections we are interested
954
dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
956
if (strcmp (sectp->name, INFO_SECTION) == 0)
958
dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
959
dwarf_info_section = sectp;
961
else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
963
dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
964
dwarf_abbrev_section = sectp;
966
else if (strcmp (sectp->name, LINE_SECTION) == 0)
968
dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
969
dwarf_line_section = sectp;
971
else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
973
dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
974
dwarf_pubnames_section = sectp;
976
else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
978
dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
979
dwarf_aranges_section = sectp;
981
else if (strcmp (sectp->name, LOC_SECTION) == 0)
983
dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
984
dwarf_loc_section = sectp;
986
else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
988
dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
989
dwarf_macinfo_section = sectp;
991
else if (strcmp (sectp->name, STR_SECTION) == 0)
993
dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
994
dwarf_str_section = sectp;
996
else if (strcmp (sectp->name, FRAME_SECTION) == 0)
998
dwarf_frame_size = bfd_get_section_size_before_reloc (sectp);
999
dwarf_frame_section = sectp;
1001
else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1003
flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1004
if (aflag & SEC_HAS_CONTENTS)
1006
dwarf_eh_frame_size = bfd_get_section_size_before_reloc (sectp);
1007
dwarf_eh_frame_section = sectp;
1010
else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1012
dwarf_ranges_size = bfd_get_section_size_before_reloc (sectp);
1013
dwarf_ranges_section = sectp;
1017
/* Build a partial symbol table. */
1020
dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1023
/* We definitely need the .debug_info and .debug_abbrev sections */
1025
dwarf_info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1026
dwarf_abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1028
if (dwarf_line_section)
1029
dwarf_line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1031
dwarf_line_buffer = NULL;
1033
if (dwarf_str_section)
1034
dwarf_str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1036
dwarf_str_buffer = NULL;
1038
if (dwarf_macinfo_section)
1039
dwarf_macinfo_buffer = dwarf2_read_section (objfile,
1040
dwarf_macinfo_section);
1042
dwarf_macinfo_buffer = NULL;
1044
if (dwarf_ranges_section)
1045
dwarf_ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1047
dwarf_ranges_buffer = NULL;
1049
if (dwarf_loc_section)
1050
dwarf_loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1052
dwarf_loc_buffer = NULL;
1055
|| (objfile->global_psymbols.size == 0
1056
&& objfile->static_psymbols.size == 0))
1058
init_psymbol_list (objfile, 1024);
1062
if (dwarf_aranges_offset && dwarf_pubnames_offset)
1064
/* Things are significantly easier if we have .debug_aranges and
1065
.debug_pubnames sections */
1067
dwarf2_build_psymtabs_easy (objfile, mainline);
1071
/* only test this case for now */
1073
/* In this case we have to work a bit harder */
1074
dwarf2_build_psymtabs_hard (objfile, mainline);
1079
/* Build the partial symbol table from the information in the
1080
.debug_pubnames and .debug_aranges sections. */
1083
dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1085
bfd *abfd = objfile->obfd;
1086
char *aranges_buffer, *pubnames_buffer;
1087
char *aranges_ptr, *pubnames_ptr;
1088
unsigned int entry_length, version, info_offset, info_size;
1090
pubnames_buffer = dwarf2_read_section (objfile,
1091
dwarf_pubnames_section);
1092
pubnames_ptr = pubnames_buffer;
1093
while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
1095
struct comp_unit_head cu_header;
1098
entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1100
pubnames_ptr += bytes_read;
1101
version = read_1_byte (abfd, pubnames_ptr);
1103
info_offset = read_4_bytes (abfd, pubnames_ptr);
1105
info_size = read_4_bytes (abfd, pubnames_ptr);
1109
aranges_buffer = dwarf2_read_section (objfile,
1110
dwarf_aranges_section);
1115
/* Read in the comp unit header information from the debug_info at
1119
read_comp_unit_head (struct comp_unit_head *cu_header,
1120
char *info_ptr, bfd *abfd)
1124
cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1126
info_ptr += bytes_read;
1127
cu_header->version = read_2_bytes (abfd, info_ptr);
1129
cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1131
info_ptr += bytes_read;
1132
cu_header->addr_size = read_1_byte (abfd, info_ptr);
1134
signed_addr = bfd_get_sign_extend_vma (abfd);
1135
if (signed_addr < 0)
1136
internal_error (__FILE__, __LINE__,
1137
"read_comp_unit_head: dwarf from non elf file");
1138
cu_header->signed_addr_p = signed_addr;
1142
/* Build the partial symbol table by doing a quick pass through the
1143
.debug_info and .debug_abbrev sections. */
1146
dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1148
/* Instead of reading this into a big buffer, we should probably use
1149
mmap() on architectures that support it. (FIXME) */
1150
bfd *abfd = objfile->obfd;
1151
char *info_ptr, *abbrev_ptr;
1152
char *beg_of_comp_unit;
1153
struct partial_die_info comp_unit_die;
1154
struct partial_symtab *pst;
1155
struct cleanup *back_to;
1156
CORE_ADDR lowpc, highpc, baseaddr;
1158
info_ptr = dwarf_info_buffer;
1159
abbrev_ptr = dwarf_abbrev_buffer;
1161
/* We use dwarf2_tmp_obstack for objects that don't need to survive
1162
the partial symbol scan, like attribute values.
1164
We could reduce our peak memory consumption during partial symbol
1165
table construction by freeing stuff from this obstack more often
1166
--- say, after processing each compilation unit, or each die ---
1167
but it turns out that this saves almost nothing. For an
1168
executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1169
on dwarf2_tmp_obstack. Some investigation showed:
1171
1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1172
DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1173
all fixed-length values not requiring dynamic allocation.
1175
2) 30% of the attributes used the form DW_FORM_string. For
1176
DW_FORM_string, read_attribute simply hands back a pointer to
1177
the null-terminated string in dwarf_info_buffer, so no dynamic
1178
allocation is needed there either.
1180
3) The remaining 1% of the attributes all used DW_FORM_block1.
1181
75% of those were DW_AT_frame_base location lists for
1182
functions; the rest were DW_AT_location attributes, probably
1183
for the global variables.
1185
Anyway, what this all means is that the memory the dwarf2
1186
reader uses as temporary space reading partial symbols is about
1187
0.5% as much as we use for dwarf_*_buffer. That's noise. */
1189
obstack_init (&dwarf2_tmp_obstack);
1190
back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1192
/* Since the objects we're extracting from dwarf_info_buffer vary in
1193
length, only the individual functions to extract them (like
1194
read_comp_unit_head and read_partial_die) can really know whether
1195
the buffer is large enough to hold another complete object.
1197
At the moment, they don't actually check that. If
1198
dwarf_info_buffer holds just one extra byte after the last
1199
compilation unit's dies, then read_comp_unit_head will happily
1200
read off the end of the buffer. read_partial_die is similarly
1201
casual. Those functions should be fixed.
1203
For this loop condition, simply checking whether there's any data
1204
left at all should be sufficient. */
1205
while (info_ptr < dwarf_info_buffer + dwarf_info_size)
1207
struct dwarf2_cu cu;
1208
beg_of_comp_unit = info_ptr;
1210
cu.objfile = objfile;
1211
info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
1213
if (cu.header.version != 2)
1215
error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu.header.version, 2, bfd_get_filename (abfd));
1218
if (cu.header.abbrev_offset >= dwarf_abbrev_size)
1220
error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1221
(long) cu.header.abbrev_offset,
1222
(long) (beg_of_comp_unit - dwarf_info_buffer),
1223
bfd_get_filename (abfd));
1226
if (beg_of_comp_unit + cu.header.length + cu.header.initial_length_size
1227
> dwarf_info_buffer + dwarf_info_size)
1229
error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1230
(long) cu.header.length,
1231
(long) (beg_of_comp_unit - dwarf_info_buffer),
1232
bfd_get_filename (abfd));
1235
/* Complete the cu_header */
1236
cu.header.offset = beg_of_comp_unit - dwarf_info_buffer;
1237
cu.header.first_die_ptr = info_ptr;
1238
cu.header.cu_head_ptr = beg_of_comp_unit;
1240
cu.list_in_scope = &file_symbols;
1242
/* Read the abbrevs for this compilation unit into a table */
1243
dwarf2_read_abbrevs (abfd, &cu);
1244
make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
1246
/* Read the compilation unit die */
1247
info_ptr = read_partial_die (&comp_unit_die, abfd, info_ptr,
1250
/* Set the language we're debugging */
1251
set_cu_language (comp_unit_die.language, &cu);
1253
/* Allocate a new partial symbol table structure */
1254
pst = start_psymtab_common (objfile, objfile->section_offsets,
1255
comp_unit_die.name ? comp_unit_die.name : "",
1256
comp_unit_die.lowpc,
1257
objfile->global_psymbols.next,
1258
objfile->static_psymbols.next);
1260
pst->read_symtab_private = (char *)
1261
obstack_alloc (&objfile->objfile_obstack, sizeof (struct dwarf2_pinfo));
1262
DWARF_INFO_BUFFER (pst) = dwarf_info_buffer;
1263
DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf_info_buffer;
1264
DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer;
1265
DWARF_ABBREV_SIZE (pst) = dwarf_abbrev_size;
1266
DWARF_LINE_BUFFER (pst) = dwarf_line_buffer;
1267
DWARF_LINE_SIZE (pst) = dwarf_line_size;
1268
DWARF_STR_BUFFER (pst) = dwarf_str_buffer;
1269
DWARF_STR_SIZE (pst) = dwarf_str_size;
1270
DWARF_MACINFO_BUFFER (pst) = dwarf_macinfo_buffer;
1271
DWARF_MACINFO_SIZE (pst) = dwarf_macinfo_size;
1272
DWARF_RANGES_BUFFER (pst) = dwarf_ranges_buffer;
1273
DWARF_RANGES_SIZE (pst) = dwarf_ranges_size;
1274
DWARF_LOC_BUFFER (pst) = dwarf_loc_buffer;
1275
DWARF_LOC_SIZE (pst) = dwarf_loc_size;
1276
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1278
/* Store the function that reads in the rest of the symbol table */
1279
pst->read_symtab = dwarf2_psymtab_to_symtab;
1281
/* Check if comp unit has_children.
1282
If so, read the rest of the partial symbols from this comp unit.
1283
If not, there's no more debug_info for this comp unit. */
1284
if (comp_unit_die.has_children)
1286
lowpc = ((CORE_ADDR) -1);
1287
highpc = ((CORE_ADDR) 0);
1289
info_ptr = scan_partial_symbols (info_ptr, &lowpc, &highpc,
1292
/* If we didn't find a lowpc, set it to highpc to avoid
1293
complaints from `maint check'. */
1294
if (lowpc == ((CORE_ADDR) -1))
1297
/* If the compilation unit didn't have an explicit address range,
1298
then use the information extracted from its child dies. */
1299
if (! comp_unit_die.has_pc_info)
1301
comp_unit_die.lowpc = lowpc;
1302
comp_unit_die.highpc = highpc;
1305
pst->textlow = comp_unit_die.lowpc + baseaddr;
1306
pst->texthigh = comp_unit_die.highpc + baseaddr;
1308
pst->n_global_syms = objfile->global_psymbols.next -
1309
(objfile->global_psymbols.list + pst->globals_offset);
1310
pst->n_static_syms = objfile->static_psymbols.next -
1311
(objfile->static_psymbols.list + pst->statics_offset);
1312
sort_pst_symbols (pst);
1314
/* If there is already a psymtab or symtab for a file of this
1315
name, remove it. (If there is a symtab, more drastic things
1316
also happen.) This happens in VxWorks. */
1317
free_named_symtabs (pst->filename);
1319
info_ptr = beg_of_comp_unit + cu.header.length
1320
+ cu.header.initial_length_size;
1322
do_cleanups (back_to);
1325
/* Read in all interesting dies to the end of the compilation unit or
1326
to the end of the current namespace. NAMESPACE is NULL if we
1327
haven't yet encountered any DW_TAG_namespace entries; otherwise,
1328
it's the name of the current namespace. In particular, it's the
1329
empty string if we're currently in the global namespace but have
1330
previously encountered a DW_TAG_namespace. */
1333
scan_partial_symbols (char *info_ptr, CORE_ADDR *lowpc,
1334
CORE_ADDR *highpc, struct dwarf2_cu *cu,
1335
const char *namespace)
1337
struct objfile *objfile = cu->objfile;
1338
bfd *abfd = objfile->obfd;
1339
struct partial_die_info pdi;
1341
/* Now, march along the PDI's, descending into ones which have
1342
interesting children but skipping the children of the other ones,
1343
until we reach the end of the compilation unit. */
1347
/* This flag tells whether or not info_ptr has gotten updated
1349
int info_ptr_updated = 0;
1351
info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1353
/* Anonymous namespaces have no name but have interesting
1354
children, so we need to look at them. Ditto for anonymous
1357
if (pdi.name != NULL || pdi.tag == DW_TAG_namespace
1358
|| pdi.tag == DW_TAG_enumeration_type)
1362
case DW_TAG_subprogram:
1363
if (pdi.has_pc_info)
1365
if (pdi.lowpc < *lowpc)
1369
if (pdi.highpc > *highpc)
1371
*highpc = pdi.highpc;
1373
if (!pdi.is_declaration)
1375
add_partial_symbol (&pdi, cu, namespace);
1379
case DW_TAG_variable:
1380
case DW_TAG_typedef:
1381
case DW_TAG_union_type:
1382
if (!pdi.is_declaration)
1384
add_partial_symbol (&pdi, cu, namespace);
1387
case DW_TAG_class_type:
1388
case DW_TAG_structure_type:
1389
if (!pdi.is_declaration)
1391
info_ptr = add_partial_structure (&pdi, info_ptr, cu,
1393
info_ptr_updated = 1;
1396
case DW_TAG_enumeration_type:
1397
if (!pdi.is_declaration)
1399
info_ptr = add_partial_enumeration (&pdi, info_ptr, cu,
1401
info_ptr_updated = 1;
1404
case DW_TAG_base_type:
1405
case DW_TAG_subrange_type:
1406
/* File scope base type definitions are added to the partial
1408
add_partial_symbol (&pdi, cu, namespace);
1410
case DW_TAG_namespace:
1411
/* We've hit a DW_TAG_namespace entry, so we know this
1412
file has been compiled using a compiler that
1413
generates them; update NAMESPACE to reflect that. */
1414
if (namespace == NULL)
1416
info_ptr = add_partial_namespace (&pdi, info_ptr, lowpc, highpc,
1418
info_ptr_updated = 1;
1428
/* If the die has a sibling, skip to the sibling, unless another
1429
function has already updated info_ptr for us. */
1431
/* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1432
or not we want to update this depends on enough stuff (not
1433
only pdi.tag but also whether or not pdi.name is NULL) that
1434
this seems like the easiest way to handle the issue. */
1436
if (!info_ptr_updated)
1437
info_ptr = locate_pdi_sibling (&pdi, info_ptr, abfd, cu);
1444
add_partial_symbol (struct partial_die_info *pdi,
1445
struct dwarf2_cu *cu, const char *namespace)
1447
struct objfile *objfile = cu->objfile;
1449
char *actual_name = pdi->name;
1450
const struct partial_symbol *psym = NULL;
1453
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1455
/* If we're not in the global namespace and if the namespace name
1456
isn't encoded in a mangled actual_name, add it. */
1458
if (pdi_needs_namespace (pdi->tag, namespace))
1460
actual_name = alloca (strlen (pdi->name) + 2 + strlen (namespace) + 1);
1461
strcpy (actual_name, namespace);
1462
strcat (actual_name, "::");
1463
strcat (actual_name, pdi->name);
1468
case DW_TAG_subprogram:
1469
if (pdi->is_external)
1471
/*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1472
mst_text, objfile); */
1473
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1474
VAR_DOMAIN, LOC_BLOCK,
1475
&objfile->global_psymbols,
1476
0, pdi->lowpc + baseaddr,
1477
cu->language, objfile);
1481
/*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1482
mst_file_text, objfile); */
1483
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1484
VAR_DOMAIN, LOC_BLOCK,
1485
&objfile->static_psymbols,
1486
0, pdi->lowpc + baseaddr,
1487
cu->language, objfile);
1490
case DW_TAG_variable:
1491
if (pdi->is_external)
1494
Don't enter into the minimal symbol tables as there is
1495
a minimal symbol table entry from the ELF symbols already.
1496
Enter into partial symbol table if it has a location
1497
descriptor or a type.
1498
If the location descriptor is missing, new_symbol will create
1499
a LOC_UNRESOLVED symbol, the address of the variable will then
1500
be determined from the minimal symbol table whenever the variable
1502
The address for the partial symbol table entry is not
1503
used by GDB, but it comes in handy for debugging partial symbol
1507
addr = decode_locdesc (pdi->locdesc, cu);
1508
if (pdi->locdesc || pdi->has_type)
1509
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1510
VAR_DOMAIN, LOC_STATIC,
1511
&objfile->global_psymbols,
1513
cu->language, objfile);
1517
/* Static Variable. Skip symbols without location descriptors. */
1518
if (pdi->locdesc == NULL)
1520
addr = decode_locdesc (pdi->locdesc, cu);
1521
/*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1522
mst_file_data, objfile); */
1523
psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1524
VAR_DOMAIN, LOC_STATIC,
1525
&objfile->static_psymbols,
1527
cu->language, objfile);
1530
case DW_TAG_typedef:
1531
case DW_TAG_base_type:
1532
case DW_TAG_subrange_type:
1533
add_psymbol_to_list (actual_name, strlen (actual_name),
1534
VAR_DOMAIN, LOC_TYPEDEF,
1535
&objfile->static_psymbols,
1536
0, (CORE_ADDR) 0, cu->language, objfile);
1538
case DW_TAG_class_type:
1539
case DW_TAG_structure_type:
1540
case DW_TAG_union_type:
1541
case DW_TAG_enumeration_type:
1542
/* Skip aggregate types without children, these are external
1544
/* NOTE: carlton/2003-10-07: See comment in new_symbol about
1545
static vs. global. */
1546
if (pdi->has_children == 0)
1548
add_psymbol_to_list (actual_name, strlen (actual_name),
1549
STRUCT_DOMAIN, LOC_TYPEDEF,
1550
cu->language == language_cplus
1551
? &objfile->global_psymbols
1552
: &objfile->static_psymbols,
1553
0, (CORE_ADDR) 0, cu->language, objfile);
1555
if (cu->language == language_cplus)
1557
/* For C++, these implicitly act as typedefs as well. */
1558
add_psymbol_to_list (actual_name, strlen (actual_name),
1559
VAR_DOMAIN, LOC_TYPEDEF,
1560
&objfile->global_psymbols,
1561
0, (CORE_ADDR) 0, cu->language, objfile);
1564
case DW_TAG_enumerator:
1565
add_psymbol_to_list (actual_name, strlen (actual_name),
1566
VAR_DOMAIN, LOC_CONST,
1567
cu->language == language_cplus
1568
? &objfile->global_psymbols
1569
: &objfile->static_psymbols,
1570
0, (CORE_ADDR) 0, cu->language, objfile);
1576
/* Check to see if we should scan the name for possible namespace
1577
info. Only do this if this is C++, if we don't have namespace
1578
debugging info in the file, if the psym is of an appropriate type
1579
(otherwise we'll have psym == NULL), and if we actually had a
1580
mangled name to begin with. */
1582
if (cu->language == language_cplus
1583
&& namespace == NULL
1585
&& SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
1586
cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
1590
/* Determine whether a die of type TAG living in the C++ namespace
1591
NAMESPACE needs to have the name of the namespace prepended to the
1592
name listed in the die. */
1595
pdi_needs_namespace (enum dwarf_tag tag, const char *namespace)
1597
if (namespace == NULL || namespace[0] == '\0')
1602
case DW_TAG_typedef:
1603
case DW_TAG_class_type:
1604
case DW_TAG_structure_type:
1605
case DW_TAG_union_type:
1606
case DW_TAG_enumeration_type:
1607
case DW_TAG_enumerator:
1614
/* Read a partial die corresponding to a namespace; also, add a symbol
1615
corresponding to that namespace to the symbol table. NAMESPACE is
1616
the name of the enclosing namespace. */
1619
add_partial_namespace (struct partial_die_info *pdi, char *info_ptr,
1620
CORE_ADDR *lowpc, CORE_ADDR *highpc,
1621
struct dwarf2_cu *cu, const char *namespace)
1623
struct objfile *objfile = cu->objfile;
1624
const char *new_name = pdi->name;
1627
/* Calculate the full name of the namespace that we just entered. */
1629
if (new_name == NULL)
1630
new_name = "(anonymous namespace)";
1631
full_name = alloca (strlen (namespace) + 2 + strlen (new_name) + 1);
1632
strcpy (full_name, namespace);
1633
if (*namespace != '\0')
1634
strcat (full_name, "::");
1635
strcat (full_name, new_name);
1637
/* FIXME: carlton/2003-10-07: We can't just replace this by a call
1638
to add_partial_symbol, because we don't have a way to pass in the
1639
full name to that function; that might be a flaw in
1640
add_partial_symbol's interface. */
1642
add_psymbol_to_list (full_name, strlen (full_name),
1643
VAR_DOMAIN, LOC_TYPEDEF,
1644
&objfile->global_psymbols,
1645
0, 0, cu->language, objfile);
1647
/* Now scan partial symbols in that namespace. */
1649
if (pdi->has_children)
1650
info_ptr = scan_partial_symbols (info_ptr, lowpc, highpc, cu, full_name);
1655
/* Read a partial die corresponding to a class or structure. */
1658
add_partial_structure (struct partial_die_info *struct_pdi, char *info_ptr,
1659
struct dwarf2_cu *cu,
1660
const char *namespace)
1662
bfd *abfd = cu->objfile->obfd;
1663
char *actual_class_name = NULL;
1665
if (cu->language == language_cplus
1666
&& (namespace == NULL || namespace[0] == '\0')
1667
&& struct_pdi->name != NULL
1668
&& struct_pdi->has_children)
1670
/* See if we can figure out if the class lives in a namespace
1671
(or is nested within another class.) We do this by looking
1672
for a member function; its demangled name will contain
1673
namespace info, if there is any. */
1675
/* NOTE: carlton/2003-10-07: Getting the info this way changes
1676
what template types look like, because the demangler
1677
frequently doesn't give the same name as the debug info. We
1678
could fix this by only using the demangled name to get the
1679
prefix (but see comment in read_structure_type). */
1681
/* FIXME: carlton/2004-01-23: If NAMESPACE equals "", we have
1682
the appropriate debug information, so it would be nice to be
1683
able to avoid this hack. But NAMESPACE may not be the
1684
namespace where this class was defined: NAMESPACE reflects
1685
where STRUCT_PDI occurs in the tree of dies, but because of
1686
DW_AT_specification, that may not actually tell us where the
1687
class is defined. (See the comment in read_func_scope for an
1688
example of how this could occur.)
1690
Unfortunately, our current partial symtab data structures are
1691
completely unable to deal with DW_AT_specification. So, for
1692
now, the best thing to do is to get nesting information from
1693
places other than the tree structure of dies if there's any
1694
chance that a DW_AT_specification is involved. :-( */
1696
char *next_child = info_ptr;
1700
struct partial_die_info child_pdi;
1702
next_child = read_partial_die (&child_pdi, abfd, next_child,
1706
if (child_pdi.tag == DW_TAG_subprogram)
1708
actual_class_name = class_name_from_physname (child_pdi.name);
1709
if (actual_class_name != NULL)
1710
struct_pdi->name = actual_class_name;
1715
next_child = locate_pdi_sibling (&child_pdi, next_child,
1721
add_partial_symbol (struct_pdi, cu, namespace);
1722
xfree (actual_class_name);
1724
return locate_pdi_sibling (struct_pdi, info_ptr, abfd, cu);
1727
/* Read a partial die corresponding to an enumeration type. */
1730
add_partial_enumeration (struct partial_die_info *enum_pdi, char *info_ptr,
1731
struct dwarf2_cu *cu, const char *namespace)
1733
struct objfile *objfile = cu->objfile;
1734
bfd *abfd = objfile->obfd;
1735
struct partial_die_info pdi;
1737
if (enum_pdi->name != NULL)
1738
add_partial_symbol (enum_pdi, cu, namespace);
1742
info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1745
if (pdi.tag != DW_TAG_enumerator || pdi.name == NULL)
1746
complaint (&symfile_complaints, "malformed enumerator DIE ignored");
1748
add_partial_symbol (&pdi, cu, namespace);
1754
/* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1758
locate_pdi_sibling (struct partial_die_info *orig_pdi, char *info_ptr,
1759
bfd *abfd, struct dwarf2_cu *cu)
1761
/* Do we know the sibling already? */
1763
if (orig_pdi->sibling)
1764
return orig_pdi->sibling;
1766
/* Are there any children to deal with? */
1768
if (!orig_pdi->has_children)
1771
/* Okay, we don't know the sibling, but we have children that we
1772
want to skip. So read children until we run into one without a
1773
tag; return whatever follows it. */
1777
struct partial_die_info pdi;
1779
info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu);
1784
info_ptr = locate_pdi_sibling (&pdi, info_ptr, abfd, cu);
1788
/* Expand this partial symbol table into a full symbol table. */
1791
dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
1793
/* FIXME: This is barely more than a stub. */
1798
warning ("bug: psymtab for %s is already read in.", pst->filename);
1804
printf_filtered ("Reading in symbols for %s...", pst->filename);
1805
gdb_flush (gdb_stdout);
1808
psymtab_to_symtab_1 (pst);
1810
/* Finish up the debug error message. */
1812
printf_filtered ("done.\n");
1818
psymtab_to_symtab_1 (struct partial_symtab *pst)
1820
struct objfile *objfile = pst->objfile;
1821
bfd *abfd = objfile->obfd;
1822
struct dwarf2_cu cu;
1823
struct die_info *dies;
1824
unsigned long offset;
1825
CORE_ADDR lowpc, highpc;
1826
struct die_info *child_die;
1828
struct symtab *symtab;
1829
struct cleanup *back_to;
1830
struct attribute *attr;
1833
/* Set local variables from the partial symbol table info. */
1834
offset = DWARF_INFO_OFFSET (pst);
1835
dwarf_info_buffer = DWARF_INFO_BUFFER (pst);
1836
dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER (pst);
1837
dwarf_abbrev_size = DWARF_ABBREV_SIZE (pst);
1838
dwarf_line_buffer = DWARF_LINE_BUFFER (pst);
1839
dwarf_line_size = DWARF_LINE_SIZE (pst);
1840
dwarf_str_buffer = DWARF_STR_BUFFER (pst);
1841
dwarf_str_size = DWARF_STR_SIZE (pst);
1842
dwarf_macinfo_buffer = DWARF_MACINFO_BUFFER (pst);
1843
dwarf_macinfo_size = DWARF_MACINFO_SIZE (pst);
1844
dwarf_ranges_buffer = DWARF_RANGES_BUFFER (pst);
1845
dwarf_ranges_size = DWARF_RANGES_SIZE (pst);
1846
dwarf_loc_buffer = DWARF_LOC_BUFFER (pst);
1847
dwarf_loc_size = DWARF_LOC_SIZE (pst);
1848
info_ptr = dwarf_info_buffer + offset;
1849
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1851
/* We're in the global namespace. */
1852
processing_current_prefix = "";
1854
obstack_init (&dwarf2_tmp_obstack);
1855
back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1858
make_cleanup (really_free_pendings, NULL);
1860
cu.objfile = objfile;
1862
/* read in the comp_unit header */
1863
info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
1865
/* Read the abbrevs for this compilation unit */
1866
dwarf2_read_abbrevs (abfd, &cu);
1867
make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
1869
cu.header.offset = offset;
1871
cu.list_in_scope = &file_symbols;
1873
dies = read_comp_unit (info_ptr, abfd, &cu);
1875
make_cleanup_free_die_list (dies);
1877
/* Find the base address of the compilation unit for range lists and
1878
location lists. It will normally be specified by DW_AT_low_pc.
1879
In DWARF-3 draft 4, the base address could be overridden by
1880
DW_AT_entry_pc. It's been removed, but GCC still uses this for
1881
compilation units with discontinuous ranges. */
1883
cu.header.base_known = 0;
1884
cu.header.base_address = 0;
1886
attr = dwarf2_attr (dies, DW_AT_entry_pc, &cu);
1889
cu.header.base_address = DW_ADDR (attr);
1890
cu.header.base_known = 1;
1894
attr = dwarf2_attr (dies, DW_AT_low_pc, &cu);
1897
cu.header.base_address = DW_ADDR (attr);
1898
cu.header.base_known = 1;
1902
/* Do line number decoding in read_file_scope () */
1903
process_die (dies, &cu);
1905
/* Some compilers don't define a DW_AT_high_pc attribute for the
1906
compilation unit. If the DW_AT_high_pc is missing, synthesize
1907
it, by scanning the DIE's below the compilation unit. */
1908
get_scope_pc_bounds (dies, &lowpc, &highpc, &cu);
1910
symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
1912
/* Set symtab language to language from DW_AT_language.
1913
If the compilation is from a C file generated by language preprocessors,
1914
do not set the language if it was already deduced by start_subfile. */
1916
&& !(cu.language == language_c && symtab->language != language_c))
1918
symtab->language = cu.language;
1920
pst->symtab = symtab;
1923
do_cleanups (back_to);
1926
/* Process a die and its children. */
1929
process_die (struct die_info *die, struct dwarf2_cu *cu)
1933
case DW_TAG_padding:
1935
case DW_TAG_compile_unit:
1936
read_file_scope (die, cu);
1938
case DW_TAG_subprogram:
1939
read_subroutine_type (die, cu);
1940
read_func_scope (die, cu);
1942
case DW_TAG_inlined_subroutine:
1943
/* FIXME: These are ignored for now.
1944
They could be used to set breakpoints on all inlined instances
1945
of a function and make GDB `next' properly over inlined functions. */
1947
case DW_TAG_lexical_block:
1948
case DW_TAG_try_block:
1949
case DW_TAG_catch_block:
1950
read_lexical_block_scope (die, cu);
1952
case DW_TAG_class_type:
1953
case DW_TAG_structure_type:
1954
case DW_TAG_union_type:
1955
read_structure_type (die, cu);
1956
process_structure_scope (die, cu);
1958
case DW_TAG_enumeration_type:
1959
read_enumeration_type (die, cu);
1960
process_enumeration_scope (die, cu);
1963
/* FIXME drow/2004-03-14: These initialize die->type, but do not create
1964
a symbol or process any children. Therefore it doesn't do anything
1965
that won't be done on-demand by read_type_die. */
1966
case DW_TAG_subroutine_type:
1967
read_subroutine_type (die, cu);
1969
case DW_TAG_array_type:
1970
read_array_type (die, cu);
1972
case DW_TAG_pointer_type:
1973
read_tag_pointer_type (die, cu);
1975
case DW_TAG_ptr_to_member_type:
1976
read_tag_ptr_to_member_type (die, cu);
1978
case DW_TAG_reference_type:
1979
read_tag_reference_type (die, cu);
1981
case DW_TAG_string_type:
1982
read_tag_string_type (die, cu);
1986
case DW_TAG_base_type:
1987
read_base_type (die, cu);
1988
/* Add a typedef symbol for the type definition, if it has a
1990
new_symbol (die, die->type, cu);
1992
case DW_TAG_subrange_type:
1993
read_subrange_type (die, cu);
1994
/* Add a typedef symbol for the type definition, if it has a
1996
new_symbol (die, die->type, cu);
1998
case DW_TAG_common_block:
1999
read_common_block (die, cu);
2001
case DW_TAG_common_inclusion:
2003
case DW_TAG_namespace:
2004
processing_has_namespace_info = 1;
2005
read_namespace (die, cu);
2007
case DW_TAG_imported_declaration:
2008
case DW_TAG_imported_module:
2009
/* FIXME: carlton/2002-10-16: Eventually, we should use the
2010
information contained in these. DW_TAG_imported_declaration
2011
dies shouldn't have children; DW_TAG_imported_module dies
2012
shouldn't in the C++ case, but conceivably could in the
2013
Fortran case, so we'll have to replace this gdb_assert if
2014
Fortran compilers start generating that info. */
2015
processing_has_namespace_info = 1;
2016
gdb_assert (die->child == NULL);
2019
new_symbol (die, NULL, cu);
2025
initialize_cu_func_list (struct dwarf2_cu *cu)
2027
cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2031
read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2033
struct objfile *objfile = cu->objfile;
2034
struct comp_unit_head *cu_header = &cu->header;
2035
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2036
CORE_ADDR lowpc = ((CORE_ADDR) -1);
2037
CORE_ADDR highpc = ((CORE_ADDR) 0);
2038
struct attribute *attr;
2039
char *name = "<unknown>";
2040
char *comp_dir = NULL;
2041
struct die_info *child_die;
2042
bfd *abfd = objfile->obfd;
2043
struct line_header *line_header = 0;
2046
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2048
get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2050
/* If we didn't find a lowpc, set it to highpc to avoid complaints
2051
from finish_block. */
2052
if (lowpc == ((CORE_ADDR) -1))
2057
attr = dwarf2_attr (die, DW_AT_name, cu);
2060
name = DW_STRING (attr);
2062
attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2065
comp_dir = DW_STRING (attr);
2068
/* Irix 6.2 native cc prepends <machine>.: to the compilation
2069
directory, get rid of it. */
2070
char *cp = strchr (comp_dir, ':');
2072
if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2077
if (objfile->ei.entry_point >= lowpc &&
2078
objfile->ei.entry_point < highpc)
2080
objfile->ei.deprecated_entry_file_lowpc = lowpc;
2081
objfile->ei.deprecated_entry_file_highpc = highpc;
2084
attr = dwarf2_attr (die, DW_AT_language, cu);
2087
set_cu_language (DW_UNSND (attr), cu);
2090
/* We assume that we're processing GCC output. */
2091
processing_gcc_compilation = 2;
2093
/* FIXME:Do something here. */
2094
if (dip->at_producer != NULL)
2096
handle_producer (dip->at_producer);
2100
/* The compilation unit may be in a different language or objfile,
2101
zero out all remembered fundamental types. */
2102
memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2104
start_symtab (name, comp_dir, lowpc);
2105
record_debugformat ("DWARF 2");
2107
initialize_cu_func_list (cu);
2109
/* Process all dies in compilation unit. */
2110
if (die->child != NULL)
2112
child_die = die->child;
2113
while (child_die && child_die->tag)
2115
process_die (child_die, cu);
2116
child_die = sibling_die (child_die);
2120
/* Decode line number information if present. */
2121
attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2124
unsigned int line_offset = DW_UNSND (attr);
2125
line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2128
make_cleanup ((make_cleanup_ftype *) free_line_header,
2129
(void *) line_header);
2130
dwarf_decode_lines (line_header, comp_dir, abfd, cu);
2134
/* Decode macro information, if present. Dwarf 2 macro information
2135
refers to information in the line number info statement program
2136
header, so we can only read it if we've read the header
2138
attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2139
if (attr && line_header)
2141
unsigned int macro_offset = DW_UNSND (attr);
2142
dwarf_decode_macros (line_header, macro_offset,
2143
comp_dir, abfd, cu);
2145
do_cleanups (back_to);
2149
add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2150
struct dwarf2_cu *cu)
2152
struct function_range *thisfn;
2154
thisfn = (struct function_range *)
2155
obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct function_range));
2156
thisfn->name = name;
2157
thisfn->lowpc = lowpc;
2158
thisfn->highpc = highpc;
2159
thisfn->seen_line = 0;
2160
thisfn->next = NULL;
2162
if (cu->last_fn == NULL)
2163
cu->first_fn = thisfn;
2165
cu->last_fn->next = thisfn;
2167
cu->last_fn = thisfn;
2171
read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2173
struct objfile *objfile = cu->objfile;
2174
struct context_stack *new;
2177
struct die_info *child_die;
2178
struct attribute *attr;
2180
const char *previous_prefix = processing_current_prefix;
2181
struct cleanup *back_to = NULL;
2184
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2186
name = dwarf2_linkage_name (die, cu);
2188
/* Ignore functions with missing or empty names and functions with
2189
missing or invalid low and high pc attributes. */
2190
if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2193
if (cu->language == language_cplus)
2195
struct die_info *spec_die = die_specification (die, cu);
2197
/* NOTE: carlton/2004-01-23: We have to be careful in the
2198
presence of DW_AT_specification. For example, with GCC 3.4,
2203
// Definition of N::foo.
2207
then we'll have a tree of DIEs like this:
2209
1: DW_TAG_compile_unit
2210
2: DW_TAG_namespace // N
2211
3: DW_TAG_subprogram // declaration of N::foo
2212
4: DW_TAG_subprogram // definition of N::foo
2213
DW_AT_specification // refers to die #3
2215
Thus, when processing die #4, we have to pretend that we're
2216
in the context of its DW_AT_specification, namely the contex
2219
if (spec_die != NULL)
2221
char *specification_prefix = determine_prefix (spec_die, cu);
2222
processing_current_prefix = specification_prefix;
2223
back_to = make_cleanup (xfree, specification_prefix);
2230
/* Record the function range for dwarf_decode_lines. */
2231
add_to_cu_func_list (name, lowpc, highpc, cu);
2233
if (objfile->ei.entry_point >= lowpc &&
2234
objfile->ei.entry_point < highpc)
2236
objfile->ei.entry_func_lowpc = lowpc;
2237
objfile->ei.entry_func_highpc = highpc;
2240
new = push_context (0, lowpc);
2241
new->name = new_symbol (die, die->type, cu);
2243
/* If there is a location expression for DW_AT_frame_base, record
2245
attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2247
/* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2248
expression is being recorded directly in the function's symbol
2249
and not in a separate frame-base object. I guess this hack is
2250
to avoid adding some sort of frame-base adjunct/annex to the
2251
function's symbol :-(. The problem with doing this is that it
2252
results in a function symbol with a location expression that
2253
has nothing to do with the location of the function, ouch! The
2254
relationship should be: a function's symbol has-a frame base; a
2255
frame-base has-a location expression. */
2256
dwarf2_symbol_mark_computed (attr, new->name, cu);
2258
cu->list_in_scope = &local_symbols;
2260
if (die->child != NULL)
2262
child_die = die->child;
2263
while (child_die && child_die->tag)
2265
process_die (child_die, cu);
2266
child_die = sibling_die (child_die);
2270
new = pop_context ();
2271
/* Make a block for the local symbols within. */
2272
finish_block (new->name, &local_symbols, new->old_blocks,
2273
lowpc, highpc, objfile);
2275
/* In C++, we can have functions nested inside functions (e.g., when
2276
a function declares a class that has methods). This means that
2277
when we finish processing a function scope, we may need to go
2278
back to building a containing block's symbol lists. */
2279
local_symbols = new->locals;
2280
param_symbols = new->params;
2282
/* If we've finished processing a top-level function, subsequent
2283
symbols go in the file symbol list. */
2284
if (outermost_context_p ())
2285
cu->list_in_scope = &file_symbols;
2287
processing_current_prefix = previous_prefix;
2288
if (back_to != NULL)
2289
do_cleanups (back_to);
2292
/* Process all the DIES contained within a lexical block scope. Start
2293
a new scope, process the dies, and then close the scope. */
2296
read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2298
struct objfile *objfile = cu->objfile;
2299
struct context_stack *new;
2300
CORE_ADDR lowpc, highpc;
2301
struct die_info *child_die;
2304
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2306
/* Ignore blocks with missing or invalid low and high pc attributes. */
2307
/* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2308
as multiple lexical blocks? Handling children in a sane way would
2309
be nasty. Might be easier to properly extend generic blocks to
2311
if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2316
push_context (0, lowpc);
2317
if (die->child != NULL)
2319
child_die = die->child;
2320
while (child_die && child_die->tag)
2322
process_die (child_die, cu);
2323
child_die = sibling_die (child_die);
2326
new = pop_context ();
2328
if (local_symbols != NULL)
2330
finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
2333
local_symbols = new->locals;
2336
/* Get low and high pc attributes from a die. Return 1 if the attributes
2337
are present and valid, otherwise, return 0. Return -1 if the range is
2338
discontinuous, i.e. derived from DW_AT_ranges information. */
2340
dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
2341
CORE_ADDR *highpc, struct dwarf2_cu *cu)
2343
struct objfile *objfile = cu->objfile;
2344
struct comp_unit_head *cu_header = &cu->header;
2345
struct attribute *attr;
2346
bfd *obfd = objfile->obfd;
2351
attr = dwarf2_attr (die, DW_AT_high_pc, cu);
2354
high = DW_ADDR (attr);
2355
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
2357
low = DW_ADDR (attr);
2359
/* Found high w/o low attribute. */
2362
/* Found consecutive range of addresses. */
2367
attr = dwarf2_attr (die, DW_AT_ranges, cu);
2370
unsigned int addr_size = cu_header->addr_size;
2371
CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2372
/* Value of the DW_AT_ranges attribute is the offset in the
2373
.debug_ranges section. */
2374
unsigned int offset = DW_UNSND (attr);
2375
/* Base address selection entry. */
2383
found_base = cu_header->base_known;
2384
base = cu_header->base_address;
2386
if (offset >= dwarf_ranges_size)
2388
complaint (&symfile_complaints,
2389
"Offset %d out of bounds for DW_AT_ranges attribute",
2393
buffer = dwarf_ranges_buffer + offset;
2395
/* Read in the largest possible address. */
2396
marker = read_address (obfd, buffer, cu, &dummy);
2397
if ((marker & mask) == mask)
2399
/* If we found the largest possible address, then
2400
read the base address. */
2401
base = read_address (obfd, buffer + addr_size, cu, &dummy);
2402
buffer += 2 * addr_size;
2403
offset += 2 * addr_size;
2411
CORE_ADDR range_beginning, range_end;
2413
range_beginning = read_address (obfd, buffer, cu, &dummy);
2414
buffer += addr_size;
2415
range_end = read_address (obfd, buffer, cu, &dummy);
2416
buffer += addr_size;
2417
offset += 2 * addr_size;
2419
/* An end of list marker is a pair of zero addresses. */
2420
if (range_beginning == 0 && range_end == 0)
2421
/* Found the end of list entry. */
2424
/* Each base address selection entry is a pair of 2 values.
2425
The first is the largest possible address, the second is
2426
the base address. Check for a base address here. */
2427
if ((range_beginning & mask) == mask)
2429
/* If we found the largest possible address, then
2430
read the base address. */
2431
base = read_address (obfd, buffer + addr_size, cu, &dummy);
2438
/* We have no valid base address for the ranges
2440
complaint (&symfile_complaints,
2441
"Invalid .debug_ranges data (no base address)");
2445
range_beginning += base;
2448
/* FIXME: This is recording everything as a low-high
2449
segment of consecutive addresses. We should have a
2450
data structure for discontiguous block ranges
2454
low = range_beginning;
2460
if (range_beginning < low)
2461
low = range_beginning;
2462
if (range_end > high)
2468
/* If the first entry is an end-of-list marker, the range
2469
describes an empty scope, i.e. no instructions. */
2479
/* When using the GNU linker, .gnu.linkonce. sections are used to
2480
eliminate duplicate copies of functions and vtables and such.
2481
The linker will arbitrarily choose one and discard the others.
2482
The AT_*_pc values for such functions refer to local labels in
2483
these sections. If the section from that file was discarded, the
2484
labels are not in the output, so the relocs get a value of 0.
2485
If this is a discarded function, mark the pc bounds as invalid,
2486
so that GDB will ignore it. */
2487
if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
2495
/* Get the low and high pc's represented by the scope DIE, and store
2496
them in *LOWPC and *HIGHPC. If the correct values can't be
2497
determined, set *LOWPC to -1 and *HIGHPC to 0. */
2500
get_scope_pc_bounds (struct die_info *die,
2501
CORE_ADDR *lowpc, CORE_ADDR *highpc,
2502
struct dwarf2_cu *cu)
2504
CORE_ADDR best_low = (CORE_ADDR) -1;
2505
CORE_ADDR best_high = (CORE_ADDR) 0;
2506
CORE_ADDR current_low, current_high;
2508
if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu))
2510
best_low = current_low;
2511
best_high = current_high;
2515
struct die_info *child = die->child;
2517
while (child && child->tag)
2519
switch (child->tag) {
2520
case DW_TAG_subprogram:
2521
if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu))
2523
best_low = min (best_low, current_low);
2524
best_high = max (best_high, current_high);
2527
case DW_TAG_namespace:
2528
/* FIXME: carlton/2004-01-16: Should we do this for
2529
DW_TAG_class_type/DW_TAG_structure_type, too? I think
2530
that current GCC's always emit the DIEs corresponding
2531
to definitions of methods of classes as children of a
2532
DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2533
the DIEs giving the declarations, which could be
2534
anywhere). But I don't see any reason why the
2535
standards says that they have to be there. */
2536
get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
2538
if (current_low != ((CORE_ADDR) -1))
2540
best_low = min (best_low, current_low);
2541
best_high = max (best_high, current_high);
2549
child = sibling_die (child);
2554
*highpc = best_high;
2557
/* Add an aggregate field to the field list. */
2560
dwarf2_add_field (struct field_info *fip, struct die_info *die,
2561
struct dwarf2_cu *cu)
2563
struct objfile *objfile = cu->objfile;
2564
struct nextfield *new_field;
2565
struct attribute *attr;
2567
char *fieldname = "";
2569
/* Allocate a new field list entry and link it in. */
2570
new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2571
make_cleanup (xfree, new_field);
2572
memset (new_field, 0, sizeof (struct nextfield));
2573
new_field->next = fip->fields;
2574
fip->fields = new_field;
2577
/* Handle accessibility and virtuality of field.
2578
The default accessibility for members is public, the default
2579
accessibility for inheritance is private. */
2580
if (die->tag != DW_TAG_inheritance)
2581
new_field->accessibility = DW_ACCESS_public;
2583
new_field->accessibility = DW_ACCESS_private;
2584
new_field->virtuality = DW_VIRTUALITY_none;
2586
attr = dwarf2_attr (die, DW_AT_accessibility, cu);
2588
new_field->accessibility = DW_UNSND (attr);
2589
if (new_field->accessibility != DW_ACCESS_public)
2590
fip->non_public_fields = 1;
2591
attr = dwarf2_attr (die, DW_AT_virtuality, cu);
2593
new_field->virtuality = DW_UNSND (attr);
2595
fp = &new_field->field;
2597
if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
2599
/* Data member other than a C++ static data member. */
2601
/* Get type of field. */
2602
fp->type = die_type (die, cu);
2604
FIELD_STATIC_KIND (*fp) = 0;
2606
/* Get bit size of field (zero if none). */
2607
attr = dwarf2_attr (die, DW_AT_bit_size, cu);
2610
FIELD_BITSIZE (*fp) = DW_UNSND (attr);
2614
FIELD_BITSIZE (*fp) = 0;
2617
/* Get bit offset of field. */
2618
attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2621
FIELD_BITPOS (*fp) =
2622
decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
2625
FIELD_BITPOS (*fp) = 0;
2626
attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
2629
if (BITS_BIG_ENDIAN)
2631
/* For big endian bits, the DW_AT_bit_offset gives the
2632
additional bit offset from the MSB of the containing
2633
anonymous object to the MSB of the field. We don't
2634
have to do anything special since we don't need to
2635
know the size of the anonymous object. */
2636
FIELD_BITPOS (*fp) += DW_UNSND (attr);
2640
/* For little endian bits, compute the bit offset to the
2641
MSB of the anonymous object, subtract off the number of
2642
bits from the MSB of the field to the MSB of the
2643
object, and then subtract off the number of bits of
2644
the field itself. The result is the bit offset of
2645
the LSB of the field. */
2647
int bit_offset = DW_UNSND (attr);
2649
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
2652
/* The size of the anonymous object containing
2653
the bit field is explicit, so use the
2654
indicated size (in bytes). */
2655
anonymous_size = DW_UNSND (attr);
2659
/* The size of the anonymous object containing
2660
the bit field must be inferred from the type
2661
attribute of the data member containing the
2663
anonymous_size = TYPE_LENGTH (fp->type);
2665
FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
2666
- bit_offset - FIELD_BITSIZE (*fp);
2670
/* Get name of field. */
2671
attr = dwarf2_attr (die, DW_AT_name, cu);
2672
if (attr && DW_STRING (attr))
2673
fieldname = DW_STRING (attr);
2674
fp->name = obsavestring (fieldname, strlen (fieldname),
2675
&objfile->objfile_obstack);
2677
/* Change accessibility for artificial fields (e.g. virtual table
2678
pointer or virtual base class pointer) to private. */
2679
if (dwarf2_attr (die, DW_AT_artificial, cu))
2681
new_field->accessibility = DW_ACCESS_private;
2682
fip->non_public_fields = 1;
2685
else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
2687
/* C++ static member. */
2689
/* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2690
is a declaration, but all versions of G++ as of this writing
2691
(so through at least 3.2.1) incorrectly generate
2692
DW_TAG_variable tags. */
2696
/* Get name of field. */
2697
attr = dwarf2_attr (die, DW_AT_name, cu);
2698
if (attr && DW_STRING (attr))
2699
fieldname = DW_STRING (attr);
2703
/* Get physical name. */
2704
physname = dwarf2_linkage_name (die, cu);
2706
SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname),
2707
&objfile->objfile_obstack));
2708
FIELD_TYPE (*fp) = die_type (die, cu);
2709
FIELD_NAME (*fp) = obsavestring (fieldname, strlen (fieldname),
2710
&objfile->objfile_obstack);
2712
else if (die->tag == DW_TAG_inheritance)
2714
/* C++ base class field. */
2715
attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2717
FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
2719
FIELD_BITSIZE (*fp) = 0;
2720
FIELD_STATIC_KIND (*fp) = 0;
2721
FIELD_TYPE (*fp) = die_type (die, cu);
2722
FIELD_NAME (*fp) = type_name_no_tag (fp->type);
2723
fip->nbaseclasses++;
2727
/* Create the vector of fields, and attach it to the type. */
2730
dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
2731
struct dwarf2_cu *cu)
2733
int nfields = fip->nfields;
2735
/* Record the field count, allocate space for the array of fields,
2736
and create blank accessibility bitfields if necessary. */
2737
TYPE_NFIELDS (type) = nfields;
2738
TYPE_FIELDS (type) = (struct field *)
2739
TYPE_ALLOC (type, sizeof (struct field) * nfields);
2740
memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
2742
if (fip->non_public_fields)
2744
ALLOCATE_CPLUS_STRUCT_TYPE (type);
2746
TYPE_FIELD_PRIVATE_BITS (type) =
2747
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2748
B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2750
TYPE_FIELD_PROTECTED_BITS (type) =
2751
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2752
B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2754
TYPE_FIELD_IGNORE_BITS (type) =
2755
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2756
B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
2759
/* If the type has baseclasses, allocate and clear a bit vector for
2760
TYPE_FIELD_VIRTUAL_BITS. */
2761
if (fip->nbaseclasses)
2763
int num_bytes = B_BYTES (fip->nbaseclasses);
2766
ALLOCATE_CPLUS_STRUCT_TYPE (type);
2767
pointer = (char *) TYPE_ALLOC (type, num_bytes);
2768
TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
2769
B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
2770
TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
2773
/* Copy the saved-up fields into the field vector. Start from the head
2774
of the list, adding to the tail of the field array, so that they end
2775
up in the same order in the array in which they were added to the list. */
2776
while (nfields-- > 0)
2778
TYPE_FIELD (type, nfields) = fip->fields->field;
2779
switch (fip->fields->accessibility)
2781
case DW_ACCESS_private:
2782
SET_TYPE_FIELD_PRIVATE (type, nfields);
2785
case DW_ACCESS_protected:
2786
SET_TYPE_FIELD_PROTECTED (type, nfields);
2789
case DW_ACCESS_public:
2793
/* Unknown accessibility. Complain and treat it as public. */
2795
complaint (&symfile_complaints, "unsupported accessibility %d",
2796
fip->fields->accessibility);
2800
if (nfields < fip->nbaseclasses)
2802
switch (fip->fields->virtuality)
2804
case DW_VIRTUALITY_virtual:
2805
case DW_VIRTUALITY_pure_virtual:
2806
SET_TYPE_FIELD_VIRTUAL (type, nfields);
2810
fip->fields = fip->fields->next;
2814
/* Add a member function to the proper fieldlist. */
2817
dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
2818
struct type *type, struct dwarf2_cu *cu)
2820
struct objfile *objfile = cu->objfile;
2821
struct attribute *attr;
2822
struct fnfieldlist *flp;
2824
struct fn_field *fnp;
2827
struct nextfnfield *new_fnfield;
2829
/* Get name of member function. */
2830
attr = dwarf2_attr (die, DW_AT_name, cu);
2831
if (attr && DW_STRING (attr))
2832
fieldname = DW_STRING (attr);
2836
/* Get the mangled name. */
2837
physname = dwarf2_linkage_name (die, cu);
2839
/* Look up member function name in fieldlist. */
2840
for (i = 0; i < fip->nfnfields; i++)
2842
if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
2846
/* Create new list element if necessary. */
2847
if (i < fip->nfnfields)
2848
flp = &fip->fnfieldlists[i];
2851
if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
2853
fip->fnfieldlists = (struct fnfieldlist *)
2854
xrealloc (fip->fnfieldlists,
2855
(fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
2856
* sizeof (struct fnfieldlist));
2857
if (fip->nfnfields == 0)
2858
make_cleanup (free_current_contents, &fip->fnfieldlists);
2860
flp = &fip->fnfieldlists[fip->nfnfields];
2861
flp->name = fieldname;
2867
/* Create a new member function field and chain it to the field list
2869
new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
2870
make_cleanup (xfree, new_fnfield);
2871
memset (new_fnfield, 0, sizeof (struct nextfnfield));
2872
new_fnfield->next = flp->head;
2873
flp->head = new_fnfield;
2876
/* Fill in the member function field info. */
2877
fnp = &new_fnfield->fnfield;
2878
fnp->physname = obsavestring (physname, strlen (physname),
2879
&objfile->objfile_obstack);
2880
fnp->type = alloc_type (objfile);
2881
if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
2883
int nparams = TYPE_NFIELDS (die->type);
2885
/* TYPE is the domain of this method, and DIE->TYPE is the type
2886
of the method itself (TYPE_CODE_METHOD). */
2887
smash_to_method_type (fnp->type, type,
2888
TYPE_TARGET_TYPE (die->type),
2889
TYPE_FIELDS (die->type),
2890
TYPE_NFIELDS (die->type),
2891
TYPE_VARARGS (die->type));
2893
/* Handle static member functions.
2894
Dwarf2 has no clean way to discern C++ static and non-static
2895
member functions. G++ helps GDB by marking the first
2896
parameter for non-static member functions (which is the
2897
this pointer) as artificial. We obtain this information
2898
from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2899
if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
2900
fnp->voffset = VOFFSET_STATIC;
2903
complaint (&symfile_complaints, "member function type missing for '%s'",
2906
/* Get fcontext from DW_AT_containing_type if present. */
2907
if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
2908
fnp->fcontext = die_containing_type (die, cu);
2910
/* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2911
and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2913
/* Get accessibility. */
2914
attr = dwarf2_attr (die, DW_AT_accessibility, cu);
2917
switch (DW_UNSND (attr))
2919
case DW_ACCESS_private:
2920
fnp->is_private = 1;
2922
case DW_ACCESS_protected:
2923
fnp->is_protected = 1;
2928
/* Check for artificial methods. */
2929
attr = dwarf2_attr (die, DW_AT_artificial, cu);
2930
if (attr && DW_UNSND (attr) != 0)
2931
fnp->is_artificial = 1;
2933
/* Get index in virtual function table if it is a virtual member function. */
2934
attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
2937
/* Support the .debug_loc offsets */
2938
if (attr_form_is_block (attr))
2940
fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
2942
else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
2944
dwarf2_complex_location_expr_complaint ();
2948
dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2954
/* Create the vector of member function fields, and attach it to the type. */
2957
dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
2958
struct dwarf2_cu *cu)
2960
struct fnfieldlist *flp;
2961
int total_length = 0;
2964
ALLOCATE_CPLUS_STRUCT_TYPE (type);
2965
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2966
TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
2968
for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
2970
struct nextfnfield *nfp = flp->head;
2971
struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
2974
TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
2975
TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
2976
fn_flp->fn_fields = (struct fn_field *)
2977
TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
2978
for (k = flp->length; (k--, nfp); nfp = nfp->next)
2979
fn_flp->fn_fields[k] = nfp->fnfield;
2981
total_length += flp->length;
2984
TYPE_NFN_FIELDS (type) = fip->nfnfields;
2985
TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2988
/* Called when we find the DIE that starts a structure or union scope
2989
(definition) to process all dies that define the members of the
2992
NOTE: we need to call struct_type regardless of whether or not the
2993
DIE has an at_name attribute, since it might be an anonymous
2994
structure or union. This gets the type entered into our set of
2997
However, if the structure is incomplete (an opaque struct/union)
2998
then suppress creating a symbol table entry for it since gdb only
2999
wants to find the one with the complete definition. Note that if
3000
it is complete, we just call new_symbol, which does it's own
3001
checking about whether the struct/union is anonymous or not (and
3002
suppresses creating a symbol table entry itself). */
3005
read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3007
struct objfile *objfile = cu->objfile;
3009
struct attribute *attr;
3010
const char *previous_prefix = processing_current_prefix;
3011
struct cleanup *back_to = NULL;
3016
type = alloc_type (objfile);
3018
INIT_CPLUS_SPECIFIC (type);
3019
attr = dwarf2_attr (die, DW_AT_name, cu);
3020
if (attr && DW_STRING (attr))
3022
if (cu->language == language_cplus)
3024
char *new_prefix = determine_class_name (die, cu);
3025
TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3026
strlen (new_prefix),
3027
&objfile->objfile_obstack);
3028
back_to = make_cleanup (xfree, new_prefix);
3029
processing_current_prefix = new_prefix;
3033
TYPE_TAG_NAME (type) = DW_STRING (attr);
3037
if (die->tag == DW_TAG_structure_type)
3039
TYPE_CODE (type) = TYPE_CODE_STRUCT;
3041
else if (die->tag == DW_TAG_union_type)
3043
TYPE_CODE (type) = TYPE_CODE_UNION;
3047
/* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3049
TYPE_CODE (type) = TYPE_CODE_CLASS;
3052
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3055
TYPE_LENGTH (type) = DW_UNSND (attr);
3059
TYPE_LENGTH (type) = 0;
3062
/* We need to add the type field to the die immediately so we don't
3063
infinitely recurse when dealing with pointers to the structure
3064
type within the structure itself. */
3067
if (die->child != NULL && ! die_is_declaration (die, cu))
3069
struct field_info fi;
3070
struct die_info *child_die;
3071
struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3073
memset (&fi, 0, sizeof (struct field_info));
3075
child_die = die->child;
3077
while (child_die && child_die->tag)
3079
if (child_die->tag == DW_TAG_member
3080
|| child_die->tag == DW_TAG_variable)
3082
/* NOTE: carlton/2002-11-05: A C++ static data member
3083
should be a DW_TAG_member that is a declaration, but
3084
all versions of G++ as of this writing (so through at
3085
least 3.2.1) incorrectly generate DW_TAG_variable
3086
tags for them instead. */
3087
dwarf2_add_field (&fi, child_die, cu);
3089
else if (child_die->tag == DW_TAG_subprogram)
3091
/* C++ member function. */
3092
read_type_die (child_die, cu);
3093
dwarf2_add_member_fn (&fi, child_die, type, cu);
3095
else if (child_die->tag == DW_TAG_inheritance)
3097
/* C++ base class field. */
3098
dwarf2_add_field (&fi, child_die, cu);
3100
child_die = sibling_die (child_die);
3103
/* Attach fields and member functions to the type. */
3105
dwarf2_attach_fields_to_type (&fi, type, cu);
3108
dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3110
/* Get the type which refers to the base class (possibly this
3111
class itself) which contains the vtable pointer for the current
3112
class from the DW_AT_containing_type attribute. */
3114
if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3116
struct type *t = die_containing_type (die, cu);
3118
TYPE_VPTR_BASETYPE (type) = t;
3121
static const char vptr_name[] =
3122
{'_', 'v', 'p', 't', 'r', '\0'};
3125
/* Our own class provides vtbl ptr. */
3126
for (i = TYPE_NFIELDS (t) - 1;
3127
i >= TYPE_N_BASECLASSES (t);
3130
char *fieldname = TYPE_FIELD_NAME (t, i);
3132
if ((strncmp (fieldname, vptr_name,
3133
strlen (vptr_name) - 1)
3135
&& is_cplus_marker (fieldname[strlen (vptr_name)]))
3137
TYPE_VPTR_FIELDNO (type) = i;
3142
/* Complain if virtual function table field not found. */
3143
if (i < TYPE_N_BASECLASSES (t))
3144
complaint (&symfile_complaints,
3145
"virtual function table pointer not found when defining class '%s'",
3146
TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3151
TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3156
do_cleanups (back_to);
3160
/* No children, must be stub. */
3161
TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3164
processing_current_prefix = previous_prefix;
3165
if (back_to != NULL)
3166
do_cleanups (back_to);
3170
process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3172
struct objfile *objfile = cu->objfile;
3173
const char *previous_prefix = processing_current_prefix;
3174
struct die_info *child_die = die->child;
3176
if (TYPE_TAG_NAME (die->type) != NULL)
3177
processing_current_prefix = TYPE_TAG_NAME (die->type);
3179
/* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3180
snapshots) has been known to create a die giving a declaration
3181
for a class that has, as a child, a die giving a definition for a
3182
nested class. So we have to process our children even if the
3183
current die is a declaration. Normally, of course, a declaration
3184
won't have any children at all. */
3186
while (child_die != NULL && child_die->tag)
3188
if (child_die->tag == DW_TAG_member
3189
|| child_die->tag == DW_TAG_variable
3190
|| child_die->tag == DW_TAG_inheritance)
3195
process_die (child_die, cu);
3197
child_die = sibling_die (child_die);
3200
if (die->child != NULL && ! die_is_declaration (die, cu))
3201
new_symbol (die, die->type, cu);
3203
processing_current_prefix = previous_prefix;
3206
/* Given a DW_AT_enumeration_type die, set its type. We do not
3207
complete the type's fields yet, or create any symbols. */
3210
read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
3212
struct objfile *objfile = cu->objfile;
3214
struct attribute *attr;
3219
type = alloc_type (objfile);
3221
TYPE_CODE (type) = TYPE_CODE_ENUM;
3222
attr = dwarf2_attr (die, DW_AT_name, cu);
3223
if (attr && DW_STRING (attr))
3225
const char *name = DW_STRING (attr);
3227
if (processing_has_namespace_info)
3229
TYPE_TAG_NAME (type) = obconcat (&objfile->objfile_obstack,
3230
processing_current_prefix,
3231
processing_current_prefix[0] == '\0'
3237
TYPE_TAG_NAME (type) = obsavestring (name, strlen (name),
3238
&objfile->objfile_obstack);
3242
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3245
TYPE_LENGTH (type) = DW_UNSND (attr);
3249
TYPE_LENGTH (type) = 0;
3255
/* Determine the name of the type represented by DIE, which should be
3256
a named C++ compound type. Return the name in question; the caller
3257
is responsible for xfree()'ing it. */
3260
determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
3262
struct cleanup *back_to = NULL;
3263
struct die_info *spec_die = die_specification (die, cu);
3264
char *new_prefix = NULL;
3266
/* If this is the definition of a class that is declared by another
3267
die, then processing_current_prefix may not be accurate; see
3268
read_func_scope for a similar example. */
3269
if (spec_die != NULL)
3271
char *specification_prefix = determine_prefix (spec_die, cu);
3272
processing_current_prefix = specification_prefix;
3273
back_to = make_cleanup (xfree, specification_prefix);
3276
/* If we don't have namespace debug info, guess the name by trying
3277
to demangle the names of members, just like we did in
3278
add_partial_structure. */
3279
if (!processing_has_namespace_info)
3281
struct die_info *child;
3283
for (child = die->child;
3284
child != NULL && child->tag != 0;
3285
child = sibling_die (child))
3287
if (child->tag == DW_TAG_subprogram)
3289
new_prefix = class_name_from_physname (dwarf2_linkage_name
3292
if (new_prefix != NULL)
3298
if (new_prefix == NULL)
3300
const char *name = dwarf2_name (die, cu);
3301
new_prefix = typename_concat (processing_current_prefix,
3302
name ? name : "<<anonymous>>");
3305
if (back_to != NULL)
3306
do_cleanups (back_to);
3311
/* Given a pointer to a die which begins an enumeration, process all
3312
the dies that define the members of the enumeration, and create the
3313
symbol for the enumeration type.
3315
NOTE: We reverse the order of the element list. */
3318
process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
3320
struct objfile *objfile = cu->objfile;
3321
struct die_info *child_die;
3322
struct field *fields;
3323
struct attribute *attr;
3326
int unsigned_enum = 1;
3330
if (die->child != NULL)
3332
child_die = die->child;
3333
while (child_die && child_die->tag)
3335
if (child_die->tag != DW_TAG_enumerator)
3337
process_die (child_die, cu);
3341
attr = dwarf2_attr (child_die, DW_AT_name, cu);
3344
sym = new_symbol (child_die, die->type, cu);
3345
if (SYMBOL_VALUE (sym) < 0)
3348
if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
3350
fields = (struct field *)
3352
(num_fields + DW_FIELD_ALLOC_CHUNK)
3353
* sizeof (struct field));
3356
FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
3357
FIELD_TYPE (fields[num_fields]) = NULL;
3358
FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
3359
FIELD_BITSIZE (fields[num_fields]) = 0;
3360
FIELD_STATIC_KIND (fields[num_fields]) = 0;
3366
child_die = sibling_die (child_die);
3371
TYPE_NFIELDS (die->type) = num_fields;
3372
TYPE_FIELDS (die->type) = (struct field *)
3373
TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
3374
memcpy (TYPE_FIELDS (die->type), fields,
3375
sizeof (struct field) * num_fields);
3379
TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
3382
new_symbol (die, die->type, cu);
3385
/* Extract all information from a DW_TAG_array_type DIE and put it in
3386
the DIE's type field. For now, this only handles one dimensional
3390
read_array_type (struct die_info *die, struct dwarf2_cu *cu)
3392
struct objfile *objfile = cu->objfile;
3393
struct die_info *child_die;
3394
struct type *type = NULL;
3395
struct type *element_type, *range_type, *index_type;
3396
struct type **range_types = NULL;
3397
struct attribute *attr;
3399
struct cleanup *back_to;
3401
/* Return if we've already decoded this type. */
3407
element_type = die_type (die, cu);
3409
/* Irix 6.2 native cc creates array types without children for
3410
arrays with unspecified length. */
3411
if (die->child == NULL)
3413
index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
3414
range_type = create_range_type (NULL, index_type, 0, -1);
3415
die->type = create_array_type (NULL, element_type, range_type);
3419
back_to = make_cleanup (null_cleanup, NULL);
3420
child_die = die->child;
3421
while (child_die && child_die->tag)
3423
if (child_die->tag == DW_TAG_subrange_type)
3425
read_subrange_type (child_die, cu);
3427
if (child_die->type != NULL)
3429
/* The range type was succesfully read. Save it for
3430
the array type creation. */
3431
if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
3433
range_types = (struct type **)
3434
xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
3435
* sizeof (struct type *));
3437
make_cleanup (free_current_contents, &range_types);
3439
range_types[ndim++] = child_die->type;
3442
child_die = sibling_die (child_die);
3445
/* Dwarf2 dimensions are output from left to right, create the
3446
necessary array types in backwards order. */
3447
type = element_type;
3449
type = create_array_type (NULL, type, range_types[ndim]);
3451
/* Understand Dwarf2 support for vector types (like they occur on
3452
the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3453
array type. This is not part of the Dwarf2/3 standard yet, but a
3454
custom vendor extension. The main difference between a regular
3455
array and the vector variant is that vectors are passed by value
3457
attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
3459
TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
3461
do_cleanups (back_to);
3463
/* Install the type in the die. */
3467
/* First cut: install each common block member as a global variable. */
3470
read_common_block (struct die_info *die, struct dwarf2_cu *cu)
3472
struct die_info *child_die;
3473
struct attribute *attr;
3475
CORE_ADDR base = (CORE_ADDR) 0;
3477
attr = dwarf2_attr (die, DW_AT_location, cu);
3480
/* Support the .debug_loc offsets */
3481
if (attr_form_is_block (attr))
3483
base = decode_locdesc (DW_BLOCK (attr), cu);
3485
else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3487
dwarf2_complex_location_expr_complaint ();
3491
dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3492
"common block member");
3495
if (die->child != NULL)
3497
child_die = die->child;
3498
while (child_die && child_die->tag)
3500
sym = new_symbol (child_die, NULL, cu);
3501
attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
3504
SYMBOL_VALUE_ADDRESS (sym) =
3505
base + decode_locdesc (DW_BLOCK (attr), cu);
3506
add_symbol_to_list (sym, &global_symbols);
3508
child_die = sibling_die (child_die);
3513
/* Read a C++ namespace. */
3516
read_namespace (struct die_info *die, struct dwarf2_cu *cu)
3518
struct objfile *objfile = cu->objfile;
3519
const char *previous_prefix = processing_current_prefix;
3522
struct die_info *current_die;
3524
name = namespace_name (die, &is_anonymous, cu);
3526
/* Now build the name of the current namespace. */
3528
if (previous_prefix[0] == '\0')
3530
processing_current_prefix = name;
3534
/* We need temp_name around because processing_current_prefix
3535
is a const char *. */
3536
char *temp_name = alloca (strlen (previous_prefix)
3537
+ 2 + strlen(name) + 1);
3538
strcpy (temp_name, previous_prefix);
3539
strcat (temp_name, "::");
3540
strcat (temp_name, name);
3542
processing_current_prefix = temp_name;
3545
/* Add a symbol associated to this if we haven't seen the namespace
3546
before. Also, add a using directive if it's an anonymous
3549
if (dwarf2_extension (die, cu) == NULL)
3553
/* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3554
this cast will hopefully become unnecessary. */
3555
type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
3556
(char *) processing_current_prefix,
3558
TYPE_TAG_NAME (type) = TYPE_NAME (type);
3560
new_symbol (die, type, cu);
3564
cp_add_using_directive (processing_current_prefix,
3565
strlen (previous_prefix),
3566
strlen (processing_current_prefix));
3569
if (die->child != NULL)
3571
struct die_info *child_die = die->child;
3573
while (child_die && child_die->tag)
3575
process_die (child_die, cu);
3576
child_die = sibling_die (child_die);
3580
processing_current_prefix = previous_prefix;
3583
/* Return the name of the namespace represented by DIE. Set
3584
*IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3588
namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
3590
struct die_info *current_die;
3591
const char *name = NULL;
3593
/* Loop through the extensions until we find a name. */
3595
for (current_die = die;
3596
current_die != NULL;
3597
current_die = dwarf2_extension (die, cu))
3599
name = dwarf2_name (current_die, cu);
3604
/* Is it an anonymous namespace? */
3606
*is_anonymous = (name == NULL);
3608
name = "(anonymous namespace)";
3613
/* Extract all information from a DW_TAG_pointer_type DIE and add to
3614
the user defined type vector. */
3617
read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
3619
struct comp_unit_head *cu_header = &cu->header;
3621
struct attribute *attr_byte_size;
3622
struct attribute *attr_address_class;
3623
int byte_size, addr_class;
3630
type = lookup_pointer_type (die_type (die, cu));
3632
attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
3634
byte_size = DW_UNSND (attr_byte_size);
3636
byte_size = cu_header->addr_size;
3638
attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
3639
if (attr_address_class)
3640
addr_class = DW_UNSND (attr_address_class);
3642
addr_class = DW_ADDR_none;
3644
/* If the pointer size or address class is different than the
3645
default, create a type variant marked as such and set the
3646
length accordingly. */
3647
if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
3649
if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3653
type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
3654
gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
3655
type = make_type_with_address_space (type, type_flags);
3657
else if (TYPE_LENGTH (type) != byte_size)
3659
complaint (&symfile_complaints, "invalid pointer size %d", byte_size);
3662
/* Should we also complain about unhandled address classes? */
3666
TYPE_LENGTH (type) = byte_size;
3670
/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3671
the user defined type vector. */
3674
read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
3676
struct objfile *objfile = cu->objfile;
3678
struct type *to_type;
3679
struct type *domain;
3686
type = alloc_type (objfile);
3687
to_type = die_type (die, cu);
3688
domain = die_containing_type (die, cu);
3689
smash_to_member_type (type, domain, to_type);
3694
/* Extract all information from a DW_TAG_reference_type DIE and add to
3695
the user defined type vector. */
3698
read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
3700
struct comp_unit_head *cu_header = &cu->header;
3702
struct attribute *attr;
3709
type = lookup_reference_type (die_type (die, cu));
3710
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3713
TYPE_LENGTH (type) = DW_UNSND (attr);
3717
TYPE_LENGTH (type) = cu_header->addr_size;
3723
read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
3725
struct type *base_type;
3732
base_type = die_type (die, cu);
3733
die->type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
3737
read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
3739
struct type *base_type;
3746
base_type = die_type (die, cu);
3747
die->type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
3750
/* Extract all information from a DW_TAG_string_type DIE and add to
3751
the user defined type vector. It isn't really a user defined type,
3752
but it behaves like one, with other DIE's using an AT_user_def_type
3753
attribute to reference it. */
3756
read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
3758
struct objfile *objfile = cu->objfile;
3759
struct type *type, *range_type, *index_type, *char_type;
3760
struct attribute *attr;
3761
unsigned int length;
3768
attr = dwarf2_attr (die, DW_AT_string_length, cu);
3771
length = DW_UNSND (attr);
3775
/* check for the DW_AT_byte_size attribute */
3776
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3779
length = DW_UNSND (attr);
3786
index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
3787
range_type = create_range_type (NULL, index_type, 1, length);
3788
if (cu->language == language_fortran)
3790
/* Need to create a unique string type for bounds
3792
type = create_string_type (0, range_type);
3796
char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
3797
type = create_string_type (char_type, range_type);
3802
/* Handle DIES due to C code like:
3806
int (*funcp)(int a, long l);
3810
('funcp' generates a DW_TAG_subroutine_type DIE)
3814
read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
3816
struct type *type; /* Type that this function returns */
3817
struct type *ftype; /* Function that returns above type */
3818
struct attribute *attr;
3820
/* Decode the type that this subroutine returns */
3825
type = die_type (die, cu);
3826
ftype = lookup_function_type (type);
3828
/* All functions in C++ have prototypes. */
3829
attr = dwarf2_attr (die, DW_AT_prototyped, cu);
3830
if ((attr && (DW_UNSND (attr) != 0))
3831
|| cu->language == language_cplus)
3832
TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
3834
if (die->child != NULL)
3836
struct die_info *child_die;
3840
/* Count the number of parameters.
3841
FIXME: GDB currently ignores vararg functions, but knows about
3842
vararg member functions. */
3843
child_die = die->child;
3844
while (child_die && child_die->tag)
3846
if (child_die->tag == DW_TAG_formal_parameter)
3848
else if (child_die->tag == DW_TAG_unspecified_parameters)
3849
TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
3850
child_die = sibling_die (child_die);
3853
/* Allocate storage for parameters and fill them in. */
3854
TYPE_NFIELDS (ftype) = nparams;
3855
TYPE_FIELDS (ftype) = (struct field *)
3856
TYPE_ALLOC (ftype, nparams * sizeof (struct field));
3858
child_die = die->child;
3859
while (child_die && child_die->tag)
3861
if (child_die->tag == DW_TAG_formal_parameter)
3863
/* Dwarf2 has no clean way to discern C++ static and non-static
3864
member functions. G++ helps GDB by marking the first
3865
parameter for non-static member functions (which is the
3866
this pointer) as artificial. We pass this information
3867
to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3868
attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
3870
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
3872
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
3873
TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
3876
child_die = sibling_die (child_die);
3884
read_typedef (struct die_info *die, struct dwarf2_cu *cu)
3886
struct objfile *objfile = cu->objfile;
3887
struct attribute *attr;
3892
attr = dwarf2_attr (die, DW_AT_name, cu);
3893
if (attr && DW_STRING (attr))
3895
name = DW_STRING (attr);
3897
die->type = init_type (TYPE_CODE_TYPEDEF, 0, TYPE_FLAG_TARGET_STUB, name, objfile);
3898
TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
3902
/* Find a representation of a given base type and install
3903
it in the TYPE field of the die. */
3906
read_base_type (struct die_info *die, struct dwarf2_cu *cu)
3908
struct objfile *objfile = cu->objfile;
3910
struct attribute *attr;
3911
int encoding = 0, size = 0;
3913
/* If we've already decoded this die, this is a no-op. */
3919
attr = dwarf2_attr (die, DW_AT_encoding, cu);
3922
encoding = DW_UNSND (attr);
3924
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3927
size = DW_UNSND (attr);
3929
attr = dwarf2_attr (die, DW_AT_name, cu);
3930
if (attr && DW_STRING (attr))
3932
enum type_code code = TYPE_CODE_INT;
3937
case DW_ATE_address:
3938
/* Turn DW_ATE_address into a void * pointer. */
3939
code = TYPE_CODE_PTR;
3940
type_flags |= TYPE_FLAG_UNSIGNED;
3942
case DW_ATE_boolean:
3943
code = TYPE_CODE_BOOL;
3944
type_flags |= TYPE_FLAG_UNSIGNED;
3946
case DW_ATE_complex_float:
3947
code = TYPE_CODE_COMPLEX;
3950
code = TYPE_CODE_FLT;
3953
case DW_ATE_signed_char:
3955
case DW_ATE_unsigned:
3956
case DW_ATE_unsigned_char:
3957
type_flags |= TYPE_FLAG_UNSIGNED;
3960
complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'",
3961
dwarf_type_encoding_name (encoding));
3964
type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
3965
if (encoding == DW_ATE_address)
3966
TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
3968
else if (encoding == DW_ATE_complex_float)
3971
TYPE_TARGET_TYPE (type)
3972
= dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
3973
else if (size == 16)
3974
TYPE_TARGET_TYPE (type)
3975
= dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
3977
TYPE_TARGET_TYPE (type)
3978
= dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
3983
type = dwarf_base_type (encoding, size, cu);
3988
/* Read the given DW_AT_subrange DIE. */
3991
read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
3993
struct type *base_type;
3994
struct type *range_type;
3995
struct attribute *attr;
3999
/* If we have already decoded this die, then nothing more to do. */
4003
base_type = die_type (die, cu);
4004
if (base_type == NULL)
4006
complaint (&symfile_complaints,
4007
"DW_AT_type missing from DW_TAG_subrange_type");
4011
if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4012
base_type = alloc_type (NULL);
4014
if (cu->language == language_fortran)
4016
/* FORTRAN implies a lower bound of 1, if not given. */
4020
attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4022
low = dwarf2_get_attr_constant_value (attr, 0);
4024
attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4027
if (attr->form == DW_FORM_block1)
4029
/* GCC encodes arrays with unspecified or dynamic length
4030
with a DW_FORM_block1 attribute.
4031
FIXME: GDB does not yet know how to handle dynamic
4032
arrays properly, treat them as arrays with unspecified
4035
FIXME: jimb/2003-09-22: GDB does not really know
4036
how to handle arrays of unspecified length
4037
either; we just represent them as zero-length
4038
arrays. Choose an appropriate upper bound given
4039
the lower bound we've computed above. */
4043
high = dwarf2_get_attr_constant_value (attr, 1);
4046
range_type = create_range_type (NULL, base_type, low, high);
4048
attr = dwarf2_attr (die, DW_AT_name, cu);
4049
if (attr && DW_STRING (attr))
4050
TYPE_NAME (range_type) = DW_STRING (attr);
4052
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4054
TYPE_LENGTH (range_type) = DW_UNSND (attr);
4056
die->type = range_type;
4060
/* Read a whole compilation unit into a linked list of dies. */
4062
static struct die_info *
4063
read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4065
/* Reset die reference table; we are
4066
building new ones now. */
4067
dwarf2_empty_hash_tables ();
4069
return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4072
/* Read a single die and all its descendents. Set the die's sibling
4073
field to NULL; set other fields in the die correctly, and set all
4074
of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4075
location of the info_ptr after reading all of those dies. PARENT
4076
is the parent of the die in question. */
4078
static struct die_info *
4079
read_die_and_children (char *info_ptr, bfd *abfd,
4080
struct dwarf2_cu *cu,
4081
char **new_info_ptr,
4082
struct die_info *parent)
4084
struct die_info *die;
4088
cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4089
store_in_ref_table (die->offset, die);
4093
die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4099
*new_info_ptr = cur_ptr;
4102
die->sibling = NULL;
4103
die->parent = parent;
4107
/* Read a die, all of its descendents, and all of its siblings; set
4108
all of the fields of all of the dies correctly. Arguments are as
4109
in read_die_and_children. */
4111
static struct die_info *
4112
read_die_and_siblings (char *info_ptr, bfd *abfd,
4113
struct dwarf2_cu *cu,
4114
char **new_info_ptr,
4115
struct die_info *parent)
4117
struct die_info *first_die, *last_sibling;
4121
first_die = last_sibling = NULL;
4125
struct die_info *die
4126
= read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
4134
last_sibling->sibling = die;
4139
*new_info_ptr = cur_ptr;
4149
/* Free a linked list of dies. */
4152
free_die_list (struct die_info *dies)
4154
struct die_info *die, *next;
4159
if (die->child != NULL)
4160
free_die_list (die->child);
4161
next = die->sibling;
4169
do_free_die_list_cleanup (void *dies)
4171
free_die_list (dies);
4174
static struct cleanup *
4175
make_cleanup_free_die_list (struct die_info *dies)
4177
return make_cleanup (do_free_die_list_cleanup, dies);
4181
/* Read the contents of the section at OFFSET and of size SIZE from the
4182
object file specified by OBJFILE into the objfile_obstack and return it. */
4185
dwarf2_read_section (struct objfile *objfile, asection *sectp)
4187
bfd *abfd = objfile->obfd;
4189
bfd_size_type size = bfd_get_section_size_before_reloc (sectp);
4194
buf = (char *) obstack_alloc (&objfile->objfile_obstack, size);
4196
= (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf);
4200
if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
4201
|| bfd_bread (buf, size, abfd) != size)
4202
error ("Dwarf Error: Can't read DWARF data from '%s'",
4203
bfd_get_filename (abfd));
4208
/* In DWARF version 2, the description of the debugging information is
4209
stored in a separate .debug_abbrev section. Before we read any
4210
dies from a section we read in all abbreviations and install them
4214
dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
4216
struct comp_unit_head *cu_header = &cu->header;
4218
struct abbrev_info *cur_abbrev;
4219
unsigned int abbrev_number, bytes_read, abbrev_name;
4220
unsigned int abbrev_form, hash_number;
4222
/* Initialize dwarf2 abbrevs */
4223
memset (cu_header->dwarf2_abbrevs, 0,
4224
ABBREV_HASH_SIZE*sizeof (struct abbrev_info *));
4226
abbrev_ptr = dwarf_abbrev_buffer + cu_header->abbrev_offset;
4227
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4228
abbrev_ptr += bytes_read;
4230
/* loop until we reach an abbrev number of 0 */
4231
while (abbrev_number)
4233
cur_abbrev = dwarf_alloc_abbrev ();
4235
/* read in abbrev header */
4236
cur_abbrev->number = abbrev_number;
4237
cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4238
abbrev_ptr += bytes_read;
4239
cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
4242
/* now read in declarations */
4243
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4244
abbrev_ptr += bytes_read;
4245
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4246
abbrev_ptr += bytes_read;
4249
if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
4251
cur_abbrev->attrs = (struct attr_abbrev *)
4252
xrealloc (cur_abbrev->attrs,
4253
(cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
4254
* sizeof (struct attr_abbrev));
4256
cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
4257
cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
4258
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4259
abbrev_ptr += bytes_read;
4260
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4261
abbrev_ptr += bytes_read;
4264
hash_number = abbrev_number % ABBREV_HASH_SIZE;
4265
cur_abbrev->next = cu_header->dwarf2_abbrevs[hash_number];
4266
cu_header->dwarf2_abbrevs[hash_number] = cur_abbrev;
4268
/* Get next abbreviation.
4269
Under Irix6 the abbreviations for a compilation unit are not
4270
always properly terminated with an abbrev number of 0.
4271
Exit loop if we encounter an abbreviation which we have
4272
already read (which means we are about to read the abbreviations
4273
for the next compile unit) or if the end of the abbreviation
4274
table is reached. */
4275
if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
4276
>= dwarf_abbrev_size)
4278
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4279
abbrev_ptr += bytes_read;
4280
if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
4285
/* Empty the abbrev table for a new compilation unit. */
4288
dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table)
4291
struct abbrev_info *abbrev, *next;
4292
struct abbrev_info **abbrevs;
4294
abbrevs = (struct abbrev_info **)ptr_to_abbrevs_table;
4296
for (i = 0; i < ABBREV_HASH_SIZE; ++i)
4299
abbrev = abbrevs[i];
4302
next = abbrev->next;
4303
xfree (abbrev->attrs);
4311
/* Lookup an abbrev_info structure in the abbrev hash table. */
4313
static struct abbrev_info *
4314
dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
4316
struct comp_unit_head *cu_header = &cu->header;
4317
unsigned int hash_number;
4318
struct abbrev_info *abbrev;
4320
hash_number = number % ABBREV_HASH_SIZE;
4321
abbrev = cu_header->dwarf2_abbrevs[hash_number];
4325
if (abbrev->number == number)
4328
abbrev = abbrev->next;
4333
/* Read a minimal amount of information into the minimal die structure. */
4336
read_partial_die (struct partial_die_info *part_die, bfd *abfd,
4337
char *info_ptr, struct dwarf2_cu *cu)
4339
unsigned int abbrev_number, bytes_read, i;
4340
struct abbrev_info *abbrev;
4341
struct attribute attr;
4342
struct attribute spec_attr;
4343
int found_spec_attr = 0;
4344
int has_low_pc_attr = 0;
4345
int has_high_pc_attr = 0;
4347
*part_die = zeroed_partial_die;
4348
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4349
info_ptr += bytes_read;
4353
abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4356
error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number,
4357
bfd_get_filename (abfd));
4359
part_die->offset = info_ptr - dwarf_info_buffer;
4360
part_die->tag = abbrev->tag;
4361
part_die->has_children = abbrev->has_children;
4362
part_die->abbrev = abbrev_number;
4364
for (i = 0; i < abbrev->num_attrs; ++i)
4366
info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
4368
/* Store the data if it is of an attribute we want to keep in a
4369
partial symbol table. */
4374
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4375
if (part_die->name == NULL)
4376
part_die->name = DW_STRING (&attr);
4378
case DW_AT_MIPS_linkage_name:
4379
part_die->name = DW_STRING (&attr);
4382
has_low_pc_attr = 1;
4383
part_die->lowpc = DW_ADDR (&attr);
4386
has_high_pc_attr = 1;
4387
part_die->highpc = DW_ADDR (&attr);
4389
case DW_AT_location:
4390
/* Support the .debug_loc offsets */
4391
if (attr_form_is_block (&attr))
4393
part_die->locdesc = DW_BLOCK (&attr);
4395
else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
4397
dwarf2_complex_location_expr_complaint ();
4401
dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4402
"partial symbol information");
4405
case DW_AT_language:
4406
part_die->language = DW_UNSND (&attr);
4408
case DW_AT_external:
4409
part_die->is_external = DW_UNSND (&attr);
4411
case DW_AT_declaration:
4412
part_die->is_declaration = DW_UNSND (&attr);
4415
part_die->has_type = 1;
4417
case DW_AT_abstract_origin:
4418
case DW_AT_specification:
4419
found_spec_attr = 1;
4423
/* Ignore absolute siblings, they might point outside of
4424
the current compile unit. */
4425
if (attr.form == DW_FORM_ref_addr)
4426
complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
4429
dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr, cu);
4436
/* If we found a reference attribute and the die has no name, try
4437
to find a name in the referred to die. */
4439
if (found_spec_attr && part_die->name == NULL)
4441
struct partial_die_info spec_die;
4444
spec_ptr = dwarf_info_buffer
4445
+ dwarf2_get_ref_die_offset (&spec_attr, cu);
4446
read_partial_die (&spec_die, abfd, spec_ptr, cu);
4449
part_die->name = spec_die.name;
4451
/* Copy DW_AT_external attribute if it is set. */
4452
if (spec_die.is_external)
4453
part_die->is_external = spec_die.is_external;
4457
/* When using the GNU linker, .gnu.linkonce. sections are used to
4458
eliminate duplicate copies of functions and vtables and such.
4459
The linker will arbitrarily choose one and discard the others.
4460
The AT_*_pc values for such functions refer to local labels in
4461
these sections. If the section from that file was discarded, the
4462
labels are not in the output, so the relocs get a value of 0.
4463
If this is a discarded function, mark the pc bounds as invalid,
4464
so that GDB will ignore it. */
4465
if (has_low_pc_attr && has_high_pc_attr
4466
&& part_die->lowpc < part_die->highpc
4467
&& (part_die->lowpc != 0
4468
|| (bfd_get_file_flags (abfd) & HAS_RELOC)))
4469
part_die->has_pc_info = 1;
4473
/* Read the die from the .debug_info section buffer. Set DIEP to
4474
point to a newly allocated die with its information, except for its
4475
child, sibling, and parent fields. Set HAS_CHILDREN to tell
4476
whether the die has children or not. */
4479
read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr,
4480
struct dwarf2_cu *cu, int *has_children)
4482
unsigned int abbrev_number, bytes_read, i, offset;
4483
struct abbrev_info *abbrev;
4484
struct die_info *die;
4486
offset = info_ptr - dwarf_info_buffer;
4487
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4488
info_ptr += bytes_read;
4491
die = dwarf_alloc_die ();
4493
die->abbrev = abbrev_number;
4500
abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4503
error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4505
bfd_get_filename (abfd));
4507
die = dwarf_alloc_die ();
4508
die->offset = offset;
4509
die->tag = abbrev->tag;
4510
die->abbrev = abbrev_number;
4513
die->num_attrs = abbrev->num_attrs;
4514
die->attrs = (struct attribute *)
4515
xmalloc (die->num_attrs * sizeof (struct attribute));
4517
for (i = 0; i < abbrev->num_attrs; ++i)
4519
info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
4520
abfd, info_ptr, cu);
4524
*has_children = abbrev->has_children;
4528
/* Read an attribute value described by an attribute form. */
4531
read_attribute_value (struct attribute *attr, unsigned form,
4532
bfd *abfd, char *info_ptr,
4533
struct dwarf2_cu *cu)
4535
struct comp_unit_head *cu_header = &cu->header;
4536
unsigned int bytes_read;
4537
struct dwarf_block *blk;
4543
case DW_FORM_ref_addr:
4544
DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
4545
info_ptr += bytes_read;
4547
case DW_FORM_block2:
4548
blk = dwarf_alloc_block ();
4549
blk->size = read_2_bytes (abfd, info_ptr);
4551
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4552
info_ptr += blk->size;
4553
DW_BLOCK (attr) = blk;
4555
case DW_FORM_block4:
4556
blk = dwarf_alloc_block ();
4557
blk->size = read_4_bytes (abfd, info_ptr);
4559
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4560
info_ptr += blk->size;
4561
DW_BLOCK (attr) = blk;
4564
DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4568
DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4572
DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4575
case DW_FORM_string:
4576
DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
4577
info_ptr += bytes_read;
4580
DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
4582
info_ptr += bytes_read;
4585
blk = dwarf_alloc_block ();
4586
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4587
info_ptr += bytes_read;
4588
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4589
info_ptr += blk->size;
4590
DW_BLOCK (attr) = blk;
4592
case DW_FORM_block1:
4593
blk = dwarf_alloc_block ();
4594
blk->size = read_1_byte (abfd, info_ptr);
4596
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4597
info_ptr += blk->size;
4598
DW_BLOCK (attr) = blk;
4601
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4605
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4609
DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
4610
info_ptr += bytes_read;
4613
DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4614
info_ptr += bytes_read;
4617
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4621
DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4625
DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4629
DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4632
case DW_FORM_ref_udata:
4633
DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4634
info_ptr += bytes_read;
4636
case DW_FORM_indirect:
4637
form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4638
info_ptr += bytes_read;
4639
info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
4642
error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4643
dwarf_form_name (form),
4644
bfd_get_filename (abfd));
4649
/* Read an attribute described by an abbreviated attribute. */
4652
read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
4653
bfd *abfd, char *info_ptr, struct dwarf2_cu *cu)
4655
attr->name = abbrev->name;
4656
return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
4659
/* read dwarf information from a buffer */
4662
read_1_byte (bfd *abfd, char *buf)
4664
return bfd_get_8 (abfd, (bfd_byte *) buf);
4668
read_1_signed_byte (bfd *abfd, char *buf)
4670
return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
4674
read_2_bytes (bfd *abfd, char *buf)
4676
return bfd_get_16 (abfd, (bfd_byte *) buf);
4680
read_2_signed_bytes (bfd *abfd, char *buf)
4682
return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4686
read_4_bytes (bfd *abfd, char *buf)
4688
return bfd_get_32 (abfd, (bfd_byte *) buf);
4692
read_4_signed_bytes (bfd *abfd, char *buf)
4694
return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4697
static unsigned long
4698
read_8_bytes (bfd *abfd, char *buf)
4700
return bfd_get_64 (abfd, (bfd_byte *) buf);
4704
read_address (bfd *abfd, char *buf, struct dwarf2_cu *cu, int *bytes_read)
4706
struct comp_unit_head *cu_header = &cu->header;
4707
CORE_ADDR retval = 0;
4709
if (cu_header->signed_addr_p)
4711
switch (cu_header->addr_size)
4714
retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4717
retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4720
retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf);
4723
internal_error (__FILE__, __LINE__,
4724
"read_address: bad switch, signed [in module %s]",
4725
bfd_get_filename (abfd));
4730
switch (cu_header->addr_size)
4733
retval = bfd_get_16 (abfd, (bfd_byte *) buf);
4736
retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4739
retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4742
internal_error (__FILE__, __LINE__,
4743
"read_address: bad switch, unsigned [in module %s]",
4744
bfd_get_filename (abfd));
4748
*bytes_read = cu_header->addr_size;
4752
/* Read the initial length from a section. The (draft) DWARF 3
4753
specification allows the initial length to take up either 4 bytes
4754
or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4755
bytes describe the length and all offsets will be 8 bytes in length
4758
An older, non-standard 64-bit format is also handled by this
4759
function. The older format in question stores the initial length
4760
as an 8-byte quantity without an escape value. Lengths greater
4761
than 2^32 aren't very common which means that the initial 4 bytes
4762
is almost always zero. Since a length value of zero doesn't make
4763
sense for the 32-bit format, this initial zero can be considered to
4764
be an escape value which indicates the presence of the older 64-bit
4765
format. As written, the code can't detect (old format) lengths
4766
greater than 4GB. If it becomes necessary to handle lengths somewhat
4767
larger than 4GB, we could allow other small values (such as the
4768
non-sensical values of 1, 2, and 3) to also be used as escape values
4769
indicating the presence of the old format.
4771
The value returned via bytes_read should be used to increment
4772
the relevant pointer after calling read_initial_length().
4774
As a side effect, this function sets the fields initial_length_size
4775
and offset_size in cu_header to the values appropriate for the
4776
length field. (The format of the initial length field determines
4777
the width of file offsets to be fetched later with fetch_offset().)
4779
[ Note: read_initial_length() and read_offset() are based on the
4780
document entitled "DWARF Debugging Information Format", revision
4781
3, draft 8, dated November 19, 2001. This document was obtained
4784
http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4786
This document is only a draft and is subject to change. (So beware.)
4788
Details regarding the older, non-standard 64-bit format were
4789
determined empirically by examining 64-bit ELF files produced
4790
by the SGI toolchain on an IRIX 6.5 machine.
4792
- Kevin, July 16, 2002
4796
read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header,
4801
retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4803
if (retval == 0xffffffff)
4805
retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
4807
if (cu_header != NULL)
4809
cu_header->initial_length_size = 12;
4810
cu_header->offset_size = 8;
4813
else if (retval == 0)
4815
/* Handle (non-standard) 64-bit DWARF2 formats such as that used
4817
retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4819
if (cu_header != NULL)
4821
cu_header->initial_length_size = 8;
4822
cu_header->offset_size = 8;
4828
if (cu_header != NULL)
4830
cu_header->initial_length_size = 4;
4831
cu_header->offset_size = 4;
4838
/* Read an offset from the data stream. The size of the offset is
4839
given by cu_header->offset_size. */
4842
read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
4847
switch (cu_header->offset_size)
4850
retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4854
retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4858
internal_error (__FILE__, __LINE__,
4859
"read_offset: bad switch [in module %s]",
4860
bfd_get_filename (abfd));
4867
read_n_bytes (bfd *abfd, char *buf, unsigned int size)
4869
/* If the size of a host char is 8 bits, we can return a pointer
4870
to the buffer, otherwise we have to copy the data to a buffer
4871
allocated on the temporary obstack. */
4872
gdb_assert (HOST_CHAR_BIT == 8);
4877
read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4879
/* If the size of a host char is 8 bits, we can return a pointer
4880
to the string, otherwise we have to copy the string to a buffer
4881
allocated on the temporary obstack. */
4882
gdb_assert (HOST_CHAR_BIT == 8);
4885
*bytes_read_ptr = 1;
4888
*bytes_read_ptr = strlen (buf) + 1;
4893
read_indirect_string (bfd *abfd, char *buf,
4894
const struct comp_unit_head *cu_header,
4895
unsigned int *bytes_read_ptr)
4897
LONGEST str_offset = read_offset (abfd, buf, cu_header,
4898
(int *) bytes_read_ptr);
4900
if (dwarf_str_buffer == NULL)
4902
error ("DW_FORM_strp used without .debug_str section [in module %s]",
4903
bfd_get_filename (abfd));
4906
if (str_offset >= dwarf_str_size)
4908
error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4909
bfd_get_filename (abfd));
4912
gdb_assert (HOST_CHAR_BIT == 8);
4913
if (dwarf_str_buffer[str_offset] == '\0')
4915
return dwarf_str_buffer + str_offset;
4918
static unsigned long
4919
read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4921
unsigned long result;
4922
unsigned int num_read;
4932
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4935
result |= ((unsigned long)(byte & 127) << shift);
4936
if ((byte & 128) == 0)
4942
*bytes_read_ptr = num_read;
4947
read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4950
int i, shift, size, num_read;
4960
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4963
result |= ((long)(byte & 127) << shift);
4965
if ((byte & 128) == 0)
4970
if ((shift < size) && (byte & 0x40))
4972
result |= -(1 << shift);
4974
*bytes_read_ptr = num_read;
4979
set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
4985
cu->language = language_c;
4987
case DW_LANG_C_plus_plus:
4988
cu->language = language_cplus;
4990
case DW_LANG_Fortran77:
4991
case DW_LANG_Fortran90:
4992
case DW_LANG_Fortran95:
4993
cu->language = language_fortran;
4995
case DW_LANG_Mips_Assembler:
4996
cu->language = language_asm;
4999
cu->language = language_java;
5003
case DW_LANG_Cobol74:
5004
case DW_LANG_Cobol85:
5005
case DW_LANG_Pascal83:
5006
case DW_LANG_Modula2:
5008
cu->language = language_minimal;
5011
cu->language_defn = language_def (cu->language);
5014
/* Return the named attribute or NULL if not there. */
5016
static struct attribute *
5017
dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
5020
struct attribute *spec = NULL;
5022
for (i = 0; i < die->num_attrs; ++i)
5024
if (die->attrs[i].name == name)
5026
return &die->attrs[i];
5028
if (die->attrs[i].name == DW_AT_specification
5029
|| die->attrs[i].name == DW_AT_abstract_origin)
5030
spec = &die->attrs[i];
5034
struct die_info *ref_die =
5035
follow_die_ref (dwarf2_get_ref_die_offset (spec, cu));
5038
return dwarf2_attr (ref_die, name, cu);
5045
die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
5047
return (dwarf2_attr (die, DW_AT_declaration, cu)
5048
&& ! dwarf2_attr (die, DW_AT_specification, cu));
5051
/* Return the die giving the specification for DIE, if there is
5054
static struct die_info *
5055
die_specification (struct die_info *die, struct dwarf2_cu *cu)
5057
struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
5059
if (spec_attr == NULL)
5062
return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr, cu));
5065
/* Free the line_header structure *LH, and any arrays and strings it
5068
free_line_header (struct line_header *lh)
5070
if (lh->standard_opcode_lengths)
5071
xfree (lh->standard_opcode_lengths);
5073
/* Remember that all the lh->file_names[i].name pointers are
5074
pointers into debug_line_buffer, and don't need to be freed. */
5076
xfree (lh->file_names);
5078
/* Similarly for the include directory names. */
5079
if (lh->include_dirs)
5080
xfree (lh->include_dirs);
5086
/* Add an entry to LH's include directory table. */
5088
add_include_dir (struct line_header *lh, char *include_dir)
5090
/* Grow the array if necessary. */
5091
if (lh->include_dirs_size == 0)
5093
lh->include_dirs_size = 1; /* for testing */
5094
lh->include_dirs = xmalloc (lh->include_dirs_size
5095
* sizeof (*lh->include_dirs));
5097
else if (lh->num_include_dirs >= lh->include_dirs_size)
5099
lh->include_dirs_size *= 2;
5100
lh->include_dirs = xrealloc (lh->include_dirs,
5101
(lh->include_dirs_size
5102
* sizeof (*lh->include_dirs)));
5105
lh->include_dirs[lh->num_include_dirs++] = include_dir;
5109
/* Add an entry to LH's file name table. */
5111
add_file_name (struct line_header *lh,
5113
unsigned int dir_index,
5114
unsigned int mod_time,
5115
unsigned int length)
5117
struct file_entry *fe;
5119
/* Grow the array if necessary. */
5120
if (lh->file_names_size == 0)
5122
lh->file_names_size = 1; /* for testing */
5123
lh->file_names = xmalloc (lh->file_names_size
5124
* sizeof (*lh->file_names));
5126
else if (lh->num_file_names >= lh->file_names_size)
5128
lh->file_names_size *= 2;
5129
lh->file_names = xrealloc (lh->file_names,
5130
(lh->file_names_size
5131
* sizeof (*lh->file_names)));
5134
fe = &lh->file_names[lh->num_file_names++];
5136
fe->dir_index = dir_index;
5137
fe->mod_time = mod_time;
5138
fe->length = length;
5142
/* Read the statement program header starting at OFFSET in
5143
dwarf_line_buffer, according to the endianness of ABFD. Return a
5144
pointer to a struct line_header, allocated using xmalloc.
5146
NOTE: the strings in the include directory and file name tables of
5147
the returned object point into debug_line_buffer, and must not be
5149
static struct line_header *
5150
dwarf_decode_line_header (unsigned int offset, bfd *abfd,
5151
struct dwarf2_cu *cu)
5153
struct cleanup *back_to;
5154
struct line_header *lh;
5158
char *cur_dir, *cur_file;
5160
if (dwarf_line_buffer == NULL)
5162
complaint (&symfile_complaints, "missing .debug_line section");
5166
/* Make sure that at least there's room for the total_length field. That
5167
could be 12 bytes long, but we're just going to fudge that. */
5168
if (offset + 4 >= dwarf_line_size)
5170
dwarf2_statement_list_fits_in_line_number_section_complaint ();
5174
lh = xmalloc (sizeof (*lh));
5175
memset (lh, 0, sizeof (*lh));
5176
back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
5179
line_ptr = dwarf_line_buffer + offset;
5181
/* read in the header */
5182
lh->total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read);
5183
line_ptr += bytes_read;
5184
if (line_ptr + lh->total_length > dwarf_line_buffer + dwarf_line_size)
5186
dwarf2_statement_list_fits_in_line_number_section_complaint ();
5189
lh->statement_program_end = line_ptr + lh->total_length;
5190
lh->version = read_2_bytes (abfd, line_ptr);
5192
lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
5193
line_ptr += bytes_read;
5194
lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
5196
lh->default_is_stmt = read_1_byte (abfd, line_ptr);
5198
lh->line_base = read_1_signed_byte (abfd, line_ptr);
5200
lh->line_range = read_1_byte (abfd, line_ptr);
5202
lh->opcode_base = read_1_byte (abfd, line_ptr);
5204
lh->standard_opcode_lengths
5205
= (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char));
5207
lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
5208
for (i = 1; i < lh->opcode_base; ++i)
5210
lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
5214
/* Read directory table */
5215
while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5217
line_ptr += bytes_read;
5218
add_include_dir (lh, cur_dir);
5220
line_ptr += bytes_read;
5222
/* Read file name table */
5223
while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5225
unsigned int dir_index, mod_time, length;
5227
line_ptr += bytes_read;
5228
dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5229
line_ptr += bytes_read;
5230
mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5231
line_ptr += bytes_read;
5232
length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5233
line_ptr += bytes_read;
5235
add_file_name (lh, cur_file, dir_index, mod_time, length);
5237
line_ptr += bytes_read;
5238
lh->statement_program_start = line_ptr;
5240
if (line_ptr > dwarf_line_buffer + dwarf_line_size)
5241
complaint (&symfile_complaints,
5242
"line number info header doesn't fit in `.debug_line' section");
5244
discard_cleanups (back_to);
5248
/* This function exists to work around a bug in certain compilers
5249
(particularly GCC 2.95), in which the first line number marker of a
5250
function does not show up until after the prologue, right before
5251
the second line number marker. This function shifts ADDRESS down
5252
to the beginning of the function if necessary, and is called on
5253
addresses passed to record_line. */
5256
check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
5258
struct function_range *fn;
5260
/* Find the function_range containing address. */
5265
cu->cached_fn = cu->first_fn;
5269
if (fn->lowpc <= address && fn->highpc > address)
5275
while (fn && fn != cu->cached_fn)
5276
if (fn->lowpc <= address && fn->highpc > address)
5286
if (address != fn->lowpc)
5287
complaint (&symfile_complaints,
5288
"misplaced first line number at 0x%lx for '%s'",
5289
(unsigned long) address, fn->name);
5294
/* Decode the line number information for the compilation unit whose
5295
line number info is at OFFSET in the .debug_line section.
5296
The compilation directory of the file is passed in COMP_DIR. */
5299
dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
5300
struct dwarf2_cu *cu)
5304
unsigned int bytes_read;
5305
unsigned char op_code, extended_op, adj_opcode;
5307
struct objfile *objfile = cu->objfile;
5309
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5311
line_ptr = lh->statement_program_start;
5312
line_end = lh->statement_program_end;
5314
/* Read the statement sequences until there's nothing left. */
5315
while (line_ptr < line_end)
5317
/* state machine registers */
5318
CORE_ADDR address = 0;
5319
unsigned int file = 1;
5320
unsigned int line = 1;
5321
unsigned int column = 0;
5322
int is_stmt = lh->default_is_stmt;
5323
int basic_block = 0;
5324
int end_sequence = 0;
5326
/* Start a subfile for the current file of the state machine. */
5327
if (lh->num_file_names >= file)
5329
/* lh->include_dirs and lh->file_names are 0-based, but the
5330
directory and file name numbers in the statement program
5332
struct file_entry *fe = &lh->file_names[file - 1];
5335
dir = lh->include_dirs[fe->dir_index - 1];
5338
dwarf2_start_subfile (fe->name, dir);
5341
/* Decode the table. */
5342
while (!end_sequence)
5344
op_code = read_1_byte (abfd, line_ptr);
5347
if (op_code >= lh->opcode_base)
5348
{ /* Special operand. */
5349
adj_opcode = op_code - lh->opcode_base;
5350
address += (adj_opcode / lh->line_range)
5351
* lh->minimum_instruction_length;
5352
line += lh->line_base + (adj_opcode % lh->line_range);
5353
/* append row to matrix using current values */
5354
record_line (current_subfile, line,
5355
check_cu_functions (address, cu));
5358
else switch (op_code)
5360
case DW_LNS_extended_op:
5361
line_ptr += 1; /* ignore length */
5362
extended_op = read_1_byte (abfd, line_ptr);
5364
switch (extended_op)
5366
case DW_LNE_end_sequence:
5368
record_line (current_subfile, 0, address);
5370
case DW_LNE_set_address:
5371
address = read_address (abfd, line_ptr, cu, &bytes_read);
5372
line_ptr += bytes_read;
5373
address += baseaddr;
5375
case DW_LNE_define_file:
5378
unsigned int dir_index, mod_time, length;
5380
cur_file = read_string (abfd, line_ptr, &bytes_read);
5381
line_ptr += bytes_read;
5383
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5384
line_ptr += bytes_read;
5386
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5387
line_ptr += bytes_read;
5389
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5390
line_ptr += bytes_read;
5391
add_file_name (lh, cur_file, dir_index, mod_time, length);
5395
complaint (&symfile_complaints,
5396
"mangled .debug_line section");
5401
record_line (current_subfile, line,
5402
check_cu_functions (address, cu));
5405
case DW_LNS_advance_pc:
5406
address += lh->minimum_instruction_length
5407
* read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5408
line_ptr += bytes_read;
5410
case DW_LNS_advance_line:
5411
line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
5412
line_ptr += bytes_read;
5414
case DW_LNS_set_file:
5416
/* lh->include_dirs and lh->file_names are 0-based,
5417
but the directory and file name numbers in the
5418
statement program are 1-based. */
5419
struct file_entry *fe;
5421
file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5422
line_ptr += bytes_read;
5423
fe = &lh->file_names[file - 1];
5425
dir = lh->include_dirs[fe->dir_index - 1];
5428
dwarf2_start_subfile (fe->name, dir);
5431
case DW_LNS_set_column:
5432
column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5433
line_ptr += bytes_read;
5435
case DW_LNS_negate_stmt:
5436
is_stmt = (!is_stmt);
5438
case DW_LNS_set_basic_block:
5441
/* Add to the address register of the state machine the
5442
address increment value corresponding to special opcode
5443
255. Ie, this value is scaled by the minimum instruction
5444
length since special opcode 255 would have scaled the
5446
case DW_LNS_const_add_pc:
5447
address += (lh->minimum_instruction_length
5448
* ((255 - lh->opcode_base) / lh->line_range));
5450
case DW_LNS_fixed_advance_pc:
5451
address += read_2_bytes (abfd, line_ptr);
5455
{ /* Unknown standard opcode, ignore it. */
5457
for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
5459
(void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5460
line_ptr += bytes_read;
5468
/* Start a subfile for DWARF. FILENAME is the name of the file and
5469
DIRNAME the name of the source directory which contains FILENAME
5470
or NULL if not known.
5471
This routine tries to keep line numbers from identical absolute and
5472
relative file names in a common subfile.
5474
Using the `list' example from the GDB testsuite, which resides in
5475
/srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5476
of /srcdir/list0.c yields the following debugging information for list0.c:
5478
DW_AT_name: /srcdir/list0.c
5479
DW_AT_comp_dir: /compdir
5480
files.files[0].name: list0.h
5481
files.files[0].dir: /srcdir
5482
files.files[1].name: list0.c
5483
files.files[1].dir: /srcdir
5485
The line number information for list0.c has to end up in a single
5486
subfile, so that `break /srcdir/list0.c:1' works as expected. */
5489
dwarf2_start_subfile (char *filename, char *dirname)
5491
/* If the filename isn't absolute, try to match an existing subfile
5492
with the full pathname. */
5494
if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
5496
struct subfile *subfile;
5497
char *fullname = concat (dirname, "/", filename, NULL);
5499
for (subfile = subfiles; subfile; subfile = subfile->next)
5501
if (FILENAME_CMP (subfile->name, fullname) == 0)
5503
current_subfile = subfile;
5510
start_subfile (filename, dirname);
5514
var_decode_location (struct attribute *attr, struct symbol *sym,
5515
struct dwarf2_cu *cu)
5517
struct objfile *objfile = cu->objfile;
5518
struct comp_unit_head *cu_header = &cu->header;
5520
/* NOTE drow/2003-01-30: There used to be a comment and some special
5521
code here to turn a symbol with DW_AT_external and a
5522
SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5523
necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5524
with some versions of binutils) where shared libraries could have
5525
relocations against symbols in their debug information - the
5526
minimal symbol would have the right address, but the debug info
5527
would not. It's no longer necessary, because we will explicitly
5528
apply relocations when we read in the debug information now. */
5530
/* A DW_AT_location attribute with no contents indicates that a
5531
variable has been optimized away. */
5532
if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
5534
SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
5538
/* Handle one degenerate form of location expression specially, to
5539
preserve GDB's previous behavior when section offsets are
5540
specified. If this is just a DW_OP_addr then mark this symbol
5543
if (attr_form_is_block (attr)
5544
&& DW_BLOCK (attr)->size == 1 + cu_header->addr_size
5545
&& DW_BLOCK (attr)->data[0] == DW_OP_addr)
5549
SYMBOL_VALUE_ADDRESS (sym) =
5550
read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
5551
fixup_symbol_section (sym, objfile);
5552
SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
5553
SYMBOL_SECTION (sym));
5554
SYMBOL_CLASS (sym) = LOC_STATIC;
5558
/* NOTE drow/2002-01-30: It might be worthwhile to have a static
5559
expression evaluator, and use LOC_COMPUTED only when necessary
5560
(i.e. when the value of a register or memory location is
5561
referenced, or a thread-local block, etc.). Then again, it might
5562
not be worthwhile. I'm assuming that it isn't unless performance
5563
or memory numbers show me otherwise. */
5565
dwarf2_symbol_mark_computed (attr, sym, cu);
5566
SYMBOL_CLASS (sym) = LOC_COMPUTED;
5569
/* Given a pointer to a DWARF information entry, figure out if we need
5570
to make a symbol table entry for it, and if so, create a new entry
5571
and return a pointer to it.
5572
If TYPE is NULL, determine symbol type from the die, otherwise
5573
used the passed type. */
5575
static struct symbol *
5576
new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
5578
struct objfile *objfile = cu->objfile;
5579
struct symbol *sym = NULL;
5581
struct attribute *attr = NULL;
5582
struct attribute *attr2 = NULL;
5585
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5587
if (die->tag != DW_TAG_namespace)
5588
name = dwarf2_linkage_name (die, cu);
5590
name = TYPE_NAME (type);
5594
sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5595
sizeof (struct symbol));
5596
OBJSTAT (objfile, n_syms++);
5597
memset (sym, 0, sizeof (struct symbol));
5599
/* Cache this symbol's name and the name's demangled form (if any). */
5600
SYMBOL_LANGUAGE (sym) = cu->language;
5601
SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
5603
/* Default assumptions.
5604
Use the passed type or decode it from the die. */
5605
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5606
SYMBOL_CLASS (sym) = LOC_STATIC;
5608
SYMBOL_TYPE (sym) = type;
5610
SYMBOL_TYPE (sym) = die_type (die, cu);
5611
attr = dwarf2_attr (die, DW_AT_decl_line, cu);
5614
SYMBOL_LINE (sym) = DW_UNSND (attr);
5619
attr = dwarf2_attr (die, DW_AT_low_pc, cu);
5622
SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
5624
SYMBOL_CLASS (sym) = LOC_LABEL;
5626
case DW_TAG_subprogram:
5627
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5629
SYMBOL_CLASS (sym) = LOC_BLOCK;
5630
attr2 = dwarf2_attr (die, DW_AT_external, cu);
5631
if (attr2 && (DW_UNSND (attr2) != 0))
5633
add_symbol_to_list (sym, &global_symbols);
5637
add_symbol_to_list (sym, cu->list_in_scope);
5640
case DW_TAG_variable:
5641
/* Compilation with minimal debug info may result in variables
5642
with missing type entries. Change the misleading `void' type
5643
to something sensible. */
5644
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
5645
SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
5646
TARGET_INT_BIT / HOST_CHAR_BIT, 0,
5647
"<variable, no debug info>",
5649
attr = dwarf2_attr (die, DW_AT_const_value, cu);
5652
dwarf2_const_value (attr, sym, cu);
5653
attr2 = dwarf2_attr (die, DW_AT_external, cu);
5654
if (attr2 && (DW_UNSND (attr2) != 0))
5655
add_symbol_to_list (sym, &global_symbols);
5657
add_symbol_to_list (sym, cu->list_in_scope);
5660
attr = dwarf2_attr (die, DW_AT_location, cu);
5663
var_decode_location (attr, sym, cu);
5664
attr2 = dwarf2_attr (die, DW_AT_external, cu);
5665
if (attr2 && (DW_UNSND (attr2) != 0))
5666
add_symbol_to_list (sym, &global_symbols);
5668
add_symbol_to_list (sym, cu->list_in_scope);
5672
/* We do not know the address of this symbol.
5673
If it is an external symbol and we have type information
5674
for it, enter the symbol as a LOC_UNRESOLVED symbol.
5675
The address of the variable will then be determined from
5676
the minimal symbol table whenever the variable is
5678
attr2 = dwarf2_attr (die, DW_AT_external, cu);
5679
if (attr2 && (DW_UNSND (attr2) != 0)
5680
&& dwarf2_attr (die, DW_AT_type, cu) != NULL)
5682
SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
5683
add_symbol_to_list (sym, &global_symbols);
5687
case DW_TAG_formal_parameter:
5688
attr = dwarf2_attr (die, DW_AT_location, cu);
5691
var_decode_location (attr, sym, cu);
5692
/* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5693
if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
5694
SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
5696
attr = dwarf2_attr (die, DW_AT_const_value, cu);
5699
dwarf2_const_value (attr, sym, cu);
5701
add_symbol_to_list (sym, cu->list_in_scope);
5703
case DW_TAG_unspecified_parameters:
5704
/* From varargs functions; gdb doesn't seem to have any
5705
interest in this information, so just ignore it for now.
5708
case DW_TAG_class_type:
5709
case DW_TAG_structure_type:
5710
case DW_TAG_union_type:
5711
case DW_TAG_enumeration_type:
5712
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5713
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5715
/* Make sure that the symbol includes appropriate enclosing
5716
classes/namespaces in its name. These are calculated in
5717
read_structure_type, and the correct name is saved in
5720
if (cu->language == language_cplus)
5722
struct type *type = SYMBOL_TYPE (sym);
5724
if (TYPE_TAG_NAME (type) != NULL)
5726
/* FIXME: carlton/2003-11-10: Should this use
5727
SYMBOL_SET_NAMES instead? (The same problem also
5728
arises a further down in the function.) */
5729
SYMBOL_LINKAGE_NAME (sym)
5730
= obsavestring (TYPE_TAG_NAME (type),
5731
strlen (TYPE_TAG_NAME (type)),
5732
&objfile->objfile_obstack);
5737
/* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
5738
really ever be static objects: otherwise, if you try
5739
to, say, break of a class's method and you're in a file
5740
which doesn't mention that class, it won't work unless
5741
the check for all static symbols in lookup_symbol_aux
5742
saves you. See the OtherFileClass tests in
5743
gdb.c++/namespace.exp. */
5745
struct pending **list_to_add;
5747
list_to_add = (cu->list_in_scope == &file_symbols
5748
&& cu->language == language_cplus
5749
? &global_symbols : cu->list_in_scope);
5751
add_symbol_to_list (sym, list_to_add);
5753
/* The semantics of C++ state that "struct foo { ... }" also
5754
defines a typedef for "foo". Synthesize a typedef symbol so
5755
that "ptype foo" works as expected. */
5756
if (cu->language == language_cplus)
5758
struct symbol *typedef_sym = (struct symbol *)
5759
obstack_alloc (&objfile->objfile_obstack,
5760
sizeof (struct symbol));
5761
*typedef_sym = *sym;
5762
SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
5763
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
5764
TYPE_NAME (SYMBOL_TYPE (sym)) =
5765
obsavestring (SYMBOL_NATURAL_NAME (sym),
5766
strlen (SYMBOL_NATURAL_NAME (sym)),
5767
&objfile->objfile_obstack);
5768
add_symbol_to_list (typedef_sym, list_to_add);
5772
case DW_TAG_typedef:
5773
if (processing_has_namespace_info
5774
&& processing_current_prefix[0] != '\0')
5776
SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
5777
processing_current_prefix,
5781
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5782
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5783
add_symbol_to_list (sym, cu->list_in_scope);
5785
case DW_TAG_base_type:
5786
case DW_TAG_subrange_type:
5787
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5788
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5789
add_symbol_to_list (sym, cu->list_in_scope);
5791
case DW_TAG_enumerator:
5792
if (processing_has_namespace_info
5793
&& processing_current_prefix[0] != '\0')
5795
SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
5796
processing_current_prefix,
5800
attr = dwarf2_attr (die, DW_AT_const_value, cu);
5803
dwarf2_const_value (attr, sym, cu);
5806
/* NOTE: carlton/2003-11-10: See comment above in the
5807
DW_TAG_class_type, etc. block. */
5809
struct pending **list_to_add;
5811
list_to_add = (cu->list_in_scope == &file_symbols
5812
&& cu->language == language_cplus
5813
? &global_symbols : cu->list_in_scope);
5815
add_symbol_to_list (sym, list_to_add);
5818
case DW_TAG_namespace:
5819
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5820
add_symbol_to_list (sym, &global_symbols);
5823
/* Not a tag we recognize. Hopefully we aren't processing
5824
trash data, but since we must specifically ignore things
5825
we don't recognize, there is nothing else we should do at
5827
complaint (&symfile_complaints, "unsupported tag: '%s'",
5828
dwarf_tag_name (die->tag));
5835
/* Copy constant value from an attribute to a symbol. */
5838
dwarf2_const_value (struct attribute *attr, struct symbol *sym,
5839
struct dwarf2_cu *cu)
5841
struct objfile *objfile = cu->objfile;
5842
struct comp_unit_head *cu_header = &cu->header;
5843
struct dwarf_block *blk;
5848
if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
5849
dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5850
cu_header->addr_size,
5851
TYPE_LENGTH (SYMBOL_TYPE
5853
SYMBOL_VALUE_BYTES (sym) = (char *)
5854
obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
5855
/* NOTE: cagney/2003-05-09: In-lined store_address call with
5856
it's body - store_unsigned_integer. */
5857
store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
5859
SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5861
case DW_FORM_block1:
5862
case DW_FORM_block2:
5863
case DW_FORM_block4:
5865
blk = DW_BLOCK (attr);
5866
if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
5867
dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5869
TYPE_LENGTH (SYMBOL_TYPE
5871
SYMBOL_VALUE_BYTES (sym) = (char *)
5872
obstack_alloc (&objfile->objfile_obstack, blk->size);
5873
memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
5874
SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5877
/* The DW_AT_const_value attributes are supposed to carry the
5878
symbol's value "represented as it would be on the target
5879
architecture." By the time we get here, it's already been
5880
converted to host endianness, so we just need to sign- or
5881
zero-extend it as appropriate. */
5883
dwarf2_const_value_data (attr, sym, 8);
5886
dwarf2_const_value_data (attr, sym, 16);
5889
dwarf2_const_value_data (attr, sym, 32);
5892
dwarf2_const_value_data (attr, sym, 64);
5896
SYMBOL_VALUE (sym) = DW_SND (attr);
5897
SYMBOL_CLASS (sym) = LOC_CONST;
5901
SYMBOL_VALUE (sym) = DW_UNSND (attr);
5902
SYMBOL_CLASS (sym) = LOC_CONST;
5906
complaint (&symfile_complaints,
5907
"unsupported const value attribute form: '%s'",
5908
dwarf_form_name (attr->form));
5909
SYMBOL_VALUE (sym) = 0;
5910
SYMBOL_CLASS (sym) = LOC_CONST;
5916
/* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5917
or zero-extend it as appropriate for the symbol's type. */
5919
dwarf2_const_value_data (struct attribute *attr,
5923
LONGEST l = DW_UNSND (attr);
5925
if (bits < sizeof (l) * 8)
5927
if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
5928
l &= ((LONGEST) 1 << bits) - 1;
5930
l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
5933
SYMBOL_VALUE (sym) = l;
5934
SYMBOL_CLASS (sym) = LOC_CONST;
5938
/* Return the type of the die in question using its DW_AT_type attribute. */
5940
static struct type *
5941
die_type (struct die_info *die, struct dwarf2_cu *cu)
5944
struct attribute *type_attr;
5945
struct die_info *type_die;
5948
type_attr = dwarf2_attr (die, DW_AT_type, cu);
5951
/* A missing DW_AT_type represents a void type. */
5952
return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
5956
ref = dwarf2_get_ref_die_offset (type_attr, cu);
5957
type_die = follow_die_ref (ref);
5960
error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5961
ref, cu->objfile->name);
5965
type = tag_type_to_type (type_die, cu);
5968
dump_die (type_die);
5969
error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5975
/* Return the containing type of the die in question using its
5976
DW_AT_containing_type attribute. */
5978
static struct type *
5979
die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
5981
struct type *type = NULL;
5982
struct attribute *type_attr;
5983
struct die_info *type_die = NULL;
5986
type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
5989
ref = dwarf2_get_ref_die_offset (type_attr, cu);
5990
type_die = follow_die_ref (ref);
5993
error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref,
5997
type = tag_type_to_type (type_die, cu);
6002
dump_die (type_die);
6003
error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
6010
static struct type *
6011
type_at_offset (unsigned int offset, struct dwarf2_cu *cu)
6013
struct die_info *die;
6016
die = follow_die_ref (offset);
6019
error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
6022
type = tag_type_to_type (die, cu);
6027
static struct type *
6028
tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
6036
read_type_die (die, cu);
6040
error ("Dwarf Error: Cannot find type of die [in module %s]",
6048
read_type_die (struct die_info *die, struct dwarf2_cu *cu)
6050
char *prefix = determine_prefix (die, cu);
6051
const char *old_prefix = processing_current_prefix;
6052
struct cleanup *back_to = make_cleanup (xfree, prefix);
6053
processing_current_prefix = prefix;
6057
case DW_TAG_class_type:
6058
case DW_TAG_structure_type:
6059
case DW_TAG_union_type:
6060
read_structure_type (die, cu);
6062
process_structure_scope (die, cu);
6065
case DW_TAG_enumeration_type:
6066
read_enumeration_type (die, cu);
6068
process_enumeration_scope (die, cu);
6071
case DW_TAG_subprogram:
6072
case DW_TAG_subroutine_type:
6073
read_subroutine_type (die, cu);
6075
case DW_TAG_array_type:
6076
read_array_type (die, cu);
6078
case DW_TAG_pointer_type:
6079
read_tag_pointer_type (die, cu);
6081
case DW_TAG_ptr_to_member_type:
6082
read_tag_ptr_to_member_type (die, cu);
6084
case DW_TAG_reference_type:
6085
read_tag_reference_type (die, cu);
6087
case DW_TAG_const_type:
6088
read_tag_const_type (die, cu);
6090
case DW_TAG_volatile_type:
6091
read_tag_volatile_type (die, cu);
6093
case DW_TAG_string_type:
6094
read_tag_string_type (die, cu);
6096
case DW_TAG_typedef:
6097
read_typedef (die, cu);
6099
case DW_TAG_subrange_type:
6100
read_subrange_type (die, cu);
6102
case DW_TAG_base_type:
6103
read_base_type (die, cu);
6105
new_symbol (die, die->type, cu);
6109
complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'",
6110
dwarf_tag_name (die->tag));
6114
processing_current_prefix = old_prefix;
6115
do_cleanups (back_to);
6118
/* Return the name of the namespace/class that DIE is defined within,
6119
or "" if we can't tell. The caller should xfree the result. */
6121
/* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6122
therein) for an example of how to use this function to deal with
6123
DW_AT_specification. */
6126
determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
6128
struct die_info *parent;
6130
if (cu->language != language_cplus)
6133
parent = die->parent;
6137
return xstrdup ("");
6141
switch (parent->tag) {
6142
case DW_TAG_namespace:
6144
/* FIXME: carlton/2004-03-05: Should I follow extension dies
6145
before doing this check? */
6146
if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6148
return xstrdup (TYPE_TAG_NAME (parent->type));
6153
char *parent_prefix = determine_prefix (parent, cu);
6154
char *retval = typename_concat (parent_prefix,
6155
namespace_name (parent, &dummy,
6157
xfree (parent_prefix);
6162
case DW_TAG_class_type:
6163
case DW_TAG_structure_type:
6165
if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6167
return xstrdup (TYPE_TAG_NAME (parent->type));
6171
const char *old_prefix = processing_current_prefix;
6172
char *new_prefix = determine_prefix (parent, cu);
6175
processing_current_prefix = new_prefix;
6176
retval = determine_class_name (parent, cu);
6177
processing_current_prefix = old_prefix;
6184
return determine_prefix (parent, cu);
6189
/* Return a newly-allocated string formed by concatenating PREFIX,
6190
"::", and SUFFIX, except that if PREFIX is NULL or the empty
6191
string, just return a copy of SUFFIX. */
6194
typename_concat (const char *prefix, const char *suffix)
6196
if (prefix == NULL || prefix[0] == '\0')
6197
return xstrdup (suffix);
6200
char *retval = xmalloc (strlen (prefix) + 2 + strlen (suffix) + 1);
6202
strcpy (retval, prefix);
6203
strcat (retval, "::");
6204
strcat (retval, suffix);
6210
static struct type *
6211
dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
6213
struct objfile *objfile = cu->objfile;
6215
/* FIXME - this should not produce a new (struct type *)
6216
every time. It should cache base types. */
6220
case DW_ATE_address:
6221
type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
6223
case DW_ATE_boolean:
6224
type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
6226
case DW_ATE_complex_float:
6229
type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
6233
type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
6239
type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
6243
type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
6250
type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6253
type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
6257
type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6261
case DW_ATE_signed_char:
6262
type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6264
case DW_ATE_unsigned:
6268
type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6271
type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
6275
type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
6279
case DW_ATE_unsigned_char:
6280
type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6283
type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6290
copy_die (struct die_info *old_die)
6292
struct die_info *new_die;
6295
new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
6296
memset (new_die, 0, sizeof (struct die_info));
6298
new_die->tag = old_die->tag;
6299
new_die->has_children = old_die->has_children;
6300
new_die->abbrev = old_die->abbrev;
6301
new_die->offset = old_die->offset;
6302
new_die->type = NULL;
6304
num_attrs = old_die->num_attrs;
6305
new_die->num_attrs = num_attrs;
6306
new_die->attrs = (struct attribute *)
6307
xmalloc (num_attrs * sizeof (struct attribute));
6309
for (i = 0; i < old_die->num_attrs; ++i)
6311
new_die->attrs[i].name = old_die->attrs[i].name;
6312
new_die->attrs[i].form = old_die->attrs[i].form;
6313
new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
6316
new_die->next = NULL;
6321
/* Return sibling of die, NULL if no sibling. */
6323
static struct die_info *
6324
sibling_die (struct die_info *die)
6326
return die->sibling;
6329
/* Get linkage name of a die, return NULL if not found. */
6332
dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
6334
struct attribute *attr;
6336
attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
6337
if (attr && DW_STRING (attr))
6338
return DW_STRING (attr);
6339
attr = dwarf2_attr (die, DW_AT_name, cu);
6340
if (attr && DW_STRING (attr))
6341
return DW_STRING (attr);
6345
/* Get name of a die, return NULL if not found. */
6348
dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
6350
struct attribute *attr;
6352
attr = dwarf2_attr (die, DW_AT_name, cu);
6353
if (attr && DW_STRING (attr))
6354
return DW_STRING (attr);
6358
/* Return the die that this die in an extension of, or NULL if there
6361
static struct die_info *
6362
dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
6364
struct attribute *attr;
6365
struct die_info *extension_die;
6368
attr = dwarf2_attr (die, DW_AT_extension, cu);
6372
ref = dwarf2_get_ref_die_offset (attr, cu);
6373
extension_die = follow_die_ref (ref);
6376
error ("Dwarf Error: Cannot find referent at offset %d.", ref);
6379
return extension_die;
6382
/* Convert a DIE tag into its string name. */
6385
dwarf_tag_name (unsigned tag)
6389
case DW_TAG_padding:
6390
return "DW_TAG_padding";
6391
case DW_TAG_array_type:
6392
return "DW_TAG_array_type";
6393
case DW_TAG_class_type:
6394
return "DW_TAG_class_type";
6395
case DW_TAG_entry_point:
6396
return "DW_TAG_entry_point";
6397
case DW_TAG_enumeration_type:
6398
return "DW_TAG_enumeration_type";
6399
case DW_TAG_formal_parameter:
6400
return "DW_TAG_formal_parameter";
6401
case DW_TAG_imported_declaration:
6402
return "DW_TAG_imported_declaration";
6404
return "DW_TAG_label";
6405
case DW_TAG_lexical_block:
6406
return "DW_TAG_lexical_block";
6408
return "DW_TAG_member";
6409
case DW_TAG_pointer_type:
6410
return "DW_TAG_pointer_type";
6411
case DW_TAG_reference_type:
6412
return "DW_TAG_reference_type";
6413
case DW_TAG_compile_unit:
6414
return "DW_TAG_compile_unit";
6415
case DW_TAG_string_type:
6416
return "DW_TAG_string_type";
6417
case DW_TAG_structure_type:
6418
return "DW_TAG_structure_type";
6419
case DW_TAG_subroutine_type:
6420
return "DW_TAG_subroutine_type";
6421
case DW_TAG_typedef:
6422
return "DW_TAG_typedef";
6423
case DW_TAG_union_type:
6424
return "DW_TAG_union_type";
6425
case DW_TAG_unspecified_parameters:
6426
return "DW_TAG_unspecified_parameters";
6427
case DW_TAG_variant:
6428
return "DW_TAG_variant";
6429
case DW_TAG_common_block:
6430
return "DW_TAG_common_block";
6431
case DW_TAG_common_inclusion:
6432
return "DW_TAG_common_inclusion";
6433
case DW_TAG_inheritance:
6434
return "DW_TAG_inheritance";
6435
case DW_TAG_inlined_subroutine:
6436
return "DW_TAG_inlined_subroutine";
6438
return "DW_TAG_module";
6439
case DW_TAG_ptr_to_member_type:
6440
return "DW_TAG_ptr_to_member_type";
6441
case DW_TAG_set_type:
6442
return "DW_TAG_set_type";
6443
case DW_TAG_subrange_type:
6444
return "DW_TAG_subrange_type";
6445
case DW_TAG_with_stmt:
6446
return "DW_TAG_with_stmt";
6447
case DW_TAG_access_declaration:
6448
return "DW_TAG_access_declaration";
6449
case DW_TAG_base_type:
6450
return "DW_TAG_base_type";
6451
case DW_TAG_catch_block:
6452
return "DW_TAG_catch_block";
6453
case DW_TAG_const_type:
6454
return "DW_TAG_const_type";
6455
case DW_TAG_constant:
6456
return "DW_TAG_constant";
6457
case DW_TAG_enumerator:
6458
return "DW_TAG_enumerator";
6459
case DW_TAG_file_type:
6460
return "DW_TAG_file_type";
6462
return "DW_TAG_friend";
6463
case DW_TAG_namelist:
6464
return "DW_TAG_namelist";
6465
case DW_TAG_namelist_item:
6466
return "DW_TAG_namelist_item";
6467
case DW_TAG_packed_type:
6468
return "DW_TAG_packed_type";
6469
case DW_TAG_subprogram:
6470
return "DW_TAG_subprogram";
6471
case DW_TAG_template_type_param:
6472
return "DW_TAG_template_type_param";
6473
case DW_TAG_template_value_param:
6474
return "DW_TAG_template_value_param";
6475
case DW_TAG_thrown_type:
6476
return "DW_TAG_thrown_type";
6477
case DW_TAG_try_block:
6478
return "DW_TAG_try_block";
6479
case DW_TAG_variant_part:
6480
return "DW_TAG_variant_part";
6481
case DW_TAG_variable:
6482
return "DW_TAG_variable";
6483
case DW_TAG_volatile_type:
6484
return "DW_TAG_volatile_type";
6485
case DW_TAG_dwarf_procedure:
6486
return "DW_TAG_dwarf_procedure";
6487
case DW_TAG_restrict_type:
6488
return "DW_TAG_restrict_type";
6489
case DW_TAG_interface_type:
6490
return "DW_TAG_interface_type";
6491
case DW_TAG_namespace:
6492
return "DW_TAG_namespace";
6493
case DW_TAG_imported_module:
6494
return "DW_TAG_imported_module";
6495
case DW_TAG_unspecified_type:
6496
return "DW_TAG_unspecified_type";
6497
case DW_TAG_partial_unit:
6498
return "DW_TAG_partial_unit";
6499
case DW_TAG_imported_unit:
6500
return "DW_TAG_imported_unit";
6501
case DW_TAG_MIPS_loop:
6502
return "DW_TAG_MIPS_loop";
6503
case DW_TAG_format_label:
6504
return "DW_TAG_format_label";
6505
case DW_TAG_function_template:
6506
return "DW_TAG_function_template";
6507
case DW_TAG_class_template:
6508
return "DW_TAG_class_template";
6510
return "DW_TAG_<unknown>";
6514
/* Convert a DWARF attribute code into its string name. */
6517
dwarf_attr_name (unsigned attr)
6522
return "DW_AT_sibling";
6523
case DW_AT_location:
6524
return "DW_AT_location";
6526
return "DW_AT_name";
6527
case DW_AT_ordering:
6528
return "DW_AT_ordering";
6529
case DW_AT_subscr_data:
6530
return "DW_AT_subscr_data";
6531
case DW_AT_byte_size:
6532
return "DW_AT_byte_size";
6533
case DW_AT_bit_offset:
6534
return "DW_AT_bit_offset";
6535
case DW_AT_bit_size:
6536
return "DW_AT_bit_size";
6537
case DW_AT_element_list:
6538
return "DW_AT_element_list";
6539
case DW_AT_stmt_list:
6540
return "DW_AT_stmt_list";
6542
return "DW_AT_low_pc";
6544
return "DW_AT_high_pc";
6545
case DW_AT_language:
6546
return "DW_AT_language";
6548
return "DW_AT_member";
6550
return "DW_AT_discr";
6551
case DW_AT_discr_value:
6552
return "DW_AT_discr_value";
6553
case DW_AT_visibility:
6554
return "DW_AT_visibility";
6556
return "DW_AT_import";
6557
case DW_AT_string_length:
6558
return "DW_AT_string_length";
6559
case DW_AT_common_reference:
6560
return "DW_AT_common_reference";
6561
case DW_AT_comp_dir:
6562
return "DW_AT_comp_dir";
6563
case DW_AT_const_value:
6564
return "DW_AT_const_value";
6565
case DW_AT_containing_type:
6566
return "DW_AT_containing_type";
6567
case DW_AT_default_value:
6568
return "DW_AT_default_value";
6570
return "DW_AT_inline";
6571
case DW_AT_is_optional:
6572
return "DW_AT_is_optional";
6573
case DW_AT_lower_bound:
6574
return "DW_AT_lower_bound";
6575
case DW_AT_producer:
6576
return "DW_AT_producer";
6577
case DW_AT_prototyped:
6578
return "DW_AT_prototyped";
6579
case DW_AT_return_addr:
6580
return "DW_AT_return_addr";
6581
case DW_AT_start_scope:
6582
return "DW_AT_start_scope";
6583
case DW_AT_stride_size:
6584
return "DW_AT_stride_size";
6585
case DW_AT_upper_bound:
6586
return "DW_AT_upper_bound";
6587
case DW_AT_abstract_origin:
6588
return "DW_AT_abstract_origin";
6589
case DW_AT_accessibility:
6590
return "DW_AT_accessibility";
6591
case DW_AT_address_class:
6592
return "DW_AT_address_class";
6593
case DW_AT_artificial:
6594
return "DW_AT_artificial";
6595
case DW_AT_base_types:
6596
return "DW_AT_base_types";
6597
case DW_AT_calling_convention:
6598
return "DW_AT_calling_convention";
6600
return "DW_AT_count";
6601
case DW_AT_data_member_location:
6602
return "DW_AT_data_member_location";
6603
case DW_AT_decl_column:
6604
return "DW_AT_decl_column";
6605
case DW_AT_decl_file:
6606
return "DW_AT_decl_file";
6607
case DW_AT_decl_line:
6608
return "DW_AT_decl_line";
6609
case DW_AT_declaration:
6610
return "DW_AT_declaration";
6611
case DW_AT_discr_list:
6612
return "DW_AT_discr_list";
6613
case DW_AT_encoding:
6614
return "DW_AT_encoding";
6615
case DW_AT_external:
6616
return "DW_AT_external";
6617
case DW_AT_frame_base:
6618
return "DW_AT_frame_base";
6620
return "DW_AT_friend";
6621
case DW_AT_identifier_case:
6622
return "DW_AT_identifier_case";
6623
case DW_AT_macro_info:
6624
return "DW_AT_macro_info";
6625
case DW_AT_namelist_items:
6626
return "DW_AT_namelist_items";
6627
case DW_AT_priority:
6628
return "DW_AT_priority";
6630
return "DW_AT_segment";
6631
case DW_AT_specification:
6632
return "DW_AT_specification";
6633
case DW_AT_static_link:
6634
return "DW_AT_static_link";
6636
return "DW_AT_type";
6637
case DW_AT_use_location:
6638
return "DW_AT_use_location";
6639
case DW_AT_variable_parameter:
6640
return "DW_AT_variable_parameter";
6641
case DW_AT_virtuality:
6642
return "DW_AT_virtuality";
6643
case DW_AT_vtable_elem_location:
6644
return "DW_AT_vtable_elem_location";
6645
case DW_AT_allocated:
6646
return "DW_AT_allocated";
6647
case DW_AT_associated:
6648
return "DW_AT_associated";
6649
case DW_AT_data_location:
6650
return "DW_AT_data_location";
6652
return "DW_AT_stride";
6653
case DW_AT_entry_pc:
6654
return "DW_AT_entry_pc";
6655
case DW_AT_use_UTF8:
6656
return "DW_AT_use_UTF8";
6657
case DW_AT_extension:
6658
return "DW_AT_extension";
6660
return "DW_AT_ranges";
6661
case DW_AT_trampoline:
6662
return "DW_AT_trampoline";
6663
case DW_AT_call_column:
6664
return "DW_AT_call_column";
6665
case DW_AT_call_file:
6666
return "DW_AT_call_file";
6667
case DW_AT_call_line:
6668
return "DW_AT_call_line";
6670
case DW_AT_MIPS_fde:
6671
return "DW_AT_MIPS_fde";
6672
case DW_AT_MIPS_loop_begin:
6673
return "DW_AT_MIPS_loop_begin";
6674
case DW_AT_MIPS_tail_loop_begin:
6675
return "DW_AT_MIPS_tail_loop_begin";
6676
case DW_AT_MIPS_epilog_begin:
6677
return "DW_AT_MIPS_epilog_begin";
6678
case DW_AT_MIPS_loop_unroll_factor:
6679
return "DW_AT_MIPS_loop_unroll_factor";
6680
case DW_AT_MIPS_software_pipeline_depth:
6681
return "DW_AT_MIPS_software_pipeline_depth";
6683
case DW_AT_MIPS_linkage_name:
6684
return "DW_AT_MIPS_linkage_name";
6686
case DW_AT_sf_names:
6687
return "DW_AT_sf_names";
6688
case DW_AT_src_info:
6689
return "DW_AT_src_info";
6690
case DW_AT_mac_info:
6691
return "DW_AT_mac_info";
6692
case DW_AT_src_coords:
6693
return "DW_AT_src_coords";
6694
case DW_AT_body_begin:
6695
return "DW_AT_body_begin";
6696
case DW_AT_body_end:
6697
return "DW_AT_body_end";
6698
case DW_AT_GNU_vector:
6699
return "DW_AT_GNU_vector";
6701
return "DW_AT_<unknown>";
6705
/* Convert a DWARF value form code into its string name. */
6708
dwarf_form_name (unsigned form)
6713
return "DW_FORM_addr";
6714
case DW_FORM_block2:
6715
return "DW_FORM_block2";
6716
case DW_FORM_block4:
6717
return "DW_FORM_block4";
6719
return "DW_FORM_data2";
6721
return "DW_FORM_data4";
6723
return "DW_FORM_data8";
6724
case DW_FORM_string:
6725
return "DW_FORM_string";
6727
return "DW_FORM_block";
6728
case DW_FORM_block1:
6729
return "DW_FORM_block1";
6731
return "DW_FORM_data1";
6733
return "DW_FORM_flag";
6735
return "DW_FORM_sdata";
6737
return "DW_FORM_strp";
6739
return "DW_FORM_udata";
6740
case DW_FORM_ref_addr:
6741
return "DW_FORM_ref_addr";
6743
return "DW_FORM_ref1";
6745
return "DW_FORM_ref2";
6747
return "DW_FORM_ref4";
6749
return "DW_FORM_ref8";
6750
case DW_FORM_ref_udata:
6751
return "DW_FORM_ref_udata";
6752
case DW_FORM_indirect:
6753
return "DW_FORM_indirect";
6755
return "DW_FORM_<unknown>";
6759
/* Convert a DWARF stack opcode into its string name. */
6762
dwarf_stack_op_name (unsigned op)
6767
return "DW_OP_addr";
6769
return "DW_OP_deref";
6771
return "DW_OP_const1u";
6773
return "DW_OP_const1s";
6775
return "DW_OP_const2u";
6777
return "DW_OP_const2s";
6779
return "DW_OP_const4u";
6781
return "DW_OP_const4s";
6783
return "DW_OP_const8u";
6785
return "DW_OP_const8s";
6787
return "DW_OP_constu";
6789
return "DW_OP_consts";
6793
return "DW_OP_drop";
6795
return "DW_OP_over";
6797
return "DW_OP_pick";
6799
return "DW_OP_swap";
6803
return "DW_OP_xderef";
6811
return "DW_OP_minus";
6823
return "DW_OP_plus";
6824
case DW_OP_plus_uconst:
6825
return "DW_OP_plus_uconst";
6831
return "DW_OP_shra";
6849
return "DW_OP_skip";
6851
return "DW_OP_lit0";
6853
return "DW_OP_lit1";
6855
return "DW_OP_lit2";
6857
return "DW_OP_lit3";
6859
return "DW_OP_lit4";
6861
return "DW_OP_lit5";
6863
return "DW_OP_lit6";
6865
return "DW_OP_lit7";
6867
return "DW_OP_lit8";
6869
return "DW_OP_lit9";
6871
return "DW_OP_lit10";
6873
return "DW_OP_lit11";
6875
return "DW_OP_lit12";
6877
return "DW_OP_lit13";
6879
return "DW_OP_lit14";
6881
return "DW_OP_lit15";
6883
return "DW_OP_lit16";
6885
return "DW_OP_lit17";
6887
return "DW_OP_lit18";
6889
return "DW_OP_lit19";
6891
return "DW_OP_lit20";
6893
return "DW_OP_lit21";
6895
return "DW_OP_lit22";
6897
return "DW_OP_lit23";
6899
return "DW_OP_lit24";
6901
return "DW_OP_lit25";
6903
return "DW_OP_lit26";
6905
return "DW_OP_lit27";
6907
return "DW_OP_lit28";
6909
return "DW_OP_lit29";
6911
return "DW_OP_lit30";
6913
return "DW_OP_lit31";
6915
return "DW_OP_reg0";
6917
return "DW_OP_reg1";
6919
return "DW_OP_reg2";
6921
return "DW_OP_reg3";
6923
return "DW_OP_reg4";
6925
return "DW_OP_reg5";
6927
return "DW_OP_reg6";
6929
return "DW_OP_reg7";
6931
return "DW_OP_reg8";
6933
return "DW_OP_reg9";
6935
return "DW_OP_reg10";
6937
return "DW_OP_reg11";
6939
return "DW_OP_reg12";
6941
return "DW_OP_reg13";
6943
return "DW_OP_reg14";
6945
return "DW_OP_reg15";
6947
return "DW_OP_reg16";
6949
return "DW_OP_reg17";
6951
return "DW_OP_reg18";
6953
return "DW_OP_reg19";
6955
return "DW_OP_reg20";
6957
return "DW_OP_reg21";
6959
return "DW_OP_reg22";
6961
return "DW_OP_reg23";
6963
return "DW_OP_reg24";
6965
return "DW_OP_reg25";
6967
return "DW_OP_reg26";
6969
return "DW_OP_reg27";
6971
return "DW_OP_reg28";
6973
return "DW_OP_reg29";
6975
return "DW_OP_reg30";
6977
return "DW_OP_reg31";
6979
return "DW_OP_breg0";
6981
return "DW_OP_breg1";
6983
return "DW_OP_breg2";
6985
return "DW_OP_breg3";
6987
return "DW_OP_breg4";
6989
return "DW_OP_breg5";
6991
return "DW_OP_breg6";
6993
return "DW_OP_breg7";
6995
return "DW_OP_breg8";
6997
return "DW_OP_breg9";
6999
return "DW_OP_breg10";
7001
return "DW_OP_breg11";
7003
return "DW_OP_breg12";
7005
return "DW_OP_breg13";
7007
return "DW_OP_breg14";
7009
return "DW_OP_breg15";
7011
return "DW_OP_breg16";
7013
return "DW_OP_breg17";
7015
return "DW_OP_breg18";
7017
return "DW_OP_breg19";
7019
return "DW_OP_breg20";
7021
return "DW_OP_breg21";
7023
return "DW_OP_breg22";
7025
return "DW_OP_breg23";
7027
return "DW_OP_breg24";
7029
return "DW_OP_breg25";
7031
return "DW_OP_breg26";
7033
return "DW_OP_breg27";
7035
return "DW_OP_breg28";
7037
return "DW_OP_breg29";
7039
return "DW_OP_breg30";
7041
return "DW_OP_breg31";
7043
return "DW_OP_regx";
7045
return "DW_OP_fbreg";
7047
return "DW_OP_bregx";
7049
return "DW_OP_piece";
7050
case DW_OP_deref_size:
7051
return "DW_OP_deref_size";
7052
case DW_OP_xderef_size:
7053
return "DW_OP_xderef_size";
7056
/* DWARF 3 extensions. */
7057
case DW_OP_push_object_address:
7058
return "DW_OP_push_object_address";
7060
return "DW_OP_call2";
7062
return "DW_OP_call4";
7063
case DW_OP_call_ref:
7064
return "DW_OP_call_ref";
7065
/* GNU extensions. */
7066
case DW_OP_GNU_push_tls_address:
7067
return "DW_OP_GNU_push_tls_address";
7069
return "OP_<unknown>";
7074
dwarf_bool_name (unsigned mybool)
7082
/* Convert a DWARF type code into its string name. */
7085
dwarf_type_encoding_name (unsigned enc)
7089
case DW_ATE_address:
7090
return "DW_ATE_address";
7091
case DW_ATE_boolean:
7092
return "DW_ATE_boolean";
7093
case DW_ATE_complex_float:
7094
return "DW_ATE_complex_float";
7096
return "DW_ATE_float";
7098
return "DW_ATE_signed";
7099
case DW_ATE_signed_char:
7100
return "DW_ATE_signed_char";
7101
case DW_ATE_unsigned:
7102
return "DW_ATE_unsigned";
7103
case DW_ATE_unsigned_char:
7104
return "DW_ATE_unsigned_char";
7105
case DW_ATE_imaginary_float:
7106
return "DW_ATE_imaginary_float";
7108
return "DW_ATE_<unknown>";
7112
/* Convert a DWARF call frame info operation to its string name. */
7116
dwarf_cfi_name (unsigned cfi_opc)
7120
case DW_CFA_advance_loc:
7121
return "DW_CFA_advance_loc";
7123
return "DW_CFA_offset";
7124
case DW_CFA_restore:
7125
return "DW_CFA_restore";
7127
return "DW_CFA_nop";
7128
case DW_CFA_set_loc:
7129
return "DW_CFA_set_loc";
7130
case DW_CFA_advance_loc1:
7131
return "DW_CFA_advance_loc1";
7132
case DW_CFA_advance_loc2:
7133
return "DW_CFA_advance_loc2";
7134
case DW_CFA_advance_loc4:
7135
return "DW_CFA_advance_loc4";
7136
case DW_CFA_offset_extended:
7137
return "DW_CFA_offset_extended";
7138
case DW_CFA_restore_extended:
7139
return "DW_CFA_restore_extended";
7140
case DW_CFA_undefined:
7141
return "DW_CFA_undefined";
7142
case DW_CFA_same_value:
7143
return "DW_CFA_same_value";
7144
case DW_CFA_register:
7145
return "DW_CFA_register";
7146
case DW_CFA_remember_state:
7147
return "DW_CFA_remember_state";
7148
case DW_CFA_restore_state:
7149
return "DW_CFA_restore_state";
7150
case DW_CFA_def_cfa:
7151
return "DW_CFA_def_cfa";
7152
case DW_CFA_def_cfa_register:
7153
return "DW_CFA_def_cfa_register";
7154
case DW_CFA_def_cfa_offset:
7155
return "DW_CFA_def_cfa_offset";
7158
case DW_CFA_def_cfa_expression:
7159
return "DW_CFA_def_cfa_expression";
7160
case DW_CFA_expression:
7161
return "DW_CFA_expression";
7162
case DW_CFA_offset_extended_sf:
7163
return "DW_CFA_offset_extended_sf";
7164
case DW_CFA_def_cfa_sf:
7165
return "DW_CFA_def_cfa_sf";
7166
case DW_CFA_def_cfa_offset_sf:
7167
return "DW_CFA_def_cfa_offset_sf";
7169
/* SGI/MIPS specific */
7170
case DW_CFA_MIPS_advance_loc8:
7171
return "DW_CFA_MIPS_advance_loc8";
7173
/* GNU extensions */
7174
case DW_CFA_GNU_window_save:
7175
return "DW_CFA_GNU_window_save";
7176
case DW_CFA_GNU_args_size:
7177
return "DW_CFA_GNU_args_size";
7178
case DW_CFA_GNU_negative_offset_extended:
7179
return "DW_CFA_GNU_negative_offset_extended";
7182
return "DW_CFA_<unknown>";
7188
dump_die (struct die_info *die)
7192
fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
7193
dwarf_tag_name (die->tag), die->abbrev, die->offset);
7194
fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
7195
dwarf_bool_name (die->child != NULL));
7197
fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
7198
for (i = 0; i < die->num_attrs; ++i)
7200
fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
7201
dwarf_attr_name (die->attrs[i].name),
7202
dwarf_form_name (die->attrs[i].form));
7203
switch (die->attrs[i].form)
7205
case DW_FORM_ref_addr:
7207
fprintf_unfiltered (gdb_stderr, "address: ");
7208
print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
7210
case DW_FORM_block2:
7211
case DW_FORM_block4:
7213
case DW_FORM_block1:
7214
fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
7225
fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
7227
case DW_FORM_string:
7229
fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
7230
DW_STRING (&die->attrs[i])
7231
? DW_STRING (&die->attrs[i]) : "");
7234
if (DW_UNSND (&die->attrs[i]))
7235
fprintf_unfiltered (gdb_stderr, "flag: TRUE");
7237
fprintf_unfiltered (gdb_stderr, "flag: FALSE");
7239
case DW_FORM_indirect:
7240
/* the reader will have reduced the indirect form to
7241
the "base form" so this form should not occur */
7242
fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
7245
fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
7246
die->attrs[i].form);
7248
fprintf_unfiltered (gdb_stderr, "\n");
7253
dump_die_list (struct die_info *die)
7258
if (die->child != NULL)
7259
dump_die_list (die->child);
7260
if (die->sibling != NULL)
7261
dump_die_list (die->sibling);
7266
store_in_ref_table (unsigned int offset, struct die_info *die)
7269
struct die_info *old;
7271
h = (offset % REF_HASH_SIZE);
7272
old = die_ref_table[h];
7273
die->next_ref = old;
7274
die_ref_table[h] = die;
7279
dwarf2_empty_hash_tables (void)
7281
memset (die_ref_table, 0, sizeof (die_ref_table));
7285
dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
7287
unsigned int result = 0;
7291
case DW_FORM_ref_addr:
7292
result = DW_ADDR (attr);
7298
case DW_FORM_ref_udata:
7299
result = cu->header.offset + DW_UNSND (attr);
7302
complaint (&symfile_complaints,
7303
"unsupported die ref attribute form: '%s'",
7304
dwarf_form_name (attr->form));
7309
/* Return the constant value held by the given attribute. Return -1
7310
if the value held by the attribute is not constant. */
7313
dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
7315
if (attr->form == DW_FORM_sdata)
7316
return DW_SND (attr);
7317
else if (attr->form == DW_FORM_udata
7318
|| attr->form == DW_FORM_data1
7319
|| attr->form == DW_FORM_data2
7320
|| attr->form == DW_FORM_data4
7321
|| attr->form == DW_FORM_data8)
7322
return DW_UNSND (attr);
7325
complaint (&symfile_complaints, "Attribute value is not a constant (%s)",
7326
dwarf_form_name (attr->form));
7327
return default_value;
7331
static struct die_info *
7332
follow_die_ref (unsigned int offset)
7334
struct die_info *die;
7337
h = (offset % REF_HASH_SIZE);
7338
die = die_ref_table[h];
7341
if (die->offset == offset)
7345
die = die->next_ref;
7350
static struct type *
7351
dwarf2_fundamental_type (struct objfile *objfile, int typeid,
7352
struct dwarf2_cu *cu)
7354
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
7356
error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7357
typeid, objfile->name);
7360
/* Look for this particular type in the fundamental type vector. If
7361
one is not found, create and install one appropriate for the
7362
current language and the current target machine. */
7364
if (cu->ftypes[typeid] == NULL)
7366
cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
7369
return (cu->ftypes[typeid]);
7372
/* Decode simple location descriptions.
7373
Given a pointer to a dwarf block that defines a location, compute
7374
the location and return the value.
7376
NOTE drow/2003-11-18: This function is called in two situations
7377
now: for the address of static or global variables (partial symbols
7378
only) and for offsets into structures which are expected to be
7379
(more or less) constant. The partial symbol case should go away,
7380
and only the constant case should remain. That will let this
7381
function complain more accurately. A few special modes are allowed
7382
without complaint for global variables (for instance, global
7383
register values and thread-local values).
7385
A location description containing no operations indicates that the
7386
object is optimized out. The return value is 0 for that case.
7387
FIXME drow/2003-11-16: No callers check for this case any more; soon all
7388
callers will only want a very basic result and this can become a
7391
When the result is a register number, the global isreg flag is set,
7392
otherwise it is cleared.
7394
Note that stack[0] is unused except as a default error return.
7395
Note that stack overflow is not yet handled. */
7398
decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
7400
struct objfile *objfile = cu->objfile;
7401
struct comp_unit_head *cu_header = &cu->header;
7403
int size = blk->size;
7404
char *data = blk->data;
7405
CORE_ADDR stack[64];
7407
unsigned int bytes_read, unsnd;
7452
stack[++stacki] = op - DW_OP_lit0;
7488
stack[++stacki] = op - DW_OP_reg0;
7490
dwarf2_complex_location_expr_complaint ();
7495
unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
7497
stack[++stacki] = unsnd;
7499
dwarf2_complex_location_expr_complaint ();
7503
stack[++stacki] = read_address (objfile->obfd, &data[i],
7509
stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
7514
stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
7519
stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
7524
stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
7529
stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
7534
stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
7539
stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
7545
stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
7550
stack[stacki + 1] = stack[stacki];
7555
stack[stacki - 1] += stack[stacki];
7559
case DW_OP_plus_uconst:
7560
stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
7565
stack[stacki - 1] -= stack[stacki];
7570
/* If we're not the last op, then we definitely can't encode
7571
this using GDB's address_class enum. This is valid for partial
7572
global symbols, although the variable's address will be bogus
7575
dwarf2_complex_location_expr_complaint ();
7578
case DW_OP_GNU_push_tls_address:
7579
/* The top of the stack has the offset from the beginning
7580
of the thread control block at which the variable is located. */
7581
/* Nothing should follow this operator, so the top of stack would
7583
/* This is valid for partial global symbols, but the variable's
7584
address will be bogus in the psymtab. */
7586
dwarf2_complex_location_expr_complaint ();
7590
complaint (&symfile_complaints, "unsupported stack op: '%s'",
7591
dwarf_stack_op_name (op));
7592
return (stack[stacki]);
7595
return (stack[stacki]);
7598
/* memory allocation interface */
7601
dwarf2_free_tmp_obstack (void *ignore)
7603
obstack_free (&dwarf2_tmp_obstack, NULL);
7606
static struct dwarf_block *
7607
dwarf_alloc_block (void)
7609
struct dwarf_block *blk;
7611
blk = (struct dwarf_block *)
7612
obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
7616
static struct abbrev_info *
7617
dwarf_alloc_abbrev (void)
7619
struct abbrev_info *abbrev;
7621
abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
7622
memset (abbrev, 0, sizeof (struct abbrev_info));
7626
static struct die_info *
7627
dwarf_alloc_die (void)
7629
struct die_info *die;
7631
die = (struct die_info *) xmalloc (sizeof (struct die_info));
7632
memset (die, 0, sizeof (struct die_info));
7637
/* Macro support. */
7640
/* Return the full name of file number I in *LH's file name table.
7641
Use COMP_DIR as the name of the current directory of the
7642
compilation. The result is allocated using xmalloc; the caller is
7643
responsible for freeing it. */
7645
file_full_name (int file, struct line_header *lh, const char *comp_dir)
7647
struct file_entry *fe = &lh->file_names[file - 1];
7649
if (IS_ABSOLUTE_PATH (fe->name))
7650
return xstrdup (fe->name);
7658
dir = lh->include_dirs[fe->dir_index - 1];
7664
dir_len = strlen (dir);
7665
full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
7666
strcpy (full_name, dir);
7667
full_name[dir_len] = '/';
7668
strcpy (full_name + dir_len + 1, fe->name);
7672
return xstrdup (fe->name);
7677
static struct macro_source_file *
7678
macro_start_file (int file, int line,
7679
struct macro_source_file *current_file,
7680
const char *comp_dir,
7681
struct line_header *lh, struct objfile *objfile)
7683
/* The full name of this source file. */
7684
char *full_name = file_full_name (file, lh, comp_dir);
7686
/* We don't create a macro table for this compilation unit
7687
at all until we actually get a filename. */
7688
if (! pending_macros)
7689
pending_macros = new_macro_table (&objfile->objfile_obstack,
7690
objfile->macro_cache);
7693
/* If we have no current file, then this must be the start_file
7694
directive for the compilation unit's main source file. */
7695
current_file = macro_set_main (pending_macros, full_name);
7697
current_file = macro_include (current_file, line, full_name);
7701
return current_file;
7705
/* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7706
followed by a null byte. */
7708
copy_string (const char *buf, int len)
7710
char *s = xmalloc (len + 1);
7711
memcpy (s, buf, len);
7719
consume_improper_spaces (const char *p, const char *body)
7723
complaint (&symfile_complaints,
7724
"macro definition contains spaces in formal argument list:\n`%s'",
7736
parse_macro_definition (struct macro_source_file *file, int line,
7741
/* The body string takes one of two forms. For object-like macro
7742
definitions, it should be:
7744
<macro name> " " <definition>
7746
For function-like macro definitions, it should be:
7748
<macro name> "() " <definition>
7750
<macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7752
Spaces may appear only where explicitly indicated, and in the
7755
The Dwarf 2 spec says that an object-like macro's name is always
7756
followed by a space, but versions of GCC around March 2002 omit
7757
the space when the macro's definition is the empty string.
7759
The Dwarf 2 spec says that there should be no spaces between the
7760
formal arguments in a function-like macro's formal argument list,
7761
but versions of GCC around March 2002 include spaces after the
7765
/* Find the extent of the macro name. The macro name is terminated
7766
by either a space or null character (for an object-like macro) or
7767
an opening paren (for a function-like macro). */
7768
for (p = body; *p; p++)
7769
if (*p == ' ' || *p == '(')
7772
if (*p == ' ' || *p == '\0')
7774
/* It's an object-like macro. */
7775
int name_len = p - body;
7776
char *name = copy_string (body, name_len);
7777
const char *replacement;
7780
replacement = body + name_len + 1;
7783
dwarf2_macro_malformed_definition_complaint (body);
7784
replacement = body + name_len;
7787
macro_define_object (file, line, name, replacement);
7793
/* It's a function-like macro. */
7794
char *name = copy_string (body, p - body);
7797
char **argv = xmalloc (argv_size * sizeof (*argv));
7801
p = consume_improper_spaces (p, body);
7803
/* Parse the formal argument list. */
7804
while (*p && *p != ')')
7806
/* Find the extent of the current argument name. */
7807
const char *arg_start = p;
7809
while (*p && *p != ',' && *p != ')' && *p != ' ')
7812
if (! *p || p == arg_start)
7813
dwarf2_macro_malformed_definition_complaint (body);
7816
/* Make sure argv has room for the new argument. */
7817
if (argc >= argv_size)
7820
argv = xrealloc (argv, argv_size * sizeof (*argv));
7823
argv[argc++] = copy_string (arg_start, p - arg_start);
7826
p = consume_improper_spaces (p, body);
7828
/* Consume the comma, if present. */
7833
p = consume_improper_spaces (p, body);
7842
/* Perfectly formed definition, no complaints. */
7843
macro_define_function (file, line, name,
7844
argc, (const char **) argv,
7846
else if (*p == '\0')
7848
/* Complain, but do define it. */
7849
dwarf2_macro_malformed_definition_complaint (body);
7850
macro_define_function (file, line, name,
7851
argc, (const char **) argv,
7855
/* Just complain. */
7856
dwarf2_macro_malformed_definition_complaint (body);
7859
/* Just complain. */
7860
dwarf2_macro_malformed_definition_complaint (body);
7866
for (i = 0; i < argc; i++)
7872
dwarf2_macro_malformed_definition_complaint (body);
7877
dwarf_decode_macros (struct line_header *lh, unsigned int offset,
7878
char *comp_dir, bfd *abfd,
7879
struct dwarf2_cu *cu)
7881
char *mac_ptr, *mac_end;
7882
struct macro_source_file *current_file = 0;
7884
if (dwarf_macinfo_buffer == NULL)
7886
complaint (&symfile_complaints, "missing .debug_macinfo section");
7890
mac_ptr = dwarf_macinfo_buffer + offset;
7891
mac_end = dwarf_macinfo_buffer + dwarf_macinfo_size;
7895
enum dwarf_macinfo_record_type macinfo_type;
7897
/* Do we at least have room for a macinfo type byte? */
7898
if (mac_ptr >= mac_end)
7900
dwarf2_macros_too_long_complaint ();
7904
macinfo_type = read_1_byte (abfd, mac_ptr);
7907
switch (macinfo_type)
7909
/* A zero macinfo type indicates the end of the macro
7914
case DW_MACINFO_define:
7915
case DW_MACINFO_undef:
7921
line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7922
mac_ptr += bytes_read;
7923
body = read_string (abfd, mac_ptr, &bytes_read);
7924
mac_ptr += bytes_read;
7927
complaint (&symfile_complaints,
7928
"debug info gives macro %s outside of any file: %s",
7930
DW_MACINFO_define ? "definition" : macinfo_type ==
7931
DW_MACINFO_undef ? "undefinition" :
7932
"something-or-other", body);
7935
if (macinfo_type == DW_MACINFO_define)
7936
parse_macro_definition (current_file, line, body);
7937
else if (macinfo_type == DW_MACINFO_undef)
7938
macro_undef (current_file, line, body);
7943
case DW_MACINFO_start_file:
7948
line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7949
mac_ptr += bytes_read;
7950
file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7951
mac_ptr += bytes_read;
7953
current_file = macro_start_file (file, line,
7954
current_file, comp_dir,
7959
case DW_MACINFO_end_file:
7961
complaint (&symfile_complaints,
7962
"macro debug info has an unmatched `close_file' directive");
7965
current_file = current_file->included_by;
7968
enum dwarf_macinfo_record_type next_type;
7970
/* GCC circa March 2002 doesn't produce the zero
7971
type byte marking the end of the compilation
7972
unit. Complain if it's not there, but exit no
7975
/* Do we at least have room for a macinfo type byte? */
7976
if (mac_ptr >= mac_end)
7978
dwarf2_macros_too_long_complaint ();
7982
/* We don't increment mac_ptr here, so this is just
7984
next_type = read_1_byte (abfd, mac_ptr);
7986
complaint (&symfile_complaints,
7987
"no terminating 0-type entry for macros in `.debug_macinfo' section");
7994
case DW_MACINFO_vendor_ext:
8000
constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
8001
mac_ptr += bytes_read;
8002
string = read_string (abfd, mac_ptr, &bytes_read);
8003
mac_ptr += bytes_read;
8005
/* We don't recognize any vendor extensions. */
8012
/* Check if the attribute's form is a DW_FORM_block*
8013
if so return true else false. */
8015
attr_form_is_block (struct attribute *attr)
8017
return (attr == NULL ? 0 :
8018
attr->form == DW_FORM_block1
8019
|| attr->form == DW_FORM_block2
8020
|| attr->form == DW_FORM_block4
8021
|| attr->form == DW_FORM_block);
8025
dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
8026
struct dwarf2_cu *cu)
8028
if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
8030
struct dwarf2_loclist_baton *baton;
8032
baton = obstack_alloc (&cu->objfile->objfile_obstack,
8033
sizeof (struct dwarf2_loclist_baton));
8034
baton->objfile = cu->objfile;
8036
/* We don't know how long the location list is, but make sure we
8037
don't run off the edge of the section. */
8038
baton->size = dwarf_loc_size - DW_UNSND (attr);
8039
baton->data = dwarf_loc_buffer + DW_UNSND (attr);
8040
baton->base_address = cu->header.base_address;
8041
if (cu->header.base_known == 0)
8042
complaint (&symfile_complaints,
8043
"Location list used without specifying the CU base address.");
8045
SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
8046
SYMBOL_LOCATION_BATON (sym) = baton;
8050
struct dwarf2_locexpr_baton *baton;
8052
baton = obstack_alloc (&cu->objfile->objfile_obstack,
8053
sizeof (struct dwarf2_locexpr_baton));
8054
baton->objfile = cu->objfile;
8056
if (attr_form_is_block (attr))
8058
/* Note that we're just copying the block's data pointer
8059
here, not the actual data. We're still pointing into the
8060
dwarf_info_buffer for SYM's objfile; right now we never
8061
release that buffer, but when we do clean up properly
8062
this may need to change. */
8063
baton->size = DW_BLOCK (attr)->size;
8064
baton->data = DW_BLOCK (attr)->data;
8068
dwarf2_invalid_attrib_class_complaint ("location description",
8069
SYMBOL_NATURAL_NAME (sym));
8074
SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
8075
SYMBOL_LOCATION_BATON (sym) = baton;