1 /* DWARF debugging format support for GDB.
3 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
6 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
7 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
27 If you are looking for DWARF-2 support, you are in the wrong file.
28 Go look in dwarf2read.c. This file is for the original DWARF,
29 also known as DWARF-1.
31 DWARF-1 is slowly headed for obsoletion.
33 In gcc 3.4.0, support for dwarf-1 has been removed.
35 In gcc 3.3.2, these targets prefer dwarf-1:
37 i[34567]86-sequent-ptx4*
38 i[34567]86-sequent-sysv4*
42 In gcc 3.2.2, these targets prefer dwarf-1:
45 i[34567]86-sequent-ptx4*
46 i[34567]86-sequent-sysv4*
51 In gcc 2.95.3, these targets prefer dwarf-1:
55 i[34567]86-sequent-ptx4*
56 i[34567]86-sequent-sysv4*
58 i[34567]86-*-sco3.2v5*
74 Some non-gcc compilers produce dwarf-1:
76 PR gdb/1179 was from a user with Diab C++ 4.3.
77 On 2003-07-25 the gdb list received a report from a user
78 with Diab Compiler 4.4b.
79 Other users have also reported using Diab compilers with dwarf-1.
81 Diab Compiler Suite 5.0.1 supports dwarf-2/dwarf-3 for C and C++.
82 (Diab(tm) Compiler Suite 5.0.1 Release Notes, DOC-14691-ZD-00,
83 Wind River Systems, 2002-07-31).
85 On 2003-06-09 the gdb list received a report from a user
86 with Absoft ProFortran f77 which is dwarf-1.
88 Absoft ProFortran Linux[sic] Fortran User Guide (no version,
89 but copyright dates are 1991-2001) says that Absoft ProFortran
90 supports -gdwarf1 and -gdwarf2.
92 -- chastain 2004-04-24
97 FIXME: Do we need to generate dependencies in partial symtabs?
98 (Perhaps we don't need to).
100 FIXME: Resolve minor differences between what information we put in the
101 partial symbol table and what dbxread puts in. For example, we don't yet
102 put enum constants there. And dbxread seems to invent a lot of typedefs
103 we never see. Use the new printpsym command to see the partial symbol table
106 FIXME: Figure out a better way to tell gdb about the name of the function
107 contain the user's entry point (I.E. main())
109 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
110 other things to work on, if you get bored. :-)
116 #include "gdbtypes.h"
117 #include "objfiles.h"
118 #include "elf/dwarf.h"
119 #include "buildsym.h"
120 #include "demangle.h"
121 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
122 #include "language.h"
123 #include "complaints.h"
126 #include "gdb_string.h"
128 /* Some macros to provide DIE info for complaints. */
130 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
131 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
133 /* Complaints that can be issued during DWARF debug info reading. */
136 bad_die_ref_complaint (int arg1
, const char *arg2
, int arg3
)
138 complaint (&symfile_complaints
,
139 _("DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit"),
144 unknown_attribute_form_complaint (int arg1
, const char *arg2
, int arg3
)
146 complaint (&symfile_complaints
,
147 _("DIE @ 0x%x \"%s\", unknown attribute form (0x%x)"), arg1
, arg2
,
152 dup_user_type_definition_complaint (int arg1
, const char *arg2
)
154 complaint (&symfile_complaints
,
155 _("DIE @ 0x%x \"%s\", internal error: duplicate user type definition"),
160 bad_array_element_type_complaint (int arg1
, const char *arg2
, int arg3
)
162 complaint (&symfile_complaints
,
163 _("DIE @ 0x%x \"%s\", bad array element type attribute 0x%x"), arg1
,
167 typedef unsigned int DIE_REF
; /* Reference to a DIE */
170 #define GCC_PRODUCER "GNU C "
173 #ifndef GPLUS_PRODUCER
174 #define GPLUS_PRODUCER "GNU C++ "
178 #define LCC_PRODUCER "NCR C/C++"
181 /* Flags to target_to_host() that tell whether or not the data object is
182 expected to be signed. Used, for example, when fetching a signed
183 integer in the target environment which is used as a signed integer
184 in the host environment, and the two environments have different sized
185 ints. In this case, *somebody* has to sign extend the smaller sized
188 #define GET_UNSIGNED 0 /* No sign extension required */
189 #define GET_SIGNED 1 /* Sign extension required */
191 /* Defines for things which are specified in the document "DWARF Debugging
192 Information Format" published by UNIX International, Programming Languages
193 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
195 #define SIZEOF_DIE_LENGTH 4
196 #define SIZEOF_DIE_TAG 2
197 #define SIZEOF_ATTRIBUTE 2
198 #define SIZEOF_FORMAT_SPECIFIER 1
199 #define SIZEOF_FMT_FT 2
200 #define SIZEOF_LINETBL_LENGTH 4
201 #define SIZEOF_LINETBL_LINENO 4
202 #define SIZEOF_LINETBL_STMT 2
203 #define SIZEOF_LINETBL_DELTA 4
204 #define SIZEOF_LOC_ATOM_CODE 1
206 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
208 /* Macros that return the sizes of various types of data in the target
211 FIXME: Currently these are just compile time constants (as they are in
212 other parts of gdb as well). They need to be able to get the right size
213 either from the bfd or possibly from the DWARF info. It would be nice if
214 the DWARF producer inserted DIES that describe the fundamental types in
215 the target environment into the DWARF info, similar to the way dbx stabs
216 producers produce information about their fundamental types. */
218 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
219 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
221 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
222 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
223 However, the Issue 2 DWARF specification from AT&T defines it as
224 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
225 For backwards compatibility with the AT&T compiler produced executables
226 we define AT_short_element_list for this variant. */
228 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
230 /* The DWARF debugging information consists of two major pieces,
231 one is a block of DWARF Information Entries (DIE's) and the other
232 is a line number table. The "struct dieinfo" structure contains
233 the information for a single DIE, the one currently being processed.
235 In order to make it easier to randomly access the attribute fields
236 of the current DIE, which are specifically unordered within the DIE,
237 each DIE is scanned and an instance of the "struct dieinfo"
238 structure is initialized.
240 Initialization is done in two levels. The first, done by basicdieinfo(),
241 just initializes those fields that are vital to deciding whether or not
242 to use this DIE, how to skip past it, etc. The second, done by the
243 function completedieinfo(), fills in the rest of the information.
245 Attributes which have block forms are not interpreted at the time
246 the DIE is scanned, instead we just save pointers to the start
247 of their value fields.
249 Some fields have a flag <name>_p that is set when the value of the
250 field is valid (I.E. we found a matching attribute in the DIE). Since
251 we may want to test for the presence of some attributes in the DIE,
252 such as AT_low_pc, without restricting the values of the field,
253 we need someway to note that we found such an attribute.
261 char *die
; /* Pointer to the raw DIE data */
262 unsigned long die_length
; /* Length of the raw DIE data */
263 DIE_REF die_ref
; /* Offset of this DIE */
264 unsigned short die_tag
; /* Tag for this DIE */
265 unsigned long at_padding
;
266 unsigned long at_sibling
;
269 unsigned short at_fund_type
;
270 BLOCK
*at_mod_fund_type
;
271 unsigned long at_user_def_type
;
272 BLOCK
*at_mod_u_d_type
;
273 unsigned short at_ordering
;
274 BLOCK
*at_subscr_data
;
275 unsigned long at_byte_size
;
276 unsigned short at_bit_offset
;
277 unsigned long at_bit_size
;
278 BLOCK
*at_element_list
;
279 unsigned long at_stmt_list
;
281 CORE_ADDR at_high_pc
;
282 unsigned long at_language
;
283 unsigned long at_member
;
284 unsigned long at_discr
;
285 BLOCK
*at_discr_value
;
286 BLOCK
*at_string_length
;
289 unsigned long at_start_scope
;
290 unsigned long at_stride_size
;
291 unsigned long at_src_info
;
293 unsigned int has_at_low_pc
:1;
294 unsigned int has_at_stmt_list
:1;
295 unsigned int has_at_byte_size
:1;
296 unsigned int short_element_list
:1;
298 /* Kludge to identify register variables */
302 /* Kludge to identify optimized out variables */
304 unsigned int optimized_out
;
306 /* Kludge to identify basereg references.
307 Nonzero if we have an offset relative to a basereg. */
311 /* Kludge to identify which base register is it relative to. */
313 unsigned int basereg
;
316 static int diecount
; /* Approximate count of dies for compilation unit */
317 static struct dieinfo
*curdie
; /* For warnings and such */
319 static char *dbbase
; /* Base pointer to dwarf info */
320 static int dbsize
; /* Size of dwarf info in bytes */
321 static int dbroff
; /* Relative offset from start of .debug section */
322 static char *lnbase
; /* Base pointer to line section */
324 /* This value is added to each symbol value. FIXME: Generalize to
325 the section_offsets structure used by dbxread (once this is done,
326 pass the appropriate section number to end_symtab). */
327 static CORE_ADDR baseaddr
; /* Add to each symbol value */
329 /* The section offsets used in the current psymtab or symtab. FIXME,
330 only used to pass one value (baseaddr) at the moment. */
331 static struct section_offsets
*base_section_offsets
;
333 /* We put a pointer to this structure in the read_symtab_private field
338 /* Always the absolute file offset to the start of the ".debug"
339 section for the file containing the DIE's being accessed. */
341 /* Relative offset from the start of the ".debug" section to the
342 first DIE to be accessed. When building the partial symbol
343 table, this value will be zero since we are accessing the
344 entire ".debug" section. When expanding a partial symbol
345 table entry, this value will be the offset to the first
346 DIE for the compilation unit containing the symbol that
347 triggers the expansion. */
349 /* The size of the chunk of DIE's being examined, in bytes. */
351 /* The absolute file offset to the line table fragment. Ignored
352 when building partial symbol tables, but used when expanding
353 them, and contains the absolute file offset to the fragment
354 of the ".line" section containing the line numbers for the
355 current compilation unit. */
359 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
360 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
361 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
362 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
364 /* The generic symbol table building routines have separate lists for
365 file scope symbols and all all other scopes (local scopes). So
366 we need to select the right one to pass to add_symbol_to_list().
367 We do it by keeping a pointer to the correct list in list_in_scope.
369 FIXME: The original dwarf code just treated the file scope as the first
370 local scope, and all other local scopes as nested local scopes, and worked
371 fine. Check to see if we really need to distinguish these in buildsym.c */
373 struct pending
**list_in_scope
= &file_symbols
;
375 /* DIES which have user defined types or modified user defined types refer to
376 other DIES for the type information. Thus we need to associate the offset
377 of a DIE for a user defined type with a pointer to the type information.
379 Originally this was done using a simple but expensive algorithm, with an
380 array of unsorted structures, each containing an offset/type-pointer pair.
381 This array was scanned linearly each time a lookup was done. The result
382 was that gdb was spending over half it's startup time munging through this
383 array of pointers looking for a structure that had the right offset member.
385 The second attempt used the same array of structures, but the array was
386 sorted using qsort each time a new offset/type was recorded, and a binary
387 search was used to find the type pointer for a given DIE offset. This was
388 even slower, due to the overhead of sorting the array each time a new
389 offset/type pair was entered.
391 The third attempt uses a fixed size array of type pointers, indexed by a
392 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
393 we can divide any DIE offset by 4 to obtain a unique index into this fixed
394 size array. Since each element is a 4 byte pointer, it takes exactly as
395 much memory to hold this array as to hold the DWARF info for a given
396 compilation unit. But it gets freed as soon as we are done with it.
397 This has worked well in practice, as a reasonable tradeoff between memory
398 consumption and speed, without having to resort to much more complicated
401 static struct type
**utypes
; /* Pointer to array of user type pointers */
402 static int numutypes
; /* Max number of user type pointers */
404 /* Maintain an array of referenced fundamental types for the current
405 compilation unit being read. For DWARF version 1, we have to construct
406 the fundamental types on the fly, since no information about the
407 fundamental types is supplied. Each such fundamental type is created by
408 calling a language dependent routine to create the type, and then a
409 pointer to that type is then placed in the array at the index specified
410 by it's FT_<TYPENAME> value. The array has a fixed size set by the
411 FT_NUM_MEMBERS compile time constant, which is the number of predefined
412 fundamental types gdb knows how to construct. */
414 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
416 /* Record the language for the compilation unit which is currently being
417 processed. We know it once we have seen the TAG_compile_unit DIE,
418 and we need it while processing the DIE's for that compilation unit.
419 It is eventually saved in the symtab structure, but we don't finalize
420 the symtab struct until we have processed all the DIE's for the
421 compilation unit. We also need to get and save a pointer to the
422 language struct for this language, so we can call the language
423 dependent routines for doing things such as creating fundamental
426 static enum language cu_language
;
427 static const struct language_defn
*cu_language_defn
;
429 /* Forward declarations of static functions so we don't have to worry
430 about ordering within this file. */
432 static void free_utypes (void *);
434 static int attribute_size (unsigned int);
436 static CORE_ADDR
target_to_host (char *, int, int, struct objfile
*);
438 static void add_enum_psymbol (struct dieinfo
*, struct objfile
*);
440 static void handle_producer (char *);
442 static void read_file_scope (struct dieinfo
*, char *, char *,
445 static void read_func_scope (struct dieinfo
*, char *, char *,
448 static void read_lexical_block_scope (struct dieinfo
*, char *, char *,
451 static void scan_partial_symbols (char *, char *, struct objfile
*);
453 static void scan_compilation_units (char *, char *, file_ptr
, file_ptr
,
456 static void add_partial_symbol (struct dieinfo
*, struct objfile
*);
458 static void basicdieinfo (struct dieinfo
*, char *, struct objfile
*);
460 static void completedieinfo (struct dieinfo
*, struct objfile
*);
462 static void dwarf_psymtab_to_symtab (struct partial_symtab
*);
464 static void psymtab_to_symtab_1 (struct partial_symtab
*);
466 static void read_ofile_symtab (struct partial_symtab
*);
468 static void process_dies (char *, char *, struct objfile
*);
470 static void read_structure_scope (struct dieinfo
*, char *, char *,
473 static struct type
*decode_array_element_type (char *);
475 static struct type
*decode_subscript_data_item (char *, char *);
477 static void dwarf_read_array_type (struct dieinfo
*);
479 static void read_tag_pointer_type (struct dieinfo
*dip
);
481 static void read_tag_string_type (struct dieinfo
*dip
);
483 static void read_subroutine_type (struct dieinfo
*, char *, char *);
485 static void read_enumeration (struct dieinfo
*, char *, char *,
488 static struct type
*struct_type (struct dieinfo
*, char *, char *,
491 static struct type
*enum_type (struct dieinfo
*, struct objfile
*);
493 static void decode_line_numbers (char *);
495 static struct type
*decode_die_type (struct dieinfo
*);
497 static struct type
*decode_mod_fund_type (char *);
499 static struct type
*decode_mod_u_d_type (char *);
501 static struct type
*decode_modified_type (char *, unsigned int, int);
503 static struct type
*decode_fund_type (unsigned int);
505 static char *create_name (char *, struct obstack
*);
507 static struct type
*lookup_utype (DIE_REF
);
509 static struct type
*alloc_utype (DIE_REF
, struct type
*);
511 static struct symbol
*new_symbol (struct dieinfo
*, struct objfile
*);
513 static void synthesize_typedef (struct dieinfo
*, struct objfile
*,
516 static int locval (struct dieinfo
*);
518 static void set_cu_language (struct dieinfo
*);
520 static struct type
*dwarf_fundamental_type (struct objfile
*, int);
527 dwarf_fundamental_type -- lookup or create a fundamental type
532 dwarf_fundamental_type (struct objfile *objfile, int typeid)
536 DWARF version 1 doesn't supply any fundamental type information,
537 so gdb has to construct such types. It has a fixed number of
538 fundamental types that it knows how to construct, which is the
539 union of all types that it knows how to construct for all languages
540 that it knows about. These are enumerated in gdbtypes.h.
542 As an example, assume we find a DIE that references a DWARF
543 fundamental type of FT_integer. We first look in the ftypes
544 array to see if we already have such a type, indexed by the
545 gdb internal value of FT_INTEGER. If so, we simply return a
546 pointer to that type. If not, then we ask an appropriate
547 language dependent routine to create a type FT_INTEGER, using
548 defaults reasonable for the current target machine, and install
549 that type in ftypes for future reference.
553 Pointer to a fundamental type.
558 dwarf_fundamental_type (struct objfile
*objfile
, int typeid)
560 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
562 error (_("internal error - invalid fundamental type id %d"), typeid);
565 /* Look for this particular type in the fundamental type vector. If one is
566 not found, create and install one appropriate for the current language
567 and the current target machine. */
569 if (ftypes
[typeid] == NULL
)
571 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
574 return (ftypes
[typeid]);
581 set_cu_language -- set local copy of language for compilation unit
586 set_cu_language (struct dieinfo *dip)
590 Decode the language attribute for a compilation unit DIE and
591 remember what the language was. We use this at various times
592 when processing DIE's for a given compilation unit.
601 set_cu_language (struct dieinfo
*dip
)
603 switch (dip
->at_language
)
607 cu_language
= language_c
;
609 case LANG_C_PLUS_PLUS
:
610 cu_language
= language_cplus
;
613 cu_language
= language_m2
;
617 cu_language
= language_fortran
;
620 cu_language
= language_pascal
;
625 /* We don't know anything special about these yet. */
626 cu_language
= language_unknown
;
629 /* If no at_language, try to deduce one from the filename */
630 cu_language
= deduce_language_from_filename (dip
->at_name
);
633 cu_language_defn
= language_def (cu_language
);
640 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
644 void dwarf_build_psymtabs (struct objfile *objfile,
645 int mainline, file_ptr dbfoff, unsigned int dbfsize,
646 file_ptr lnoffset, unsigned int lnsize)
650 This function is called upon to build partial symtabs from files
651 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
653 It is passed a bfd* containing the DIES
654 and line number information, the corresponding filename for that
655 file, a base address for relocating the symbols, a flag indicating
656 whether or not this debugging information is from a "main symbol
657 table" rather than a shared library or dynamically linked file,
658 and file offset/size pairs for the DIE information and line number
668 dwarf_build_psymtabs (struct objfile
*objfile
, int mainline
, file_ptr dbfoff
,
669 unsigned int dbfsize
, file_ptr lnoffset
,
672 bfd
*abfd
= objfile
->obfd
;
673 struct cleanup
*back_to
;
675 current_objfile
= objfile
;
677 dbbase
= xmalloc (dbsize
);
679 if ((bfd_seek (abfd
, dbfoff
, SEEK_SET
) != 0) ||
680 (bfd_bread (dbbase
, dbsize
, abfd
) != dbsize
))
683 error (_("can't read DWARF data from '%s'"), bfd_get_filename (abfd
));
685 back_to
= make_cleanup (xfree
, dbbase
);
687 /* If we are reinitializing, or if we have never loaded syms yet, init.
688 Since we have no idea how many DIES we are looking at, we just guess
689 some arbitrary value. */
692 || (objfile
->global_psymbols
.size
== 0
693 && objfile
->static_psymbols
.size
== 0))
695 init_psymbol_list (objfile
, 1024);
698 /* Save the relocation factor where everybody can see it. */
700 base_section_offsets
= objfile
->section_offsets
;
701 baseaddr
= ANOFFSET (objfile
->section_offsets
, 0);
703 /* Follow the compilation unit sibling chain, building a partial symbol
704 table entry for each one. Save enough information about each compilation
705 unit to locate the full DWARF information later. */
707 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
709 do_cleanups (back_to
);
710 current_objfile
= NULL
;
717 read_lexical_block_scope -- process all dies in a lexical block
721 static void read_lexical_block_scope (struct dieinfo *dip,
722 char *thisdie, char *enddie)
726 Process all the DIES contained within a lexical block scope.
727 Start a new scope, process the dies, and then close the scope.
732 read_lexical_block_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
733 struct objfile
*objfile
)
735 struct context_stack
*new;
737 push_context (0, dip
->at_low_pc
);
738 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
739 new = pop_context ();
740 if (local_symbols
!= NULL
)
742 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
743 dip
->at_high_pc
, objfile
);
745 local_symbols
= new->locals
;
752 lookup_utype -- look up a user defined type from die reference
756 static type *lookup_utype (DIE_REF die_ref)
760 Given a DIE reference, lookup the user defined type associated with
761 that DIE, if it has been registered already. If not registered, then
762 return NULL. Alloc_utype() can be called to register an empty
763 type for this reference, which will be filled in later when the
764 actual referenced DIE is processed.
768 lookup_utype (DIE_REF die_ref
)
770 struct type
*type
= NULL
;
773 utypeidx
= (die_ref
- dbroff
) / 4;
774 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
776 bad_die_ref_complaint (DIE_ID
, DIE_NAME
, die_ref
);
780 type
= *(utypes
+ utypeidx
);
790 alloc_utype -- add a user defined type for die reference
794 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
798 Given a die reference DIE_REF, and a possible pointer to a user
799 defined type UTYPEP, register that this reference has a user
800 defined type and either use the specified type in UTYPEP or
801 make a new empty type that will be filled in later.
803 We should only be called after calling lookup_utype() to verify that
804 there is not currently a type registered for DIE_REF.
808 alloc_utype (DIE_REF die_ref
, struct type
*utypep
)
813 utypeidx
= (die_ref
- dbroff
) / 4;
814 typep
= utypes
+ utypeidx
;
815 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
817 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
818 bad_die_ref_complaint (DIE_ID
, DIE_NAME
, die_ref
);
820 else if (*typep
!= NULL
)
823 complaint (&symfile_complaints
,
824 _("DIE @ 0x%x \"%s\", internal error: duplicate user type allocation"),
831 utypep
= alloc_type (current_objfile
);
842 free_utypes -- free the utypes array and reset pointer & count
846 static void free_utypes (void *dummy)
850 Called via do_cleanups to free the utypes array, reset the pointer to NULL,
851 and set numutypes back to zero. This ensures that the utypes does not get
852 referenced after being freed.
856 free_utypes (void *dummy
)
868 decode_die_type -- return a type for a specified die
872 static struct type *decode_die_type (struct dieinfo *dip)
876 Given a pointer to a die information structure DIP, decode the
877 type of the die and return a pointer to the decoded type. All
878 dies without specific types default to type int.
882 decode_die_type (struct dieinfo
*dip
)
884 struct type
*type
= NULL
;
886 if (dip
->at_fund_type
!= 0)
888 type
= decode_fund_type (dip
->at_fund_type
);
890 else if (dip
->at_mod_fund_type
!= NULL
)
892 type
= decode_mod_fund_type (dip
->at_mod_fund_type
);
894 else if (dip
->at_user_def_type
)
896 type
= lookup_utype (dip
->at_user_def_type
);
899 type
= alloc_utype (dip
->at_user_def_type
, NULL
);
902 else if (dip
->at_mod_u_d_type
)
904 type
= decode_mod_u_d_type (dip
->at_mod_u_d_type
);
908 type
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
917 struct_type -- compute and return the type for a struct or union
921 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
922 char *enddie, struct objfile *objfile)
926 Given pointer to a die information structure for a die which
927 defines a union or structure (and MUST define one or the other),
928 and pointers to the raw die data that define the range of dies which
929 define the members, compute and return the user defined type for the
934 struct_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
935 struct objfile
*objfile
)
940 struct nextfield
*next
;
943 struct nextfield
*list
= NULL
;
944 struct nextfield
*new;
951 type
= lookup_utype (dip
->die_ref
);
954 /* No forward references created an empty type, so install one now */
955 type
= alloc_utype (dip
->die_ref
, NULL
);
957 INIT_CPLUS_SPECIFIC (type
);
958 switch (dip
->die_tag
)
961 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
963 case TAG_structure_type
:
964 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
967 TYPE_CODE (type
) = TYPE_CODE_UNION
;
970 /* Should never happen */
971 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
972 complaint (&symfile_complaints
,
973 _("DIE @ 0x%x \"%s\", missing class, structure, or union tag"),
977 /* Some compilers try to be helpful by inventing "fake" names for
978 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
979 Thanks, but no thanks... */
980 if (dip
->at_name
!= NULL
981 && *dip
->at_name
!= '~'
982 && *dip
->at_name
!= '.')
984 TYPE_TAG_NAME (type
) = obconcat (&objfile
->objfile_obstack
,
985 "", "", dip
->at_name
);
987 /* Use whatever size is known. Zero is a valid size. We might however
988 wish to check has_at_byte_size to make sure that some byte size was
989 given explicitly, but DWARF doesn't specify that explicit sizes of
990 zero have to present, so complaining about missing sizes should
991 probably not be the default. */
992 TYPE_LENGTH (type
) = dip
->at_byte_size
;
993 thisdie
+= dip
->die_length
;
994 while (thisdie
< enddie
)
996 basicdieinfo (&mbr
, thisdie
, objfile
);
997 completedieinfo (&mbr
, objfile
);
998 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1002 else if (mbr
.at_sibling
!= 0)
1004 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1008 nextdie
= thisdie
+ mbr
.die_length
;
1010 switch (mbr
.die_tag
)
1013 /* Static fields can be either TAG_global_variable (GCC) or else
1014 TAG_member with no location (Diab). We could treat the latter like
1015 the former... but since we don't support the former, just avoid
1016 crashing on the latter for now. */
1017 if (mbr
.at_location
== NULL
)
1020 /* Get space to record the next field's data. */
1021 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1024 /* Save the data. */
1026 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1027 &objfile
->objfile_obstack
);
1028 FIELD_TYPE (list
->field
) = decode_die_type (&mbr
);
1029 FIELD_BITPOS (list
->field
) = 8 * locval (&mbr
);
1030 FIELD_STATIC_KIND (list
->field
) = 0;
1031 /* Handle bit fields. */
1032 FIELD_BITSIZE (list
->field
) = mbr
.at_bit_size
;
1033 if (BITS_BIG_ENDIAN
)
1035 /* For big endian bits, the at_bit_offset gives the
1036 additional bit offset from the MSB of the containing
1037 anonymous object to the MSB of the field. We don't
1038 have to do anything special since we don't need to
1039 know the size of the anonymous object. */
1040 FIELD_BITPOS (list
->field
) += mbr
.at_bit_offset
;
1044 /* For little endian bits, we need to have a non-zero
1045 at_bit_size, so that we know we are in fact dealing
1046 with a bitfield. Compute the bit offset to the MSB
1047 of the anonymous object, subtract off the number of
1048 bits from the MSB of the field to the MSB of the
1049 object, and then subtract off the number of bits of
1050 the field itself. The result is the bit offset of
1051 the LSB of the field. */
1052 if (mbr
.at_bit_size
> 0)
1054 if (mbr
.has_at_byte_size
)
1056 /* The size of the anonymous object containing
1057 the bit field is explicit, so use the
1058 indicated size (in bytes). */
1059 anonymous_size
= mbr
.at_byte_size
;
1063 /* The size of the anonymous object containing
1064 the bit field matches the size of an object
1065 of the bit field's type. DWARF allows
1066 at_byte_size to be left out in such cases, as
1067 a debug information size optimization. */
1068 anonymous_size
= TYPE_LENGTH (list
->field
.type
);
1070 FIELD_BITPOS (list
->field
) +=
1071 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1077 process_dies (thisdie
, nextdie
, objfile
);
1082 /* Now create the vector of fields, and record how big it is. We may
1083 not even have any fields, if this DIE was generated due to a reference
1084 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1085 set, which clues gdb in to the fact that it needs to search elsewhere
1086 for the full structure definition. */
1089 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1093 TYPE_NFIELDS (type
) = nfields
;
1094 TYPE_FIELDS (type
) = (struct field
*)
1095 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1096 /* Copy the saved-up fields into the field vector. */
1097 for (n
= nfields
; list
; list
= list
->next
)
1099 TYPE_FIELD (type
, --n
) = list
->field
;
1109 read_structure_scope -- process all dies within struct or union
1113 static void read_structure_scope (struct dieinfo *dip,
1114 char *thisdie, char *enddie, struct objfile *objfile)
1118 Called when we find the DIE that starts a structure or union
1119 scope (definition) to process all dies that define the members
1120 of the structure or union. DIP is a pointer to the die info
1121 struct for the DIE that names the structure or union.
1125 Note that we need to call struct_type regardless of whether or not
1126 the DIE has an at_name attribute, since it might be an anonymous
1127 structure or union. This gets the type entered into our set of
1130 However, if the structure is incomplete (an opaque struct/union)
1131 then suppress creating a symbol table entry for it since gdb only
1132 wants to find the one with the complete definition. Note that if
1133 it is complete, we just call new_symbol, which does it's own
1134 checking about whether the struct/union is anonymous or not (and
1135 suppresses creating a symbol table entry itself).
1140 read_structure_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1141 struct objfile
*objfile
)
1146 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1147 if (!TYPE_STUB (type
))
1149 sym
= new_symbol (dip
, objfile
);
1152 SYMBOL_TYPE (sym
) = type
;
1153 if (cu_language
== language_cplus
)
1155 synthesize_typedef (dip
, objfile
, type
);
1165 decode_array_element_type -- decode type of the array elements
1169 static struct type *decode_array_element_type (char *scan, char *end)
1173 As the last step in decoding the array subscript information for an
1174 array DIE, we need to decode the type of the array elements. We are
1175 passed a pointer to this last part of the subscript information and
1176 must return the appropriate type. If the type attribute is not
1177 recognized, just warn about the problem and return type int.
1180 static struct type
*
1181 decode_array_element_type (char *scan
)
1185 unsigned short attribute
;
1186 unsigned short fundtype
;
1189 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1191 scan
+= SIZEOF_ATTRIBUTE
;
1192 nbytes
= attribute_size (attribute
);
1195 bad_array_element_type_complaint (DIE_ID
, DIE_NAME
, attribute
);
1196 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1203 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1205 typep
= decode_fund_type (fundtype
);
1207 case AT_mod_fund_type
:
1208 typep
= decode_mod_fund_type (scan
);
1210 case AT_user_def_type
:
1211 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1213 typep
= lookup_utype (die_ref
);
1216 typep
= alloc_utype (die_ref
, NULL
);
1219 case AT_mod_u_d_type
:
1220 typep
= decode_mod_u_d_type (scan
);
1223 bad_array_element_type_complaint (DIE_ID
, DIE_NAME
, attribute
);
1224 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1235 decode_subscript_data_item -- decode array subscript item
1239 static struct type *
1240 decode_subscript_data_item (char *scan, char *end)
1244 The array subscripts and the data type of the elements of an
1245 array are described by a list of data items, stored as a block
1246 of contiguous bytes. There is a data item describing each array
1247 dimension, and a final data item describing the element type.
1248 The data items are ordered the same as their appearance in the
1249 source (I.E. leftmost dimension first, next to leftmost second,
1252 The data items describing each array dimension consist of four
1253 parts: (1) a format specifier, (2) type type of the subscript
1254 index, (3) a description of the low bound of the array dimension,
1255 and (4) a description of the high bound of the array dimension.
1257 The last data item is the description of the type of each of
1260 We are passed a pointer to the start of the block of bytes
1261 containing the remaining data items, and a pointer to the first
1262 byte past the data. This function recursively decodes the
1263 remaining data items and returns a type.
1265 If we somehow fail to decode some data, we complain about it
1266 and return a type "array of int".
1269 FIXME: This code only implements the forms currently used
1270 by the AT&T and GNU C compilers.
1272 The end pointer is supplied for error checking, maybe we should
1276 static struct type
*
1277 decode_subscript_data_item (char *scan
, char *end
)
1279 struct type
*typep
= NULL
; /* Array type we are building */
1280 struct type
*nexttype
; /* Type of each element (may be array) */
1281 struct type
*indextype
; /* Type of this index */
1282 struct type
*rangetype
;
1283 unsigned int format
;
1284 unsigned short fundtype
;
1285 unsigned long lowbound
;
1286 unsigned long highbound
;
1289 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1291 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1295 typep
= decode_array_element_type (scan
);
1298 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1300 indextype
= decode_fund_type (fundtype
);
1301 scan
+= SIZEOF_FMT_FT
;
1302 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1303 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1305 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1307 nexttype
= decode_subscript_data_item (scan
, end
);
1308 if (nexttype
== NULL
)
1310 /* Munged subscript data or other problem, fake it. */
1311 complaint (&symfile_complaints
,
1312 _("DIE @ 0x%x \"%s\", can't decode subscript data items"),
1314 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1316 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1317 lowbound
, highbound
);
1318 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1327 complaint (&symfile_complaints
,
1328 _("DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet"),
1329 DIE_ID
, DIE_NAME
, format
);
1330 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1331 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1332 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1335 complaint (&symfile_complaints
,
1336 _("DIE @ 0x%x \"%s\", unknown array subscript format %x"), DIE_ID
,
1338 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1339 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1340 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1350 dwarf_read_array_type -- read TAG_array_type DIE
1354 static void dwarf_read_array_type (struct dieinfo *dip)
1358 Extract all information from a TAG_array_type DIE and add to
1359 the user defined type vector.
1363 dwarf_read_array_type (struct dieinfo
*dip
)
1369 unsigned short blocksz
;
1372 if (dip
->at_ordering
!= ORD_row_major
)
1374 /* FIXME: Can gdb even handle column major arrays? */
1375 complaint (&symfile_complaints
,
1376 _("DIE @ 0x%x \"%s\", array not row major; not handled correctly"),
1379 sub
= dip
->at_subscr_data
;
1382 nbytes
= attribute_size (AT_subscr_data
);
1383 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1384 subend
= sub
+ nbytes
+ blocksz
;
1386 type
= decode_subscript_data_item (sub
, subend
);
1387 utype
= lookup_utype (dip
->die_ref
);
1390 /* Install user defined type that has not been referenced yet. */
1391 alloc_utype (dip
->die_ref
, type
);
1393 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1395 /* Ick! A forward ref has already generated a blank type in our
1396 slot, and this type probably already has things pointing to it
1397 (which is what caused it to be created in the first place).
1398 If it's just a place holder we can plop our fully defined type
1399 on top of it. We can't recover the space allocated for our
1400 new type since it might be on an obstack, but we could reuse
1401 it if we kept a list of them, but it might not be worth it
1407 /* Double ick! Not only is a type already in our slot, but
1408 someone has decorated it. Complain and leave it alone. */
1409 dup_user_type_definition_complaint (DIE_ID
, DIE_NAME
);
1418 read_tag_pointer_type -- read TAG_pointer_type DIE
1422 static void read_tag_pointer_type (struct dieinfo *dip)
1426 Extract all information from a TAG_pointer_type DIE and add to
1427 the user defined type vector.
1431 read_tag_pointer_type (struct dieinfo
*dip
)
1436 type
= decode_die_type (dip
);
1437 utype
= lookup_utype (dip
->die_ref
);
1440 utype
= lookup_pointer_type (type
);
1441 alloc_utype (dip
->die_ref
, utype
);
1445 TYPE_TARGET_TYPE (utype
) = type
;
1446 TYPE_POINTER_TYPE (type
) = utype
;
1448 /* We assume the machine has only one representation for pointers! */
1449 /* FIXME: Possably a poor assumption */
1450 TYPE_LENGTH (utype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
1451 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1459 read_tag_string_type -- read TAG_string_type DIE
1463 static void read_tag_string_type (struct dieinfo *dip)
1467 Extract all information from a TAG_string_type DIE and add to
1468 the user defined type vector. It isn't really a user defined
1469 type, but it behaves like one, with other DIE's using an
1470 AT_user_def_type attribute to reference it.
1474 read_tag_string_type (struct dieinfo
*dip
)
1477 struct type
*indextype
;
1478 struct type
*rangetype
;
1479 unsigned long lowbound
= 0;
1480 unsigned long highbound
;
1482 if (dip
->has_at_byte_size
)
1484 /* A fixed bounds string */
1485 highbound
= dip
->at_byte_size
- 1;
1489 /* A varying length string. Stub for now. (FIXME) */
1492 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1493 rangetype
= create_range_type ((struct type
*) NULL
, indextype
, lowbound
,
1496 utype
= lookup_utype (dip
->die_ref
);
1499 /* No type defined, go ahead and create a blank one to use. */
1500 utype
= alloc_utype (dip
->die_ref
, (struct type
*) NULL
);
1504 /* Already a type in our slot due to a forward reference. Make sure it
1505 is a blank one. If not, complain and leave it alone. */
1506 if (TYPE_CODE (utype
) != TYPE_CODE_UNDEF
)
1508 dup_user_type_definition_complaint (DIE_ID
, DIE_NAME
);
1513 /* Create the string type using the blank type we either found or created. */
1514 utype
= create_string_type (utype
, rangetype
);
1521 read_subroutine_type -- process TAG_subroutine_type dies
1525 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1530 Handle DIES due to C code like:
1533 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1539 The parameter DIES are currently ignored. See if gdb has a way to
1540 include this info in it's type system, and decode them if so. Is
1541 this what the type structure's "arg_types" field is for? (FIXME)
1545 read_subroutine_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
)
1547 struct type
*type
; /* Type that this function returns */
1548 struct type
*ftype
; /* Function that returns above type */
1550 /* Decode the type that this subroutine returns */
1552 type
= decode_die_type (dip
);
1554 /* Check to see if we already have a partially constructed user
1555 defined type for this DIE, from a forward reference. */
1557 ftype
= lookup_utype (dip
->die_ref
);
1560 /* This is the first reference to one of these types. Make
1561 a new one and place it in the user defined types. */
1562 ftype
= lookup_function_type (type
);
1563 alloc_utype (dip
->die_ref
, ftype
);
1565 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1567 /* We have an existing partially constructed type, so bash it
1568 into the correct type. */
1569 TYPE_TARGET_TYPE (ftype
) = type
;
1570 TYPE_LENGTH (ftype
) = 1;
1571 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1575 dup_user_type_definition_complaint (DIE_ID
, DIE_NAME
);
1583 read_enumeration -- process dies which define an enumeration
1587 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1588 char *enddie, struct objfile *objfile)
1592 Given a pointer to a die which begins an enumeration, process all
1593 the dies that define the members of the enumeration.
1597 Note that we need to call enum_type regardless of whether or not we
1598 have a symbol, since we might have an enum without a tag name (thus
1599 no symbol for the tagname).
1603 read_enumeration (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1604 struct objfile
*objfile
)
1609 type
= enum_type (dip
, objfile
);
1610 sym
= new_symbol (dip
, objfile
);
1613 SYMBOL_TYPE (sym
) = type
;
1614 if (cu_language
== language_cplus
)
1616 synthesize_typedef (dip
, objfile
, type
);
1625 enum_type -- decode and return a type for an enumeration
1629 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1633 Given a pointer to a die information structure for the die which
1634 starts an enumeration, process all the dies that define the members
1635 of the enumeration and return a type pointer for the enumeration.
1637 At the same time, for each member of the enumeration, create a
1638 symbol for it with domain VAR_DOMAIN and class LOC_CONST,
1639 and give it the type of the enumeration itself.
1643 Note that the DWARF specification explicitly mandates that enum
1644 constants occur in reverse order from the source program order,
1645 for "consistency" and because this ordering is easier for many
1646 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1647 Entries). Because gdb wants to see the enum members in program
1648 source order, we have to ensure that the order gets reversed while
1649 we are processing them.
1652 static struct type
*
1653 enum_type (struct dieinfo
*dip
, struct objfile
*objfile
)
1658 struct nextfield
*next
;
1661 struct nextfield
*list
= NULL
;
1662 struct nextfield
*new;
1667 unsigned short blocksz
;
1670 int unsigned_enum
= 1;
1672 type
= lookup_utype (dip
->die_ref
);
1675 /* No forward references created an empty type, so install one now */
1676 type
= alloc_utype (dip
->die_ref
, NULL
);
1678 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1679 /* Some compilers try to be helpful by inventing "fake" names for
1680 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1681 Thanks, but no thanks... */
1682 if (dip
->at_name
!= NULL
1683 && *dip
->at_name
!= '~'
1684 && *dip
->at_name
!= '.')
1686 TYPE_TAG_NAME (type
) = obconcat (&objfile
->objfile_obstack
,
1687 "", "", dip
->at_name
);
1689 if (dip
->at_byte_size
!= 0)
1691 TYPE_LENGTH (type
) = dip
->at_byte_size
;
1693 scan
= dip
->at_element_list
;
1696 if (dip
->short_element_list
)
1698 nbytes
= attribute_size (AT_short_element_list
);
1702 nbytes
= attribute_size (AT_element_list
);
1704 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1705 listend
= scan
+ nbytes
+ blocksz
;
1707 while (scan
< listend
)
1709 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1712 FIELD_TYPE (list
->field
) = NULL
;
1713 FIELD_BITSIZE (list
->field
) = 0;
1714 FIELD_STATIC_KIND (list
->field
) = 0;
1715 FIELD_BITPOS (list
->field
) =
1716 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1718 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1719 list
->field
.name
= obsavestring (scan
, strlen (scan
),
1720 &objfile
->objfile_obstack
);
1721 scan
+= strlen (scan
) + 1;
1723 /* Handcraft a new symbol for this enum member. */
1724 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
1725 sizeof (struct symbol
));
1726 memset (sym
, 0, sizeof (struct symbol
));
1727 DEPRECATED_SYMBOL_NAME (sym
) = create_name (list
->field
.name
,
1728 &objfile
->objfile_obstack
);
1729 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1730 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1731 SYMBOL_CLASS (sym
) = LOC_CONST
;
1732 SYMBOL_TYPE (sym
) = type
;
1733 SYMBOL_VALUE (sym
) = FIELD_BITPOS (list
->field
);
1734 if (SYMBOL_VALUE (sym
) < 0)
1736 add_symbol_to_list (sym
, list_in_scope
);
1738 /* Now create the vector of fields, and record how big it is. This is
1739 where we reverse the order, by pulling the members off the list in
1740 reverse order from how they were inserted. If we have no fields
1741 (this is apparently possible in C++) then skip building a field
1746 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
1747 TYPE_NFIELDS (type
) = nfields
;
1748 TYPE_FIELDS (type
) = (struct field
*)
1749 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct field
) * nfields
);
1750 /* Copy the saved-up fields into the field vector. */
1751 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
->next
)
1753 TYPE_FIELD (type
, n
++) = list
->field
;
1764 read_func_scope -- process all dies within a function scope
1768 Process all dies within a given function scope. We are passed
1769 a die information structure pointer DIP for the die which
1770 starts the function scope, and pointers into the raw die data
1771 that define the dies within the function scope.
1773 For now, we ignore lexical block scopes within the function.
1774 The problem is that AT&T cc does not define a DWARF lexical
1775 block scope for the function itself, while gcc defines a
1776 lexical block scope for the function. We need to think about
1777 how to handle this difference, or if it is even a problem.
1782 read_func_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1783 struct objfile
*objfile
)
1785 struct context_stack
*new;
1787 /* AT_name is absent if the function is described with an
1788 AT_abstract_origin tag.
1789 Ignore the function description for now to avoid GDB core dumps.
1790 FIXME: Add code to handle AT_abstract_origin tags properly. */
1791 if (dip
->at_name
== NULL
)
1793 complaint (&symfile_complaints
, _("DIE @ 0x%x, AT_name tag missing"),
1798 new = push_context (0, dip
->at_low_pc
);
1799 new->name
= new_symbol (dip
, objfile
);
1800 list_in_scope
= &local_symbols
;
1801 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1802 new = pop_context ();
1803 /* Make a block for the local symbols within. */
1804 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1805 new->start_addr
, dip
->at_high_pc
, objfile
);
1806 list_in_scope
= &file_symbols
;
1814 handle_producer -- process the AT_producer attribute
1818 Perform any operations that depend on finding a particular
1819 AT_producer attribute.
1824 handle_producer (char *producer
)
1827 /* If this compilation unit was compiled with g++ or gcc, then set the
1828 processing_gcc_compilation flag. */
1830 if (DEPRECATED_STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
)))
1832 char version
= producer
[strlen (GCC_PRODUCER
)];
1833 processing_gcc_compilation
= (version
== '2' ? 2 : 1);
1837 processing_gcc_compilation
=
1838 strncmp (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)) == 0;
1841 /* Select a demangling style if we can identify the producer and if
1842 the current style is auto. We leave the current style alone if it
1843 is not auto. We also leave the demangling style alone if we find a
1844 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1846 if (AUTO_DEMANGLING
)
1848 if (DEPRECATED_STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1851 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1852 know whether it will use the old style or v3 mangling. */
1853 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1856 else if (DEPRECATED_STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1858 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1868 read_file_scope -- process all dies within a file scope
1872 Process all dies within a given file scope. We are passed a
1873 pointer to the die information structure for the die which
1874 starts the file scope, and pointers into the raw die data which
1875 mark the range of dies within the file scope.
1877 When the partial symbol table is built, the file offset for the line
1878 number table for each compilation unit is saved in the partial symbol
1879 table entry for that compilation unit. As the symbols for each
1880 compilation unit are read, the line number table is read into memory
1881 and the variable lnbase is set to point to it. Thus all we have to
1882 do is use lnbase to access the line number table for the current
1887 read_file_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1888 struct objfile
*objfile
)
1890 struct cleanup
*back_to
;
1891 struct symtab
*symtab
;
1893 set_cu_language (dip
);
1894 if (dip
->at_producer
!= NULL
)
1896 handle_producer (dip
->at_producer
);
1898 numutypes
= (enddie
- thisdie
) / 4;
1899 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1900 back_to
= make_cleanup (free_utypes
, NULL
);
1901 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1902 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1903 start_symtab (dip
->at_name
, dip
->at_comp_dir
, dip
->at_low_pc
);
1904 record_debugformat ("DWARF 1");
1905 decode_line_numbers (lnbase
);
1906 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1908 symtab
= end_symtab (dip
->at_high_pc
, objfile
, 0);
1911 symtab
->language
= cu_language
;
1913 do_cleanups (back_to
);
1920 process_dies -- process a range of DWARF Information Entries
1924 static void process_dies (char *thisdie, char *enddie,
1925 struct objfile *objfile)
1929 Process all DIE's in a specified range. May be (and almost
1930 certainly will be) called recursively.
1934 process_dies (char *thisdie
, char *enddie
, struct objfile
*objfile
)
1939 while (thisdie
< enddie
)
1941 basicdieinfo (&di
, thisdie
, objfile
);
1942 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1946 else if (di
.die_tag
== TAG_padding
)
1948 nextdie
= thisdie
+ di
.die_length
;
1952 completedieinfo (&di
, objfile
);
1953 if (di
.at_sibling
!= 0)
1955 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1959 nextdie
= thisdie
+ di
.die_length
;
1961 /* I think that these are always text, not data, addresses. */
1962 di
.at_low_pc
= SMASH_TEXT_ADDRESS (di
.at_low_pc
);
1963 di
.at_high_pc
= SMASH_TEXT_ADDRESS (di
.at_high_pc
);
1966 case TAG_compile_unit
:
1967 /* Skip Tag_compile_unit if we are already inside a compilation
1968 unit, we are unable to handle nested compilation units
1969 properly (FIXME). */
1970 if (current_subfile
== NULL
)
1971 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1973 nextdie
= thisdie
+ di
.die_length
;
1975 case TAG_global_subroutine
:
1976 case TAG_subroutine
:
1977 if (di
.has_at_low_pc
)
1979 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1982 case TAG_lexical_block
:
1983 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1985 case TAG_class_type
:
1986 case TAG_structure_type
:
1987 case TAG_union_type
:
1988 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1990 case TAG_enumeration_type
:
1991 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1993 case TAG_subroutine_type
:
1994 read_subroutine_type (&di
, thisdie
, nextdie
);
1996 case TAG_array_type
:
1997 dwarf_read_array_type (&di
);
1999 case TAG_pointer_type
:
2000 read_tag_pointer_type (&di
);
2002 case TAG_string_type
:
2003 read_tag_string_type (&di
);
2006 new_symbol (&di
, objfile
);
2018 decode_line_numbers -- decode a line number table fragment
2022 static void decode_line_numbers (char *tblscan, char *tblend,
2023 long length, long base, long line, long pc)
2027 Translate the DWARF line number information to gdb form.
2029 The ".line" section contains one or more line number tables, one for
2030 each ".line" section from the objects that were linked.
2032 The AT_stmt_list attribute for each TAG_source_file entry in the
2033 ".debug" section contains the offset into the ".line" section for the
2034 start of the table for that file.
2036 The table itself has the following structure:
2038 <table length><base address><source statement entry>
2039 4 bytes 4 bytes 10 bytes
2041 The table length is the total size of the table, including the 4 bytes
2042 for the length information.
2044 The base address is the address of the first instruction generated
2045 for the source file.
2047 Each source statement entry has the following structure:
2049 <line number><statement position><address delta>
2050 4 bytes 2 bytes 4 bytes
2052 The line number is relative to the start of the file, starting with
2055 The statement position either -1 (0xFFFF) or the number of characters
2056 from the beginning of the line to the beginning of the statement.
2058 The address delta is the difference between the base address and
2059 the address of the first instruction for the statement.
2061 Note that we must copy the bytes from the packed table to our local
2062 variables before attempting to use them, to avoid alignment problems
2063 on some machines, particularly RISC processors.
2067 Does gdb expect the line numbers to be sorted? They are now by
2068 chance/luck, but are not required to be. (FIXME)
2070 The line with number 0 is unused, gdb apparently can discover the
2071 span of the last line some other way. How? (FIXME)
2075 decode_line_numbers (char *linetable
)
2079 unsigned long length
;
2084 if (linetable
!= NULL
)
2086 tblscan
= tblend
= linetable
;
2087 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2089 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2091 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2092 GET_UNSIGNED
, current_objfile
);
2093 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2095 while (tblscan
< tblend
)
2097 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2099 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2100 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2102 tblscan
+= SIZEOF_LINETBL_DELTA
;
2106 record_line (current_subfile
, line
, pc
);
2116 locval -- compute the value of a location attribute
2120 static int locval (struct dieinfo *dip)
2124 Given pointer to a string of bytes that define a location, compute
2125 the location and return the value.
2126 A location description containing no atoms indicates that the
2127 object is optimized out. The optimized_out flag is set for those,
2128 the return value is meaningless.
2130 When computing values involving the current value of the frame pointer,
2131 the value zero is used, which results in a value relative to the frame
2132 pointer, rather than the absolute value. This is what GDB wants
2135 When the result is a register number, the isreg flag is set, otherwise
2136 it is cleared. This is a kludge until we figure out a better
2137 way to handle the problem. Gdb's design does not mesh well with the
2138 DWARF notion of a location computing interpreter, which is a shame
2139 because the flexibility goes unused.
2143 Note that stack[0] is unused except as a default error return.
2144 Note that stack overflow is not yet handled.
2148 locval (struct dieinfo
*dip
)
2150 unsigned short nbytes
;
2151 unsigned short locsize
;
2152 auto long stack
[64];
2159 loc
= dip
->at_location
;
2160 nbytes
= attribute_size (AT_location
);
2161 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2163 end
= loc
+ locsize
;
2168 dip
->optimized_out
= 1;
2169 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2172 dip
->optimized_out
= 0;
2173 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2175 loc
+= SIZEOF_LOC_ATOM_CODE
;
2176 switch (loc_atom_code
)
2183 /* push register (number) */
2185 = DWARF_REG_TO_REGNUM (target_to_host (loc
, loc_value_size
,
2188 loc
+= loc_value_size
;
2192 /* push value of register (number) */
2193 /* Actually, we compute the value as if register has 0, so the
2194 value ends up being the offset from that register. */
2196 dip
->basereg
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2198 loc
+= loc_value_size
;
2199 stack
[++stacki
] = 0;
2202 /* push address (relocated address) */
2203 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2204 GET_UNSIGNED
, current_objfile
);
2205 loc
+= loc_value_size
;
2208 /* push constant (number) FIXME: signed or unsigned! */
2209 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2210 GET_SIGNED
, current_objfile
);
2211 loc
+= loc_value_size
;
2214 /* pop, deref and push 2 bytes (as a long) */
2215 complaint (&symfile_complaints
,
2216 _("DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled"),
2217 DIE_ID
, DIE_NAME
, stack
[stacki
]);
2219 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2220 complaint (&symfile_complaints
,
2221 _("DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled"),
2222 DIE_ID
, DIE_NAME
, stack
[stacki
]);
2224 case OP_ADD
: /* pop top 2 items, add, push result */
2225 stack
[stacki
- 1] += stack
[stacki
];
2230 return (stack
[stacki
]);
2237 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2241 static void read_ofile_symtab (struct partial_symtab *pst)
2245 When expanding a partial symbol table entry to a full symbol table
2246 entry, this is the function that gets called to read in the symbols
2247 for the compilation unit. A pointer to the newly constructed symtab,
2248 which is now the new first one on the objfile's symtab list, is
2249 stashed in the partial symbol table entry.
2253 read_ofile_symtab (struct partial_symtab
*pst
)
2255 struct cleanup
*back_to
;
2256 unsigned long lnsize
;
2259 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2261 abfd
= pst
->objfile
->obfd
;
2262 current_objfile
= pst
->objfile
;
2264 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2265 unit, seek to the location in the file, and read in all the DIE's. */
2268 dbsize
= DBLENGTH (pst
);
2269 dbbase
= xmalloc (dbsize
);
2270 dbroff
= DBROFF (pst
);
2271 foffset
= DBFOFF (pst
) + dbroff
;
2272 base_section_offsets
= pst
->section_offsets
;
2273 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2274 if (bfd_seek (abfd
, foffset
, SEEK_SET
) ||
2275 (bfd_bread (dbbase
, dbsize
, abfd
) != dbsize
))
2278 error (_("can't read DWARF data"));
2280 back_to
= make_cleanup (xfree
, dbbase
);
2282 /* If there is a line number table associated with this compilation unit
2283 then read the size of this fragment in bytes, from the fragment itself.
2284 Allocate a buffer for the fragment and read it in for future
2290 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2291 (bfd_bread (lnsizedata
, sizeof (lnsizedata
), abfd
)
2292 != sizeof (lnsizedata
)))
2294 error (_("can't read DWARF line number table size"));
2296 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2297 GET_UNSIGNED
, pst
->objfile
);
2298 lnbase
= xmalloc (lnsize
);
2299 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2300 (bfd_bread (lnbase
, lnsize
, abfd
) != lnsize
))
2303 error (_("can't read DWARF line numbers"));
2305 make_cleanup (xfree
, lnbase
);
2308 process_dies (dbbase
, dbbase
+ dbsize
, pst
->objfile
);
2309 do_cleanups (back_to
);
2310 current_objfile
= NULL
;
2311 pst
->symtab
= pst
->objfile
->symtabs
;
2318 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2322 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2326 Called once for each partial symbol table entry that needs to be
2327 expanded into a full symbol table entry.
2332 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2335 struct cleanup
*old_chain
;
2341 warning (_("psymtab for %s already read in. Shouldn't happen."),
2346 /* Read in all partial symtabs on which this one is dependent */
2347 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2349 if (!pst
->dependencies
[i
]->readin
)
2351 /* Inform about additional files that need to be read in. */
2354 /* FIXME: i18n: Need to make this a single
2356 fputs_filtered (" ", gdb_stdout
);
2358 fputs_filtered ("and ", gdb_stdout
);
2360 printf_filtered ("%s...",
2361 pst
->dependencies
[i
]->filename
);
2363 gdb_flush (gdb_stdout
); /* Flush output */
2365 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2368 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2371 old_chain
= make_cleanup (really_free_pendings
, 0);
2372 read_ofile_symtab (pst
);
2375 printf_filtered (_("%d DIE's, sorting..."), diecount
);
2377 gdb_flush (gdb_stdout
);
2379 do_cleanups (old_chain
);
2390 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2394 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2398 This is the DWARF support entry point for building a full symbol
2399 table entry from a partial symbol table entry. We are passed a
2400 pointer to the partial symbol table entry that needs to be expanded.
2405 dwarf_psymtab_to_symtab (struct partial_symtab
*pst
)
2412 warning (_("psymtab for %s already read in. Shouldn't happen."),
2417 if (DBLENGTH (pst
) || pst
->number_of_dependencies
)
2419 /* Print the message now, before starting serious work, to avoid
2420 disconcerting pauses. */
2423 printf_filtered (_("Reading in symbols for %s..."),
2425 gdb_flush (gdb_stdout
);
2428 psymtab_to_symtab_1 (pst
);
2430 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2431 we need to do an equivalent or is this something peculiar to
2433 Match with global symbols. This only needs to be done once,
2434 after all of the symtabs and dependencies have been read in.
2436 scan_file_globals (pst
->objfile
);
2439 /* Finish up the verbose info message. */
2442 printf_filtered (_("done.\n"));
2443 gdb_flush (gdb_stdout
);
2454 add_enum_psymbol -- add enumeration members to partial symbol table
2458 Given pointer to a DIE that is known to be for an enumeration,
2459 extract the symbolic names of the enumeration members and add
2460 partial symbols for them.
2464 add_enum_psymbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2468 unsigned short blocksz
;
2471 scan
= dip
->at_element_list
;
2474 if (dip
->short_element_list
)
2476 nbytes
= attribute_size (AT_short_element_list
);
2480 nbytes
= attribute_size (AT_element_list
);
2482 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2484 listend
= scan
+ blocksz
;
2485 while (scan
< listend
)
2487 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2488 add_psymbol_to_list (scan
, strlen (scan
), VAR_DOMAIN
, LOC_CONST
,
2489 &objfile
->static_psymbols
, 0, 0, cu_language
,
2491 scan
+= strlen (scan
) + 1;
2500 add_partial_symbol -- add symbol to partial symbol table
2504 Given a DIE, if it is one of the types that we want to
2505 add to a partial symbol table, finish filling in the die info
2506 and then add a partial symbol table entry for it.
2510 The caller must ensure that the DIE has a valid name attribute.
2514 add_partial_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2516 switch (dip
->die_tag
)
2518 case TAG_global_subroutine
:
2519 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2520 VAR_DOMAIN
, LOC_BLOCK
,
2521 &objfile
->global_psymbols
,
2522 0, dip
->at_low_pc
, cu_language
, objfile
);
2524 case TAG_global_variable
:
2525 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2526 VAR_DOMAIN
, LOC_STATIC
,
2527 &objfile
->global_psymbols
,
2528 0, 0, cu_language
, objfile
);
2530 case TAG_subroutine
:
2531 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2532 VAR_DOMAIN
, LOC_BLOCK
,
2533 &objfile
->static_psymbols
,
2534 0, dip
->at_low_pc
, cu_language
, objfile
);
2536 case TAG_local_variable
:
2537 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2538 VAR_DOMAIN
, LOC_STATIC
,
2539 &objfile
->static_psymbols
,
2540 0, 0, cu_language
, objfile
);
2543 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2544 VAR_DOMAIN
, LOC_TYPEDEF
,
2545 &objfile
->static_psymbols
,
2546 0, 0, cu_language
, objfile
);
2548 case TAG_class_type
:
2549 case TAG_structure_type
:
2550 case TAG_union_type
:
2551 case TAG_enumeration_type
:
2552 /* Do not add opaque aggregate definitions to the psymtab. */
2553 if (!dip
->has_at_byte_size
)
2555 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2556 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2557 &objfile
->static_psymbols
,
2558 0, 0, cu_language
, objfile
);
2559 if (cu_language
== language_cplus
)
2561 /* For C++, these implicitly act as typedefs as well. */
2562 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2563 VAR_DOMAIN
, LOC_TYPEDEF
,
2564 &objfile
->static_psymbols
,
2565 0, 0, cu_language
, objfile
);
2575 scan_partial_symbols -- scan DIE's within a single compilation unit
2579 Process the DIE's within a single compilation unit, looking for
2580 interesting DIE's that contribute to the partial symbol table entry
2581 for this compilation unit.
2585 There are some DIE's that may appear both at file scope and within
2586 the scope of a function. We are only interested in the ones at file
2587 scope, and the only way to tell them apart is to keep track of the
2588 scope. For example, consider the test case:
2593 for which the relevant DWARF segment has the structure:
2596 0x23 global subrtn sibling 0x9b
2598 fund_type FT_integer
2603 0x23 local var sibling 0x97
2605 fund_type FT_integer
2606 location OP_BASEREG 0xe
2613 0x1d local var sibling 0xb8
2615 fund_type FT_integer
2616 location OP_ADDR 0x800025dc
2621 We want to include the symbol 'i' in the partial symbol table, but
2622 not the symbol 'j'. In essence, we want to skip all the dies within
2623 the scope of a TAG_global_subroutine DIE.
2625 Don't attempt to add anonymous structures or unions since they have
2626 no name. Anonymous enumerations however are processed, because we
2627 want to extract their member names (the check for a tag name is
2630 Also, for variables and subroutines, check that this is the place
2631 where the actual definition occurs, rather than just a reference
2639 scan_partial_symbols (char *thisdie
, char *enddie
, struct objfile
*objfile
)
2645 while (thisdie
< enddie
)
2647 basicdieinfo (&di
, thisdie
, objfile
);
2648 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2654 nextdie
= thisdie
+ di
.die_length
;
2655 /* To avoid getting complete die information for every die, we
2656 only do it (below) for the cases we are interested in. */
2659 case TAG_global_subroutine
:
2660 case TAG_subroutine
:
2661 completedieinfo (&di
, objfile
);
2662 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2664 add_partial_symbol (&di
, objfile
);
2665 /* If there is a sibling attribute, adjust the nextdie
2666 pointer to skip the entire scope of the subroutine.
2667 Apply some sanity checking to make sure we don't
2668 overrun or underrun the range of remaining DIE's */
2669 if (di
.at_sibling
!= 0)
2671 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2672 if ((temp
< thisdie
) || (temp
>= enddie
))
2674 bad_die_ref_complaint (DIE_ID
, DIE_NAME
,
2684 case TAG_global_variable
:
2685 case TAG_local_variable
:
2686 completedieinfo (&di
, objfile
);
2687 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2689 add_partial_symbol (&di
, objfile
);
2693 case TAG_class_type
:
2694 case TAG_structure_type
:
2695 case TAG_union_type
:
2696 completedieinfo (&di
, objfile
);
2699 add_partial_symbol (&di
, objfile
);
2702 case TAG_enumeration_type
:
2703 completedieinfo (&di
, objfile
);
2706 add_partial_symbol (&di
, objfile
);
2708 add_enum_psymbol (&di
, objfile
);
2720 scan_compilation_units -- build a psymtab entry for each compilation
2724 This is the top level dwarf parsing routine for building partial
2727 It scans from the beginning of the DWARF table looking for the first
2728 TAG_compile_unit DIE, and then follows the sibling chain to locate
2729 each additional TAG_compile_unit DIE.
2731 For each TAG_compile_unit DIE it creates a partial symtab structure,
2732 calls a subordinate routine to collect all the compilation unit's
2733 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2734 new partial symtab structure into the partial symbol table. It also
2735 records the appropriate information in the partial symbol table entry
2736 to allow the chunk of DIE's and line number table for this compilation
2737 unit to be located and re-read later, to generate a complete symbol
2738 table entry for the compilation unit.
2740 Thus it effectively partitions up a chunk of DIE's for multiple
2741 compilation units into smaller DIE chunks and line number tables,
2742 and associates them with a partial symbol table entry.
2746 If any compilation unit has no line number table associated with
2747 it for some reason (a missing at_stmt_list attribute, rather than
2748 just one with a value of zero, which is valid) then we ensure that
2749 the recorded file offset is zero so that the routine which later
2750 reads line number table fragments knows that there is no fragment
2760 scan_compilation_units (char *thisdie
, char *enddie
, file_ptr dbfoff
,
2761 file_ptr lnoffset
, struct objfile
*objfile
)
2765 struct partial_symtab
*pst
;
2768 file_ptr curlnoffset
;
2770 while (thisdie
< enddie
)
2772 basicdieinfo (&di
, thisdie
, objfile
);
2773 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2777 else if (di
.die_tag
!= TAG_compile_unit
)
2779 nextdie
= thisdie
+ di
.die_length
;
2783 completedieinfo (&di
, objfile
);
2784 set_cu_language (&di
);
2785 if (di
.at_sibling
!= 0)
2787 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2791 nextdie
= thisdie
+ di
.die_length
;
2793 curoff
= thisdie
- dbbase
;
2794 culength
= nextdie
- thisdie
;
2795 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2797 /* First allocate a new partial symbol table structure */
2799 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2800 di
.at_name
, di
.at_low_pc
,
2801 objfile
->global_psymbols
.next
,
2802 objfile
->static_psymbols
.next
);
2804 pst
->texthigh
= di
.at_high_pc
;
2805 pst
->read_symtab_private
= (char *)
2806 obstack_alloc (&objfile
->objfile_obstack
,
2807 sizeof (struct dwfinfo
));
2808 DBFOFF (pst
) = dbfoff
;
2809 DBROFF (pst
) = curoff
;
2810 DBLENGTH (pst
) = culength
;
2811 LNFOFF (pst
) = curlnoffset
;
2812 pst
->read_symtab
= dwarf_psymtab_to_symtab
;
2814 /* Now look for partial symbols */
2816 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2818 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
2819 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2820 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
2821 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2822 sort_pst_symbols (pst
);
2823 /* If there is already a psymtab or symtab for a file of this name,
2824 remove it. (If there is a symtab, more drastic things also
2825 happen.) This happens in VxWorks. */
2826 free_named_symtabs (pst
->filename
);
2836 new_symbol -- make a symbol table entry for a new symbol
2840 static struct symbol *new_symbol (struct dieinfo *dip,
2841 struct objfile *objfile)
2845 Given a pointer to a DWARF information entry, figure out if we need
2846 to make a symbol table entry for it, and if so, create a new entry
2847 and return a pointer to it.
2850 static struct symbol
*
2851 new_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2853 struct symbol
*sym
= NULL
;
2855 if (dip
->at_name
!= NULL
)
2857 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
2858 sizeof (struct symbol
));
2859 OBJSTAT (objfile
, n_syms
++);
2860 memset (sym
, 0, sizeof (struct symbol
));
2861 /* default assumptions */
2862 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2863 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2864 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2866 /* If this symbol is from a C++ compilation, then attempt to cache the
2867 demangled form for future reference. This is a typical time versus
2868 space tradeoff, that was decided in favor of time because it sped up
2869 C++ symbol lookups by a factor of about 20. */
2871 SYMBOL_LANGUAGE (sym
) = cu_language
;
2872 SYMBOL_SET_NAMES (sym
, dip
->at_name
, strlen (dip
->at_name
), objfile
);
2873 switch (dip
->die_tag
)
2876 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2877 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2879 case TAG_global_subroutine
:
2880 case TAG_subroutine
:
2881 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2882 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2883 if (dip
->at_prototyped
)
2884 TYPE_FLAGS (SYMBOL_TYPE (sym
)) |= TYPE_FLAG_PROTOTYPED
;
2885 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2886 if (dip
->die_tag
== TAG_global_subroutine
)
2888 add_symbol_to_list (sym
, &global_symbols
);
2892 add_symbol_to_list (sym
, list_in_scope
);
2895 case TAG_global_variable
:
2896 if (dip
->at_location
!= NULL
)
2898 SYMBOL_VALUE_ADDRESS (sym
) = locval (dip
);
2899 add_symbol_to_list (sym
, &global_symbols
);
2900 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2901 SYMBOL_VALUE (sym
) += baseaddr
;
2904 case TAG_local_variable
:
2905 if (dip
->at_location
!= NULL
)
2907 int loc
= locval (dip
);
2908 if (dip
->optimized_out
)
2910 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
2912 else if (dip
->isreg
)
2914 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2916 else if (dip
->offreg
)
2918 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
2919 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2923 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2924 SYMBOL_VALUE (sym
) += baseaddr
;
2926 if (SYMBOL_CLASS (sym
) == LOC_STATIC
)
2928 /* LOC_STATIC address class MUST use SYMBOL_VALUE_ADDRESS,
2929 which may store to a bigger location than SYMBOL_VALUE. */
2930 SYMBOL_VALUE_ADDRESS (sym
) = loc
;
2934 SYMBOL_VALUE (sym
) = loc
;
2936 add_symbol_to_list (sym
, list_in_scope
);
2939 case TAG_formal_parameter
:
2940 if (dip
->at_location
!= NULL
)
2942 SYMBOL_VALUE (sym
) = locval (dip
);
2944 add_symbol_to_list (sym
, list_in_scope
);
2947 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2949 else if (dip
->offreg
)
2951 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
2952 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2956 SYMBOL_CLASS (sym
) = LOC_ARG
;
2959 case TAG_unspecified_parameters
:
2960 /* From varargs functions; gdb doesn't seem to have any interest in
2961 this information, so just ignore it for now. (FIXME?) */
2963 case TAG_class_type
:
2964 case TAG_structure_type
:
2965 case TAG_union_type
:
2966 case TAG_enumeration_type
:
2967 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2968 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
2969 add_symbol_to_list (sym
, list_in_scope
);
2972 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2973 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2974 add_symbol_to_list (sym
, list_in_scope
);
2977 /* Not a tag we recognize. Hopefully we aren't processing trash
2978 data, but since we must specifically ignore things we don't
2979 recognize, there is nothing else we should do at this point. */
2990 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2994 static void synthesize_typedef (struct dieinfo *dip,
2995 struct objfile *objfile,
3000 Given a pointer to a DWARF information entry, synthesize a typedef
3001 for the name in the DIE, using the specified type.
3003 This is used for C++ class, structs, unions, and enumerations to
3004 set up the tag name as a type.
3009 synthesize_typedef (struct dieinfo
*dip
, struct objfile
*objfile
,
3012 struct symbol
*sym
= NULL
;
3014 if (dip
->at_name
!= NULL
)
3016 sym
= (struct symbol
*)
3017 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symbol
));
3018 OBJSTAT (objfile
, n_syms
++);
3019 memset (sym
, 0, sizeof (struct symbol
));
3020 DEPRECATED_SYMBOL_NAME (sym
) = create_name (dip
->at_name
,
3021 &objfile
->objfile_obstack
);
3022 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3023 SYMBOL_TYPE (sym
) = type
;
3024 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3025 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
3026 add_symbol_to_list (sym
, list_in_scope
);
3034 decode_mod_fund_type -- decode a modified fundamental type
3038 static struct type *decode_mod_fund_type (char *typedata)
3042 Decode a block of data containing a modified fundamental
3043 type specification. TYPEDATA is a pointer to the block,
3044 which starts with a length containing the size of the rest
3045 of the block. At the end of the block is a fundmental type
3046 code value that gives the fundamental type. Everything
3047 in between are type modifiers.
3049 We simply compute the number of modifiers and call the general
3050 function decode_modified_type to do the actual work.
3053 static struct type
*
3054 decode_mod_fund_type (char *typedata
)
3056 struct type
*typep
= NULL
;
3057 unsigned short modcount
;
3060 /* Get the total size of the block, exclusive of the size itself */
3062 nbytes
= attribute_size (AT_mod_fund_type
);
3063 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3066 /* Deduct the size of the fundamental type bytes at the end of the block. */
3068 modcount
-= attribute_size (AT_fund_type
);
3070 /* Now do the actual decoding */
3072 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3080 decode_mod_u_d_type -- decode a modified user defined type
3084 static struct type *decode_mod_u_d_type (char *typedata)
3088 Decode a block of data containing a modified user defined
3089 type specification. TYPEDATA is a pointer to the block,
3090 which consists of a two byte length, containing the size
3091 of the rest of the block. At the end of the block is a
3092 four byte value that gives a reference to a user defined type.
3093 Everything in between are type modifiers.
3095 We simply compute the number of modifiers and call the general
3096 function decode_modified_type to do the actual work.
3099 static struct type
*
3100 decode_mod_u_d_type (char *typedata
)
3102 struct type
*typep
= NULL
;
3103 unsigned short modcount
;
3106 /* Get the total size of the block, exclusive of the size itself */
3108 nbytes
= attribute_size (AT_mod_u_d_type
);
3109 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3112 /* Deduct the size of the reference type bytes at the end of the block. */
3114 modcount
-= attribute_size (AT_user_def_type
);
3116 /* Now do the actual decoding */
3118 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3126 decode_modified_type -- decode modified user or fundamental type
3130 static struct type *decode_modified_type (char *modifiers,
3131 unsigned short modcount, int mtype)
3135 Decode a modified type, either a modified fundamental type or
3136 a modified user defined type. MODIFIERS is a pointer to the
3137 block of bytes that define MODCOUNT modifiers. Immediately
3138 following the last modifier is a short containing the fundamental
3139 type or a long containing the reference to the user defined
3140 type. Which one is determined by MTYPE, which is either
3141 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3142 type we are generating.
3144 We call ourself recursively to generate each modified type,`
3145 until MODCOUNT reaches zero, at which point we have consumed
3146 all the modifiers and generate either the fundamental type or
3147 user defined type. When the recursion unwinds, each modifier
3148 is applied in turn to generate the full modified type.
3152 If we find a modifier that we don't recognize, and it is not one
3153 of those reserved for application specific use, then we issue a
3154 warning and simply ignore the modifier.
3158 We currently ignore MOD_const and MOD_volatile. (FIXME)
3162 static struct type
*
3163 decode_modified_type (char *modifiers
, unsigned int modcount
, int mtype
)
3165 struct type
*typep
= NULL
;
3166 unsigned short fundtype
;
3175 case AT_mod_fund_type
:
3176 nbytes
= attribute_size (AT_fund_type
);
3177 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3179 typep
= decode_fund_type (fundtype
);
3181 case AT_mod_u_d_type
:
3182 nbytes
= attribute_size (AT_user_def_type
);
3183 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3185 typep
= lookup_utype (die_ref
);
3188 typep
= alloc_utype (die_ref
, NULL
);
3192 complaint (&symfile_complaints
,
3193 _("DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)"),
3194 DIE_ID
, DIE_NAME
, mtype
);
3195 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3201 modifier
= *modifiers
++;
3202 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3205 case MOD_pointer_to
:
3206 typep
= lookup_pointer_type (typep
);
3208 case MOD_reference_to
:
3209 typep
= lookup_reference_type (typep
);
3212 complaint (&symfile_complaints
,
3213 _("DIE @ 0x%x \"%s\", type modifier 'const' ignored"), DIE_ID
,
3214 DIE_NAME
); /* FIXME */
3217 complaint (&symfile_complaints
,
3218 _("DIE @ 0x%x \"%s\", type modifier 'volatile' ignored"),
3219 DIE_ID
, DIE_NAME
); /* FIXME */
3222 if (!(MOD_lo_user
<= (unsigned char) modifier
))
3224 /* This part of the test would always be true, and it triggers a compiler
3226 && (unsigned char) modifier
<= MOD_hi_user
))
3229 complaint (&symfile_complaints
,
3230 _("DIE @ 0x%x \"%s\", unknown type modifier %u"), DIE_ID
,
3231 DIE_NAME
, modifier
);
3243 decode_fund_type -- translate basic DWARF type to gdb base type
3247 Given an integer that is one of the fundamental DWARF types,
3248 translate it to one of the basic internal gdb types and return
3249 a pointer to the appropriate gdb type (a "struct type *").
3253 For robustness, if we are asked to translate a fundamental
3254 type that we are unprepared to deal with, we return int so
3255 callers can always depend upon a valid type being returned,
3256 and so gdb may at least do something reasonable by default.
3257 If the type is not in the range of those types defined as
3258 application specific types, we also issue a warning.
3261 static struct type
*
3262 decode_fund_type (unsigned int fundtype
)
3264 struct type
*typep
= NULL
;
3270 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3273 case FT_boolean
: /* Was FT_set in AT&T version */
3274 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3277 case FT_pointer
: /* (void *) */
3278 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3279 typep
= lookup_pointer_type (typep
);
3283 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3286 case FT_signed_char
:
3287 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3290 case FT_unsigned_char
:
3291 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3295 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3298 case FT_signed_short
:
3299 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3302 case FT_unsigned_short
:
3303 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3307 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3310 case FT_signed_integer
:
3311 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3314 case FT_unsigned_integer
:
3315 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3319 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3322 case FT_signed_long
:
3323 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3326 case FT_unsigned_long
:
3327 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3331 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3334 case FT_signed_long_long
:
3335 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3338 case FT_unsigned_long_long
:
3339 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3343 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3346 case FT_dbl_prec_float
:
3347 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3350 case FT_ext_prec_float
:
3351 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3355 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3358 case FT_dbl_prec_complex
:
3359 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3362 case FT_ext_prec_complex
:
3363 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3370 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3371 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3373 complaint (&symfile_complaints
,
3374 _("DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x"),
3375 DIE_ID
, DIE_NAME
, fundtype
);
3386 create_name -- allocate a fresh copy of a string on an obstack
3390 Given a pointer to a string and a pointer to an obstack, allocates
3391 a fresh copy of the string on the specified obstack.
3396 create_name (char *name
, struct obstack
*obstackp
)
3401 length
= strlen (name
) + 1;
3402 newname
= (char *) obstack_alloc (obstackp
, length
);
3403 strcpy (newname
, name
);
3411 basicdieinfo -- extract the minimal die info from raw die data
3415 void basicdieinfo (char *diep, struct dieinfo *dip,
3416 struct objfile *objfile)
3420 Given a pointer to raw DIE data, and a pointer to an instance of a
3421 die info structure, this function extracts the basic information
3422 from the DIE data required to continue processing this DIE, along
3423 with some bookkeeping information about the DIE.
3425 The information we absolutely must have includes the DIE tag,
3426 and the DIE length. If we need the sibling reference, then we
3427 will have to call completedieinfo() to process all the remaining
3430 Note that since there is no guarantee that the data is properly
3431 aligned in memory for the type of access required (indirection
3432 through anything other than a char pointer), and there is no
3433 guarantee that it is in the same byte order as the gdb host,
3434 we call a function which deals with both alignment and byte
3435 swapping issues. Possibly inefficient, but quite portable.
3437 We also take care of some other basic things at this point, such
3438 as ensuring that the instance of the die info structure starts
3439 out completely zero'd and that curdie is initialized for use
3440 in error reporting if we have a problem with the current die.
3444 All DIE's must have at least a valid length, thus the minimum
3445 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3446 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3447 are forced to be TAG_padding DIES.
3449 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3450 that if a padding DIE is used for alignment and the amount needed is
3451 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3452 enough to align to the next alignment boundry.
3454 We do some basic sanity checking here, such as verifying that the
3455 length of the die would not cause it to overrun the recorded end of
3456 the buffer holding the DIE info. If we find a DIE that is either
3457 too small or too large, we force it's length to zero which should
3458 cause the caller to take appropriate action.
3462 basicdieinfo (struct dieinfo
*dip
, char *diep
, struct objfile
*objfile
)
3465 memset (dip
, 0, sizeof (struct dieinfo
));
3467 dip
->die_ref
= dbroff
+ (diep
- dbbase
);
3468 dip
->die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3470 if ((dip
->die_length
< SIZEOF_DIE_LENGTH
) ||
3471 ((diep
+ dip
->die_length
) > (dbbase
+ dbsize
)))
3473 complaint (&symfile_complaints
,
3474 _("DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)"),
3475 DIE_ID
, DIE_NAME
, dip
->die_length
);
3476 dip
->die_length
= 0;
3478 else if (dip
->die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3480 dip
->die_tag
= TAG_padding
;
3484 diep
+= SIZEOF_DIE_LENGTH
;
3485 dip
->die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3494 completedieinfo -- finish reading the information for a given DIE
3498 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3502 Given a pointer to an already partially initialized die info structure,
3503 scan the raw DIE data and finish filling in the die info structure
3504 from the various attributes found.
3506 Note that since there is no guarantee that the data is properly
3507 aligned in memory for the type of access required (indirection
3508 through anything other than a char pointer), and there is no
3509 guarantee that it is in the same byte order as the gdb host,
3510 we call a function which deals with both alignment and byte
3511 swapping issues. Possibly inefficient, but quite portable.
3515 Each time we are called, we increment the diecount variable, which
3516 keeps an approximate count of the number of dies processed for
3517 each compilation unit. This information is presented to the user
3518 if the info_verbose flag is set.
3523 completedieinfo (struct dieinfo
*dip
, struct objfile
*objfile
)
3525 char *diep
; /* Current pointer into raw DIE data */
3526 char *end
; /* Terminate DIE scan here */
3527 unsigned short attr
; /* Current attribute being scanned */
3528 unsigned short form
; /* Form of the attribute */
3529 int nbytes
; /* Size of next field to read */
3533 end
= diep
+ dip
->die_length
;
3534 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3537 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3538 diep
+= SIZEOF_ATTRIBUTE
;
3539 nbytes
= attribute_size (attr
);
3542 complaint (&symfile_complaints
,
3543 _("DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes"),
3551 dip
->at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3555 dip
->at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3559 dip
->at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3563 dip
->at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3567 dip
->at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3569 dip
->has_at_stmt_list
= 1;
3572 dip
->at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3574 dip
->at_low_pc
+= baseaddr
;
3575 dip
->has_at_low_pc
= 1;
3578 dip
->at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3580 dip
->at_high_pc
+= baseaddr
;
3583 dip
->at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3586 case AT_user_def_type
:
3587 dip
->at_user_def_type
= target_to_host (diep
, nbytes
,
3588 GET_UNSIGNED
, objfile
);
3591 dip
->at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3593 dip
->has_at_byte_size
= 1;
3596 dip
->at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3600 dip
->at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3604 dip
->at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3608 dip
->at_location
= diep
;
3610 case AT_mod_fund_type
:
3611 dip
->at_mod_fund_type
= diep
;
3613 case AT_subscr_data
:
3614 dip
->at_subscr_data
= diep
;
3616 case AT_mod_u_d_type
:
3617 dip
->at_mod_u_d_type
= diep
;
3619 case AT_element_list
:
3620 dip
->at_element_list
= diep
;
3621 dip
->short_element_list
= 0;
3623 case AT_short_element_list
:
3624 dip
->at_element_list
= diep
;
3625 dip
->short_element_list
= 1;
3627 case AT_discr_value
:
3628 dip
->at_discr_value
= diep
;
3630 case AT_string_length
:
3631 dip
->at_string_length
= diep
;
3634 dip
->at_name
= diep
;
3637 /* For now, ignore any "hostname:" portion, since gdb doesn't
3638 know how to deal with it. (FIXME). */
3639 dip
->at_comp_dir
= strrchr (diep
, ':');
3640 if (dip
->at_comp_dir
!= NULL
)
3646 dip
->at_comp_dir
= diep
;
3650 dip
->at_producer
= diep
;
3652 case AT_start_scope
:
3653 dip
->at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3656 case AT_stride_size
:
3657 dip
->at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3661 dip
->at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3665 dip
->at_prototyped
= diep
;
3668 /* Found an attribute that we are unprepared to handle. However
3669 it is specifically one of the design goals of DWARF that
3670 consumers should ignore unknown attributes. As long as the
3671 form is one that we recognize (so we know how to skip it),
3672 we can just ignore the unknown attribute. */
3675 form
= FORM_FROM_ATTR (attr
);
3689 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3692 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3695 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3698 diep
+= strlen (diep
) + 1;
3701 unknown_attribute_form_complaint (DIE_ID
, DIE_NAME
, form
);
3712 target_to_host -- swap in target data to host
3716 target_to_host (char *from, int nbytes, int signextend,
3717 struct objfile *objfile)
3721 Given pointer to data in target format in FROM, a byte count for
3722 the size of the data in NBYTES, a flag indicating whether or not
3723 the data is signed in SIGNEXTEND, and a pointer to the current
3724 objfile in OBJFILE, convert the data to host format and return
3725 the converted value.
3729 FIXME: If we read data that is known to be signed, and expect to
3730 use it as signed data, then we need to explicitly sign extend the
3731 result until the bfd library is able to do this for us.
3733 FIXME: Would a 32 bit target ever need an 8 byte result?
3738 target_to_host (char *from
, int nbytes
, int signextend
, /* FIXME: Unused */
3739 struct objfile
*objfile
)
3746 rtnval
= bfd_get_64 (objfile
->obfd
, (bfd_byte
*) from
);
3749 rtnval
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) from
);
3752 rtnval
= bfd_get_16 (objfile
->obfd
, (bfd_byte
*) from
);
3755 rtnval
= bfd_get_8 (objfile
->obfd
, (bfd_byte
*) from
);
3758 complaint (&symfile_complaints
,
3759 _("DIE @ 0x%x \"%s\", no bfd support for %d byte data object"),
3760 DIE_ID
, DIE_NAME
, nbytes
);
3771 attribute_size -- compute size of data for a DWARF attribute
3775 static int attribute_size (unsigned int attr)
3779 Given a DWARF attribute in ATTR, compute the size of the first
3780 piece of data associated with this attribute and return that
3783 Returns -1 for unrecognized attributes.
3788 attribute_size (unsigned int attr
)
3790 int nbytes
; /* Size of next data for this attribute */
3791 unsigned short form
; /* Form of the attribute */
3793 form
= FORM_FROM_ATTR (attr
);
3796 case FORM_STRING
: /* A variable length field is next */
3799 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3800 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3803 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3804 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3805 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3808 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3811 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3812 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3815 unknown_attribute_form_complaint (DIE_ID
, DIE_NAME
, form
);