1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998
3 Free Software Foundation, Inc.
4 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
5 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 FIXME: Do we need to generate dependencies in partial symtabs?
26 (Perhaps we don't need to).
28 FIXME: Resolve minor differences between what information we put in the
29 partial symbol table and what dbxread puts in. For example, we don't yet
30 put enum constants there. And dbxread seems to invent a lot of typedefs
31 we never see. Use the new printpsym command to see the partial symbol table
34 FIXME: Figure out a better way to tell gdb about the name of the function
35 contain the user's entry point (I.E. main())
37 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
38 other things to work on, if you get bored. :-)
47 #include "elf/dwarf.h"
50 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
52 #include "complaints.h"
55 #include "gdb_string.h"
57 /* Some macros to provide DIE info for complaints. */
59 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
60 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
62 /* Complaints that can be issued during DWARF debug info reading. */
64 struct complaint no_bfd_get_N
=
66 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
69 struct complaint malformed_die
=
71 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
74 struct complaint bad_die_ref
=
76 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
79 struct complaint unknown_attribute_form
=
81 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
84 struct complaint unknown_attribute_length
=
86 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
89 struct complaint unexpected_fund_type
=
91 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
94 struct complaint unknown_type_modifier
=
96 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
99 struct complaint volatile_ignored
=
101 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
104 struct complaint const_ignored
=
106 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
109 struct complaint botched_modified_type
=
111 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
114 struct complaint op_deref2
=
116 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
119 struct complaint op_deref4
=
121 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
124 struct complaint basereg_not_handled
=
126 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
129 struct complaint dup_user_type_allocation
=
131 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
134 struct complaint dup_user_type_definition
=
136 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
139 struct complaint missing_tag
=
141 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
144 struct complaint bad_array_element_type
=
146 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
149 struct complaint subscript_data_items
=
151 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
154 struct complaint unhandled_array_subscript_format
=
156 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
159 struct complaint unknown_array_subscript_format
=
161 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
164 struct complaint not_row_major
=
166 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
169 struct complaint missing_at_name
=
171 "DIE @ 0x%x, AT_name tag missing", 0, 0
174 typedef unsigned int DIE_REF
; /* Reference to a DIE */
177 #define GCC_PRODUCER "GNU C "
180 #ifndef GPLUS_PRODUCER
181 #define GPLUS_PRODUCER "GNU C++ "
185 #define LCC_PRODUCER "NCR C/C++"
188 #ifndef CHILL_PRODUCER
189 #define CHILL_PRODUCER "GNU Chill "
192 /* Flags to target_to_host() that tell whether or not the data object is
193 expected to be signed. Used, for example, when fetching a signed
194 integer in the target environment which is used as a signed integer
195 in the host environment, and the two environments have different sized
196 ints. In this case, *somebody* has to sign extend the smaller sized
199 #define GET_UNSIGNED 0 /* No sign extension required */
200 #define GET_SIGNED 1 /* Sign extension required */
202 /* Defines for things which are specified in the document "DWARF Debugging
203 Information Format" published by UNIX International, Programming Languages
204 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
206 #define SIZEOF_DIE_LENGTH 4
207 #define SIZEOF_DIE_TAG 2
208 #define SIZEOF_ATTRIBUTE 2
209 #define SIZEOF_FORMAT_SPECIFIER 1
210 #define SIZEOF_FMT_FT 2
211 #define SIZEOF_LINETBL_LENGTH 4
212 #define SIZEOF_LINETBL_LINENO 4
213 #define SIZEOF_LINETBL_STMT 2
214 #define SIZEOF_LINETBL_DELTA 4
215 #define SIZEOF_LOC_ATOM_CODE 1
217 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
219 /* Macros that return the sizes of various types of data in the target
222 FIXME: Currently these are just compile time constants (as they are in
223 other parts of gdb as well). They need to be able to get the right size
224 either from the bfd or possibly from the DWARF info. It would be nice if
225 the DWARF producer inserted DIES that describe the fundamental types in
226 the target environment into the DWARF info, similar to the way dbx stabs
227 producers produce information about their fundamental types. */
229 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
230 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
232 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
233 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
234 However, the Issue 2 DWARF specification from AT&T defines it as
235 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
236 For backwards compatibility with the AT&T compiler produced executables
237 we define AT_short_element_list for this variant. */
239 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
241 /* External variables referenced. */
243 extern int info_verbose
; /* From main.c; nonzero => verbose */
244 extern char *warning_pre_print
; /* From utils.c */
246 /* The DWARF debugging information consists of two major pieces,
247 one is a block of DWARF Information Entries (DIE's) and the other
248 is a line number table. The "struct dieinfo" structure contains
249 the information for a single DIE, the one currently being processed.
251 In order to make it easier to randomly access the attribute fields
252 of the current DIE, which are specifically unordered within the DIE,
253 each DIE is scanned and an instance of the "struct dieinfo"
254 structure is initialized.
256 Initialization is done in two levels. The first, done by basicdieinfo(),
257 just initializes those fields that are vital to deciding whether or not
258 to use this DIE, how to skip past it, etc. The second, done by the
259 function completedieinfo(), fills in the rest of the information.
261 Attributes which have block forms are not interpreted at the time
262 the DIE is scanned, instead we just save pointers to the start
263 of their value fields.
265 Some fields have a flag <name>_p that is set when the value of the
266 field is valid (I.E. we found a matching attribute in the DIE). Since
267 we may want to test for the presence of some attributes in the DIE,
268 such as AT_low_pc, without restricting the values of the field,
269 we need someway to note that we found such an attribute.
277 char *die
; /* Pointer to the raw DIE data */
278 unsigned long die_length
; /* Length of the raw DIE data */
279 DIE_REF die_ref
; /* Offset of this DIE */
280 unsigned short die_tag
; /* Tag for this DIE */
281 unsigned long at_padding
;
282 unsigned long at_sibling
;
285 unsigned short at_fund_type
;
286 BLOCK
*at_mod_fund_type
;
287 unsigned long at_user_def_type
;
288 BLOCK
*at_mod_u_d_type
;
289 unsigned short at_ordering
;
290 BLOCK
*at_subscr_data
;
291 unsigned long at_byte_size
;
292 unsigned short at_bit_offset
;
293 unsigned long at_bit_size
;
294 BLOCK
*at_element_list
;
295 unsigned long at_stmt_list
;
297 CORE_ADDR at_high_pc
;
298 unsigned long at_language
;
299 unsigned long at_member
;
300 unsigned long at_discr
;
301 BLOCK
*at_discr_value
;
302 BLOCK
*at_string_length
;
305 unsigned long at_start_scope
;
306 unsigned long at_stride_size
;
307 unsigned long at_src_info
;
309 unsigned int has_at_low_pc
:1;
310 unsigned int has_at_stmt_list
:1;
311 unsigned int has_at_byte_size
:1;
312 unsigned int short_element_list
:1;
314 /* Kludge to identify register variables */
318 /* Kludge to identify optimized out variables */
320 unsigned int optimized_out
;
322 /* Kludge to identify basereg references.
323 Nonzero if we have an offset relative to a basereg. */
327 /* Kludge to identify which base register is it relative to. */
329 unsigned int basereg
;
332 static int diecount
; /* Approximate count of dies for compilation unit */
333 static struct dieinfo
*curdie
; /* For warnings and such */
335 static char *dbbase
; /* Base pointer to dwarf info */
336 static int dbsize
; /* Size of dwarf info in bytes */
337 static int dbroff
; /* Relative offset from start of .debug section */
338 static char *lnbase
; /* Base pointer to line section */
340 /* This value is added to each symbol value. FIXME: Generalize to
341 the section_offsets structure used by dbxread (once this is done,
342 pass the appropriate section number to end_symtab). */
343 static CORE_ADDR baseaddr
; /* Add to each symbol value */
345 /* The section offsets used in the current psymtab or symtab. FIXME,
346 only used to pass one value (baseaddr) at the moment. */
347 static struct section_offsets
*base_section_offsets
;
349 /* We put a pointer to this structure in the read_symtab_private field
354 /* Always the absolute file offset to the start of the ".debug"
355 section for the file containing the DIE's being accessed. */
357 /* Relative offset from the start of the ".debug" section to the
358 first DIE to be accessed. When building the partial symbol
359 table, this value will be zero since we are accessing the
360 entire ".debug" section. When expanding a partial symbol
361 table entry, this value will be the offset to the first
362 DIE for the compilation unit containing the symbol that
363 triggers the expansion. */
365 /* The size of the chunk of DIE's being examined, in bytes. */
367 /* The absolute file offset to the line table fragment. Ignored
368 when building partial symbol tables, but used when expanding
369 them, and contains the absolute file offset to the fragment
370 of the ".line" section containing the line numbers for the
371 current compilation unit. */
375 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
376 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
377 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
378 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
380 /* The generic symbol table building routines have separate lists for
381 file scope symbols and all all other scopes (local scopes). So
382 we need to select the right one to pass to add_symbol_to_list().
383 We do it by keeping a pointer to the correct list in list_in_scope.
385 FIXME: The original dwarf code just treated the file scope as the first
386 local scope, and all other local scopes as nested local scopes, and worked
387 fine. Check to see if we really need to distinguish these in buildsym.c */
389 struct pending
**list_in_scope
= &file_symbols
;
391 /* DIES which have user defined types or modified user defined types refer to
392 other DIES for the type information. Thus we need to associate the offset
393 of a DIE for a user defined type with a pointer to the type information.
395 Originally this was done using a simple but expensive algorithm, with an
396 array of unsorted structures, each containing an offset/type-pointer pair.
397 This array was scanned linearly each time a lookup was done. The result
398 was that gdb was spending over half it's startup time munging through this
399 array of pointers looking for a structure that had the right offset member.
401 The second attempt used the same array of structures, but the array was
402 sorted using qsort each time a new offset/type was recorded, and a binary
403 search was used to find the type pointer for a given DIE offset. This was
404 even slower, due to the overhead of sorting the array each time a new
405 offset/type pair was entered.
407 The third attempt uses a fixed size array of type pointers, indexed by a
408 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
409 we can divide any DIE offset by 4 to obtain a unique index into this fixed
410 size array. Since each element is a 4 byte pointer, it takes exactly as
411 much memory to hold this array as to hold the DWARF info for a given
412 compilation unit. But it gets freed as soon as we are done with it.
413 This has worked well in practice, as a reasonable tradeoff between memory
414 consumption and speed, without having to resort to much more complicated
417 static struct type
**utypes
; /* Pointer to array of user type pointers */
418 static int numutypes
; /* Max number of user type pointers */
420 /* Maintain an array of referenced fundamental types for the current
421 compilation unit being read. For DWARF version 1, we have to construct
422 the fundamental types on the fly, since no information about the
423 fundamental types is supplied. Each such fundamental type is created by
424 calling a language dependent routine to create the type, and then a
425 pointer to that type is then placed in the array at the index specified
426 by it's FT_<TYPENAME> value. The array has a fixed size set by the
427 FT_NUM_MEMBERS compile time constant, which is the number of predefined
428 fundamental types gdb knows how to construct. */
430 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
432 /* Record the language for the compilation unit which is currently being
433 processed. We know it once we have seen the TAG_compile_unit DIE,
434 and we need it while processing the DIE's for that compilation unit.
435 It is eventually saved in the symtab structure, but we don't finalize
436 the symtab struct until we have processed all the DIE's for the
437 compilation unit. We also need to get and save a pointer to the
438 language struct for this language, so we can call the language
439 dependent routines for doing things such as creating fundamental
442 static enum language cu_language
;
443 static const struct language_defn
*cu_language_defn
;
445 /* Forward declarations of static functions so we don't have to worry
446 about ordering within this file. */
448 static void free_utypes (PTR
);
450 static int attribute_size (unsigned int);
452 static CORE_ADDR
target_to_host (char *, int, int, struct objfile
*);
454 static void add_enum_psymbol (struct dieinfo
*, struct objfile
*);
456 static void handle_producer (char *);
459 read_file_scope (struct dieinfo
*, char *, char *, struct objfile
*);
462 read_func_scope (struct dieinfo
*, char *, char *, struct objfile
*);
465 read_lexical_block_scope (struct dieinfo
*, char *, char *, struct objfile
*);
467 static void scan_partial_symbols (char *, char *, struct objfile
*);
470 scan_compilation_units (char *, char *, file_ptr
, file_ptr
, struct objfile
*);
472 static void add_partial_symbol (struct dieinfo
*, struct objfile
*);
474 static void basicdieinfo (struct dieinfo
*, char *, struct objfile
*);
476 static void completedieinfo (struct dieinfo
*, struct objfile
*);
478 static void dwarf_psymtab_to_symtab (struct partial_symtab
*);
480 static void psymtab_to_symtab_1 (struct partial_symtab
*);
482 static void read_ofile_symtab (struct partial_symtab
*);
484 static void process_dies (char *, char *, struct objfile
*);
487 read_structure_scope (struct dieinfo
*, char *, char *, struct objfile
*);
489 static struct type
*decode_array_element_type (char *);
491 static struct type
*decode_subscript_data_item (char *, char *);
493 static void dwarf_read_array_type (struct dieinfo
*);
495 static void read_tag_pointer_type (struct dieinfo
*dip
);
497 static void read_tag_string_type (struct dieinfo
*dip
);
499 static void read_subroutine_type (struct dieinfo
*, char *, char *);
502 read_enumeration (struct dieinfo
*, char *, char *, struct objfile
*);
504 static struct type
*struct_type (struct dieinfo
*, char *, char *,
507 static struct type
*enum_type (struct dieinfo
*, struct objfile
*);
509 static void decode_line_numbers (char *);
511 static struct type
*decode_die_type (struct dieinfo
*);
513 static struct type
*decode_mod_fund_type (char *);
515 static struct type
*decode_mod_u_d_type (char *);
517 static struct type
*decode_modified_type (char *, unsigned int, int);
519 static struct type
*decode_fund_type (unsigned int);
521 static char *create_name (char *, struct obstack
*);
523 static struct type
*lookup_utype (DIE_REF
);
525 static struct type
*alloc_utype (DIE_REF
, struct type
*);
527 static struct symbol
*new_symbol (struct dieinfo
*, struct objfile
*);
530 synthesize_typedef (struct dieinfo
*, struct objfile
*, struct type
*);
532 static int locval (struct dieinfo
*);
534 static void set_cu_language (struct dieinfo
*);
536 static struct type
*dwarf_fundamental_type (struct objfile
*, int);
543 dwarf_fundamental_type -- lookup or create a fundamental type
548 dwarf_fundamental_type (struct objfile *objfile, int typeid)
552 DWARF version 1 doesn't supply any fundamental type information,
553 so gdb has to construct such types. It has a fixed number of
554 fundamental types that it knows how to construct, which is the
555 union of all types that it knows how to construct for all languages
556 that it knows about. These are enumerated in gdbtypes.h.
558 As an example, assume we find a DIE that references a DWARF
559 fundamental type of FT_integer. We first look in the ftypes
560 array to see if we already have such a type, indexed by the
561 gdb internal value of FT_INTEGER. If so, we simply return a
562 pointer to that type. If not, then we ask an appropriate
563 language dependent routine to create a type FT_INTEGER, using
564 defaults reasonable for the current target machine, and install
565 that type in ftypes for future reference.
569 Pointer to a fundamental type.
574 dwarf_fundamental_type (struct objfile
*objfile
, int typeid)
576 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
578 error ("internal error - invalid fundamental type id %d", typeid);
581 /* Look for this particular type in the fundamental type vector. If one is
582 not found, create and install one appropriate for the current language
583 and the current target machine. */
585 if (ftypes
[typeid] == NULL
)
587 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
590 return (ftypes
[typeid]);
597 set_cu_language -- set local copy of language for compilation unit
602 set_cu_language (struct dieinfo *dip)
606 Decode the language attribute for a compilation unit DIE and
607 remember what the language was. We use this at various times
608 when processing DIE's for a given compilation unit.
617 set_cu_language (struct dieinfo
*dip
)
619 switch (dip
->at_language
)
623 cu_language
= language_c
;
625 case LANG_C_PLUS_PLUS
:
626 cu_language
= language_cplus
;
629 cu_language
= language_chill
;
632 cu_language
= language_m2
;
636 cu_language
= language_fortran
;
642 /* We don't know anything special about these yet. */
643 cu_language
= language_unknown
;
646 /* If no at_language, try to deduce one from the filename */
647 cu_language
= deduce_language_from_filename (dip
->at_name
);
650 cu_language_defn
= language_def (cu_language
);
657 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
661 void dwarf_build_psymtabs (struct objfile *objfile,
662 int mainline, file_ptr dbfoff, unsigned int dbfsize,
663 file_ptr lnoffset, unsigned int lnsize)
667 This function is called upon to build partial symtabs from files
668 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
670 It is passed a bfd* containing the DIES
671 and line number information, the corresponding filename for that
672 file, a base address for relocating the symbols, a flag indicating
673 whether or not this debugging information is from a "main symbol
674 table" rather than a shared library or dynamically linked file,
675 and file offset/size pairs for the DIE information and line number
685 dwarf_build_psymtabs (struct objfile
*objfile
, int mainline
, file_ptr dbfoff
,
686 unsigned int dbfsize
, file_ptr lnoffset
,
689 bfd
*abfd
= objfile
->obfd
;
690 struct cleanup
*back_to
;
692 current_objfile
= objfile
;
694 dbbase
= xmalloc (dbsize
);
696 if ((bfd_seek (abfd
, dbfoff
, SEEK_SET
) != 0) ||
697 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
700 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
702 back_to
= make_cleanup (xfree
, dbbase
);
704 /* If we are reinitializing, or if we have never loaded syms yet, init.
705 Since we have no idea how many DIES we are looking at, we just guess
706 some arbitrary value. */
708 if (mainline
|| objfile
->global_psymbols
.size
== 0 ||
709 objfile
->static_psymbols
.size
== 0)
711 init_psymbol_list (objfile
, 1024);
714 /* Save the relocation factor where everybody can see it. */
716 base_section_offsets
= objfile
->section_offsets
;
717 baseaddr
= ANOFFSET (objfile
->section_offsets
, 0);
719 /* Follow the compilation unit sibling chain, building a partial symbol
720 table entry for each one. Save enough information about each compilation
721 unit to locate the full DWARF information later. */
723 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
725 do_cleanups (back_to
);
726 current_objfile
= NULL
;
733 read_lexical_block_scope -- process all dies in a lexical block
737 static void read_lexical_block_scope (struct dieinfo *dip,
738 char *thisdie, char *enddie)
742 Process all the DIES contained within a lexical block scope.
743 Start a new scope, process the dies, and then close the scope.
748 read_lexical_block_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
749 struct objfile
*objfile
)
751 register struct context_stack
*new;
753 push_context (0, dip
->at_low_pc
);
754 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
755 new = pop_context ();
756 if (local_symbols
!= NULL
)
758 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
759 dip
->at_high_pc
, objfile
);
761 local_symbols
= new->locals
;
768 lookup_utype -- look up a user defined type from die reference
772 static type *lookup_utype (DIE_REF die_ref)
776 Given a DIE reference, lookup the user defined type associated with
777 that DIE, if it has been registered already. If not registered, then
778 return NULL. Alloc_utype() can be called to register an empty
779 type for this reference, which will be filled in later when the
780 actual referenced DIE is processed.
784 lookup_utype (DIE_REF die_ref
)
786 struct type
*type
= NULL
;
789 utypeidx
= (die_ref
- dbroff
) / 4;
790 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
792 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
796 type
= *(utypes
+ utypeidx
);
806 alloc_utype -- add a user defined type for die reference
810 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
814 Given a die reference DIE_REF, and a possible pointer to a user
815 defined type UTYPEP, register that this reference has a user
816 defined type and either use the specified type in UTYPEP or
817 make a new empty type that will be filled in later.
819 We should only be called after calling lookup_utype() to verify that
820 there is not currently a type registered for DIE_REF.
824 alloc_utype (DIE_REF die_ref
, struct type
*utypep
)
829 utypeidx
= (die_ref
- dbroff
) / 4;
830 typep
= utypes
+ utypeidx
;
831 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
833 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
834 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
836 else if (*typep
!= NULL
)
839 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
845 utypep
= alloc_type (current_objfile
);
856 free_utypes -- free the utypes array and reset pointer & count
860 static void free_utypes (PTR dummy)
864 Called via do_cleanups to free the utypes array, reset the pointer to NULL,
865 and set numutypes back to zero. This ensures that the utypes does not get
866 referenced after being freed.
870 free_utypes (PTR dummy
)
882 decode_die_type -- return a type for a specified die
886 static struct type *decode_die_type (struct dieinfo *dip)
890 Given a pointer to a die information structure DIP, decode the
891 type of the die and return a pointer to the decoded type. All
892 dies without specific types default to type int.
896 decode_die_type (struct dieinfo
*dip
)
898 struct type
*type
= NULL
;
900 if (dip
->at_fund_type
!= 0)
902 type
= decode_fund_type (dip
->at_fund_type
);
904 else if (dip
->at_mod_fund_type
!= NULL
)
906 type
= decode_mod_fund_type (dip
->at_mod_fund_type
);
908 else if (dip
->at_user_def_type
)
910 if ((type
= lookup_utype (dip
->at_user_def_type
)) == NULL
)
912 type
= alloc_utype (dip
->at_user_def_type
, NULL
);
915 else if (dip
->at_mod_u_d_type
)
917 type
= decode_mod_u_d_type (dip
->at_mod_u_d_type
);
921 type
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
930 struct_type -- compute and return the type for a struct or union
934 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
935 char *enddie, struct objfile *objfile)
939 Given pointer to a die information structure for a die which
940 defines a union or structure (and MUST define one or the other),
941 and pointers to the raw die data that define the range of dies which
942 define the members, compute and return the user defined type for the
947 struct_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
948 struct objfile
*objfile
)
953 struct nextfield
*next
;
956 struct nextfield
*list
= NULL
;
957 struct nextfield
*new;
964 if ((type
= lookup_utype (dip
->die_ref
)) == NULL
)
966 /* No forward references created an empty type, so install one now */
967 type
= alloc_utype (dip
->die_ref
, NULL
);
969 INIT_CPLUS_SPECIFIC (type
);
970 switch (dip
->die_tag
)
973 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
975 case TAG_structure_type
:
976 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
979 TYPE_CODE (type
) = TYPE_CODE_UNION
;
982 /* Should never happen */
983 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
984 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
987 /* Some compilers try to be helpful by inventing "fake" names for
988 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
989 Thanks, but no thanks... */
990 if (dip
->at_name
!= NULL
991 && *dip
->at_name
!= '~'
992 && *dip
->at_name
!= '.')
994 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
995 "", "", dip
->at_name
);
997 /* Use whatever size is known. Zero is a valid size. We might however
998 wish to check has_at_byte_size to make sure that some byte size was
999 given explicitly, but DWARF doesn't specify that explicit sizes of
1000 zero have to present, so complaining about missing sizes should
1001 probably not be the default. */
1002 TYPE_LENGTH (type
) = dip
->at_byte_size
;
1003 thisdie
+= dip
->die_length
;
1004 while (thisdie
< enddie
)
1006 basicdieinfo (&mbr
, thisdie
, objfile
);
1007 completedieinfo (&mbr
, objfile
);
1008 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1012 else if (mbr
.at_sibling
!= 0)
1014 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1018 nextdie
= thisdie
+ mbr
.die_length
;
1020 switch (mbr
.die_tag
)
1023 /* Get space to record the next field's data. */
1024 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1027 /* Save the data. */
1029 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1030 &objfile
->type_obstack
);
1031 FIELD_TYPE (list
->field
) = decode_die_type (&mbr
);
1032 FIELD_BITPOS (list
->field
) = 8 * locval (&mbr
);
1033 /* Handle bit fields. */
1034 FIELD_BITSIZE (list
->field
) = mbr
.at_bit_size
;
1035 if (BITS_BIG_ENDIAN
)
1037 /* For big endian bits, the at_bit_offset gives the
1038 additional bit offset from the MSB of the containing
1039 anonymous object to the MSB of the field. We don't
1040 have to do anything special since we don't need to
1041 know the size of the anonymous object. */
1042 FIELD_BITPOS (list
->field
) += mbr
.at_bit_offset
;
1046 /* For little endian bits, we need to have a non-zero
1047 at_bit_size, so that we know we are in fact dealing
1048 with a bitfield. Compute the bit offset to the MSB
1049 of the anonymous object, subtract off the number of
1050 bits from the MSB of the field to the MSB of the
1051 object, and then subtract off the number of bits of
1052 the field itself. The result is the bit offset of
1053 the LSB of the field. */
1054 if (mbr
.at_bit_size
> 0)
1056 if (mbr
.has_at_byte_size
)
1058 /* The size of the anonymous object containing
1059 the bit field is explicit, so use the
1060 indicated size (in bytes). */
1061 anonymous_size
= mbr
.at_byte_size
;
1065 /* The size of the anonymous object containing
1066 the bit field matches the size of an object
1067 of the bit field's type. DWARF allows
1068 at_byte_size to be left out in such cases, as
1069 a debug information size optimization. */
1070 anonymous_size
= TYPE_LENGTH (list
->field
.type
);
1072 FIELD_BITPOS (list
->field
) +=
1073 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1079 process_dies (thisdie
, nextdie
, objfile
);
1084 /* Now create the vector of fields, and record how big it is. We may
1085 not even have any fields, if this DIE was generated due to a reference
1086 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1087 set, which clues gdb in to the fact that it needs to search elsewhere
1088 for the full structure definition. */
1091 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1095 TYPE_NFIELDS (type
) = nfields
;
1096 TYPE_FIELDS (type
) = (struct field
*)
1097 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1098 /* Copy the saved-up fields into the field vector. */
1099 for (n
= nfields
; list
; list
= list
->next
)
1101 TYPE_FIELD (type
, --n
) = list
->field
;
1111 read_structure_scope -- process all dies within struct or union
1115 static void read_structure_scope (struct dieinfo *dip,
1116 char *thisdie, char *enddie, struct objfile *objfile)
1120 Called when we find the DIE that starts a structure or union
1121 scope (definition) to process all dies that define the members
1122 of the structure or union. DIP is a pointer to the die info
1123 struct for the DIE that names the structure or union.
1127 Note that we need to call struct_type regardless of whether or not
1128 the DIE has an at_name attribute, since it might be an anonymous
1129 structure or union. This gets the type entered into our set of
1132 However, if the structure is incomplete (an opaque struct/union)
1133 then suppress creating a symbol table entry for it since gdb only
1134 wants to find the one with the complete definition. Note that if
1135 it is complete, we just call new_symbol, which does it's own
1136 checking about whether the struct/union is anonymous or not (and
1137 suppresses creating a symbol table entry itself).
1142 read_structure_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1143 struct objfile
*objfile
)
1148 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1149 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1151 sym
= new_symbol (dip
, objfile
);
1154 SYMBOL_TYPE (sym
) = type
;
1155 if (cu_language
== language_cplus
)
1157 synthesize_typedef (dip
, objfile
, type
);
1167 decode_array_element_type -- decode type of the array elements
1171 static struct type *decode_array_element_type (char *scan, char *end)
1175 As the last step in decoding the array subscript information for an
1176 array DIE, we need to decode the type of the array elements. We are
1177 passed a pointer to this last part of the subscript information and
1178 must return the appropriate type. If the type attribute is not
1179 recognized, just warn about the problem and return type int.
1182 static struct type
*
1183 decode_array_element_type (char *scan
)
1187 unsigned short attribute
;
1188 unsigned short fundtype
;
1191 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1193 scan
+= SIZEOF_ATTRIBUTE
;
1194 if ((nbytes
= attribute_size (attribute
)) == -1)
1196 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1197 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1204 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1206 typep
= decode_fund_type (fundtype
);
1208 case AT_mod_fund_type
:
1209 typep
= decode_mod_fund_type (scan
);
1211 case AT_user_def_type
:
1212 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1214 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1216 typep
= alloc_utype (die_ref
, NULL
);
1219 case AT_mod_u_d_type
:
1220 typep
= decode_mod_u_d_type (scan
);
1223 complain (&bad_array_element_type
, 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 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1312 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1314 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1315 lowbound
, highbound
);
1316 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1325 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1326 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1327 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1328 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1331 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1332 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1333 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1334 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1344 dwarf_read_array_type -- read TAG_array_type DIE
1348 static void dwarf_read_array_type (struct dieinfo *dip)
1352 Extract all information from a TAG_array_type DIE and add to
1353 the user defined type vector.
1357 dwarf_read_array_type (struct dieinfo
*dip
)
1363 unsigned short blocksz
;
1366 if (dip
->at_ordering
!= ORD_row_major
)
1368 /* FIXME: Can gdb even handle column major arrays? */
1369 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1371 if ((sub
= dip
->at_subscr_data
) != NULL
)
1373 nbytes
= attribute_size (AT_subscr_data
);
1374 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1375 subend
= sub
+ nbytes
+ blocksz
;
1377 type
= decode_subscript_data_item (sub
, subend
);
1378 if ((utype
= lookup_utype (dip
->die_ref
)) == NULL
)
1380 /* Install user defined type that has not been referenced yet. */
1381 alloc_utype (dip
->die_ref
, type
);
1383 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1385 /* Ick! A forward ref has already generated a blank type in our
1386 slot, and this type probably already has things pointing to it
1387 (which is what caused it to be created in the first place).
1388 If it's just a place holder we can plop our fully defined type
1389 on top of it. We can't recover the space allocated for our
1390 new type since it might be on an obstack, but we could reuse
1391 it if we kept a list of them, but it might not be worth it
1397 /* Double ick! Not only is a type already in our slot, but
1398 someone has decorated it. Complain and leave it alone. */
1399 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1408 read_tag_pointer_type -- read TAG_pointer_type DIE
1412 static void read_tag_pointer_type (struct dieinfo *dip)
1416 Extract all information from a TAG_pointer_type DIE and add to
1417 the user defined type vector.
1421 read_tag_pointer_type (struct dieinfo
*dip
)
1426 type
= decode_die_type (dip
);
1427 if ((utype
= lookup_utype (dip
->die_ref
)) == NULL
)
1429 utype
= lookup_pointer_type (type
);
1430 alloc_utype (dip
->die_ref
, utype
);
1434 TYPE_TARGET_TYPE (utype
) = type
;
1435 TYPE_POINTER_TYPE (type
) = utype
;
1437 /* We assume the machine has only one representation for pointers! */
1438 /* FIXME: Possably a poor assumption */
1439 TYPE_LENGTH (utype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
1440 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1448 read_tag_string_type -- read TAG_string_type DIE
1452 static void read_tag_string_type (struct dieinfo *dip)
1456 Extract all information from a TAG_string_type DIE and add to
1457 the user defined type vector. It isn't really a user defined
1458 type, but it behaves like one, with other DIE's using an
1459 AT_user_def_type attribute to reference it.
1463 read_tag_string_type (struct dieinfo
*dip
)
1466 struct type
*indextype
;
1467 struct type
*rangetype
;
1468 unsigned long lowbound
= 0;
1469 unsigned long highbound
;
1471 if (dip
->has_at_byte_size
)
1473 /* A fixed bounds string */
1474 highbound
= dip
->at_byte_size
- 1;
1478 /* A varying length string. Stub for now. (FIXME) */
1481 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1482 rangetype
= create_range_type ((struct type
*) NULL
, indextype
, lowbound
,
1485 utype
= lookup_utype (dip
->die_ref
);
1488 /* No type defined, go ahead and create a blank one to use. */
1489 utype
= alloc_utype (dip
->die_ref
, (struct type
*) NULL
);
1493 /* Already a type in our slot due to a forward reference. Make sure it
1494 is a blank one. If not, complain and leave it alone. */
1495 if (TYPE_CODE (utype
) != TYPE_CODE_UNDEF
)
1497 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1502 /* Create the string type using the blank type we either found or created. */
1503 utype
= create_string_type (utype
, rangetype
);
1510 read_subroutine_type -- process TAG_subroutine_type dies
1514 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1519 Handle DIES due to C code like:
1522 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1528 The parameter DIES are currently ignored. See if gdb has a way to
1529 include this info in it's type system, and decode them if so. Is
1530 this what the type structure's "arg_types" field is for? (FIXME)
1534 read_subroutine_type (struct dieinfo
*dip
, char *thisdie
, char *enddie
)
1536 struct type
*type
; /* Type that this function returns */
1537 struct type
*ftype
; /* Function that returns above type */
1539 /* Decode the type that this subroutine returns */
1541 type
= decode_die_type (dip
);
1543 /* Check to see if we already have a partially constructed user
1544 defined type for this DIE, from a forward reference. */
1546 if ((ftype
= lookup_utype (dip
->die_ref
)) == NULL
)
1548 /* This is the first reference to one of these types. Make
1549 a new one and place it in the user defined types. */
1550 ftype
= lookup_function_type (type
);
1551 alloc_utype (dip
->die_ref
, ftype
);
1553 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1555 /* We have an existing partially constructed type, so bash it
1556 into the correct type. */
1557 TYPE_TARGET_TYPE (ftype
) = type
;
1558 TYPE_LENGTH (ftype
) = 1;
1559 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1563 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1571 read_enumeration -- process dies which define an enumeration
1575 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1576 char *enddie, struct objfile *objfile)
1580 Given a pointer to a die which begins an enumeration, process all
1581 the dies that define the members of the enumeration.
1585 Note that we need to call enum_type regardless of whether or not we
1586 have a symbol, since we might have an enum without a tag name (thus
1587 no symbol for the tagname).
1591 read_enumeration (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1592 struct objfile
*objfile
)
1597 type
= enum_type (dip
, objfile
);
1598 sym
= new_symbol (dip
, objfile
);
1601 SYMBOL_TYPE (sym
) = type
;
1602 if (cu_language
== language_cplus
)
1604 synthesize_typedef (dip
, objfile
, type
);
1613 enum_type -- decode and return a type for an enumeration
1617 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1621 Given a pointer to a die information structure for the die which
1622 starts an enumeration, process all the dies that define the members
1623 of the enumeration and return a type pointer for the enumeration.
1625 At the same time, for each member of the enumeration, create a
1626 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1627 and give it the type of the enumeration itself.
1631 Note that the DWARF specification explicitly mandates that enum
1632 constants occur in reverse order from the source program order,
1633 for "consistency" and because this ordering is easier for many
1634 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1635 Entries). Because gdb wants to see the enum members in program
1636 source order, we have to ensure that the order gets reversed while
1637 we are processing them.
1640 static struct type
*
1641 enum_type (struct dieinfo
*dip
, struct objfile
*objfile
)
1646 struct nextfield
*next
;
1649 struct nextfield
*list
= NULL
;
1650 struct nextfield
*new;
1655 unsigned short blocksz
;
1658 int unsigned_enum
= 1;
1660 if ((type
= lookup_utype (dip
->die_ref
)) == NULL
)
1662 /* No forward references created an empty type, so install one now */
1663 type
= alloc_utype (dip
->die_ref
, NULL
);
1665 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1666 /* Some compilers try to be helpful by inventing "fake" names for
1667 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1668 Thanks, but no thanks... */
1669 if (dip
->at_name
!= NULL
1670 && *dip
->at_name
!= '~'
1671 && *dip
->at_name
!= '.')
1673 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
1674 "", "", dip
->at_name
);
1676 if (dip
->at_byte_size
!= 0)
1678 TYPE_LENGTH (type
) = dip
->at_byte_size
;
1680 if ((scan
= dip
->at_element_list
) != NULL
)
1682 if (dip
->short_element_list
)
1684 nbytes
= attribute_size (AT_short_element_list
);
1688 nbytes
= attribute_size (AT_element_list
);
1690 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1691 listend
= scan
+ nbytes
+ blocksz
;
1693 while (scan
< listend
)
1695 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1698 FIELD_TYPE (list
->field
) = NULL
;
1699 FIELD_BITSIZE (list
->field
) = 0;
1700 FIELD_BITPOS (list
->field
) =
1701 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1703 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1704 list
->field
.name
= obsavestring (scan
, strlen (scan
),
1705 &objfile
->type_obstack
);
1706 scan
+= strlen (scan
) + 1;
1708 /* Handcraft a new symbol for this enum member. */
1709 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1710 sizeof (struct symbol
));
1711 memset (sym
, 0, sizeof (struct symbol
));
1712 SYMBOL_NAME (sym
) = create_name (list
->field
.name
,
1713 &objfile
->symbol_obstack
);
1714 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1715 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1716 SYMBOL_CLASS (sym
) = LOC_CONST
;
1717 SYMBOL_TYPE (sym
) = type
;
1718 SYMBOL_VALUE (sym
) = FIELD_BITPOS (list
->field
);
1719 if (SYMBOL_VALUE (sym
) < 0)
1721 add_symbol_to_list (sym
, list_in_scope
);
1723 /* Now create the vector of fields, and record how big it is. This is
1724 where we reverse the order, by pulling the members off the list in
1725 reverse order from how they were inserted. If we have no fields
1726 (this is apparently possible in C++) then skip building a field
1731 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
1732 TYPE_NFIELDS (type
) = nfields
;
1733 TYPE_FIELDS (type
) = (struct field
*)
1734 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1735 /* Copy the saved-up fields into the field vector. */
1736 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
->next
)
1738 TYPE_FIELD (type
, n
++) = list
->field
;
1749 read_func_scope -- process all dies within a function scope
1753 Process all dies within a given function scope. We are passed
1754 a die information structure pointer DIP for the die which
1755 starts the function scope, and pointers into the raw die data
1756 that define the dies within the function scope.
1758 For now, we ignore lexical block scopes within the function.
1759 The problem is that AT&T cc does not define a DWARF lexical
1760 block scope for the function itself, while gcc defines a
1761 lexical block scope for the function. We need to think about
1762 how to handle this difference, or if it is even a problem.
1767 read_func_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1768 struct objfile
*objfile
)
1770 register struct context_stack
*new;
1772 /* AT_name is absent if the function is described with an
1773 AT_abstract_origin tag.
1774 Ignore the function description for now to avoid GDB core dumps.
1775 FIXME: Add code to handle AT_abstract_origin tags properly. */
1776 if (dip
->at_name
== NULL
)
1778 complain (&missing_at_name
, DIE_ID
);
1782 if (objfile
->ei
.entry_point
>= dip
->at_low_pc
&&
1783 objfile
->ei
.entry_point
< dip
->at_high_pc
)
1785 objfile
->ei
.entry_func_lowpc
= dip
->at_low_pc
;
1786 objfile
->ei
.entry_func_highpc
= dip
->at_high_pc
;
1788 new = push_context (0, dip
->at_low_pc
);
1789 new->name
= new_symbol (dip
, objfile
);
1790 list_in_scope
= &local_symbols
;
1791 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1792 new = pop_context ();
1793 /* Make a block for the local symbols within. */
1794 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1795 new->start_addr
, dip
->at_high_pc
, objfile
);
1796 list_in_scope
= &file_symbols
;
1804 handle_producer -- process the AT_producer attribute
1808 Perform any operations that depend on finding a particular
1809 AT_producer attribute.
1814 handle_producer (char *producer
)
1817 /* If this compilation unit was compiled with g++ or gcc, then set the
1818 processing_gcc_compilation flag. */
1820 if (STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
)))
1822 char version
= producer
[strlen (GCC_PRODUCER
)];
1823 processing_gcc_compilation
= (version
== '2' ? 2 : 1);
1827 processing_gcc_compilation
=
1828 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1829 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
));
1832 /* Select a demangling style if we can identify the producer and if
1833 the current style is auto. We leave the current style alone if it
1834 is not auto. We also leave the demangling style alone if we find a
1835 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1837 if (AUTO_DEMANGLING
)
1839 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1842 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1843 know whether it will use the old style or v3 mangling. */
1844 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1847 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1849 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1859 read_file_scope -- process all dies within a file scope
1863 Process all dies within a given file scope. We are passed a
1864 pointer to the die information structure for the die which
1865 starts the file scope, and pointers into the raw die data which
1866 mark the range of dies within the file scope.
1868 When the partial symbol table is built, the file offset for the line
1869 number table for each compilation unit is saved in the partial symbol
1870 table entry for that compilation unit. As the symbols for each
1871 compilation unit are read, the line number table is read into memory
1872 and the variable lnbase is set to point to it. Thus all we have to
1873 do is use lnbase to access the line number table for the current
1878 read_file_scope (struct dieinfo
*dip
, char *thisdie
, char *enddie
,
1879 struct objfile
*objfile
)
1881 struct cleanup
*back_to
;
1882 struct symtab
*symtab
;
1884 if (objfile
->ei
.entry_point
>= dip
->at_low_pc
&&
1885 objfile
->ei
.entry_point
< dip
->at_high_pc
)
1887 objfile
->ei
.entry_file_lowpc
= dip
->at_low_pc
;
1888 objfile
->ei
.entry_file_highpc
= dip
->at_high_pc
;
1890 set_cu_language (dip
);
1891 if (dip
->at_producer
!= NULL
)
1893 handle_producer (dip
->at_producer
);
1895 numutypes
= (enddie
- thisdie
) / 4;
1896 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1897 back_to
= make_cleanup (free_utypes
, NULL
);
1898 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1899 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1900 start_symtab (dip
->at_name
, dip
->at_comp_dir
, dip
->at_low_pc
);
1901 record_debugformat ("DWARF 1");
1902 decode_line_numbers (lnbase
);
1903 process_dies (thisdie
+ dip
->die_length
, enddie
, objfile
);
1905 symtab
= end_symtab (dip
->at_high_pc
, objfile
, 0);
1908 symtab
->language
= cu_language
;
1910 do_cleanups (back_to
);
1917 process_dies -- process a range of DWARF Information Entries
1921 static void process_dies (char *thisdie, char *enddie,
1922 struct objfile *objfile)
1926 Process all DIE's in a specified range. May be (and almost
1927 certainly will be) called recursively.
1931 process_dies (char *thisdie
, char *enddie
, struct objfile
*objfile
)
1936 while (thisdie
< enddie
)
1938 basicdieinfo (&di
, thisdie
, objfile
);
1939 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1943 else if (di
.die_tag
== TAG_padding
)
1945 nextdie
= thisdie
+ di
.die_length
;
1949 completedieinfo (&di
, objfile
);
1950 if (di
.at_sibling
!= 0)
1952 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1956 nextdie
= thisdie
+ di
.die_length
;
1958 #ifdef SMASH_TEXT_ADDRESS
1959 /* I think that these are always text, not data, addresses. */
1960 SMASH_TEXT_ADDRESS (di
.at_low_pc
);
1961 SMASH_TEXT_ADDRESS (di
.at_high_pc
);
1965 case TAG_compile_unit
:
1966 /* Skip Tag_compile_unit if we are already inside a compilation
1967 unit, we are unable to handle nested compilation units
1968 properly (FIXME). */
1969 if (current_subfile
== NULL
)
1970 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1972 nextdie
= thisdie
+ di
.die_length
;
1974 case TAG_global_subroutine
:
1975 case TAG_subroutine
:
1976 if (di
.has_at_low_pc
)
1978 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1981 case TAG_lexical_block
:
1982 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1984 case TAG_class_type
:
1985 case TAG_structure_type
:
1986 case TAG_union_type
:
1987 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1989 case TAG_enumeration_type
:
1990 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1992 case TAG_subroutine_type
:
1993 read_subroutine_type (&di
, thisdie
, nextdie
);
1995 case TAG_array_type
:
1996 dwarf_read_array_type (&di
);
1998 case TAG_pointer_type
:
1999 read_tag_pointer_type (&di
);
2001 case TAG_string_type
:
2002 read_tag_string_type (&di
);
2005 new_symbol (&di
, objfile
);
2017 decode_line_numbers -- decode a line number table fragment
2021 static void decode_line_numbers (char *tblscan, char *tblend,
2022 long length, long base, long line, long pc)
2026 Translate the DWARF line number information to gdb form.
2028 The ".line" section contains one or more line number tables, one for
2029 each ".line" section from the objects that were linked.
2031 The AT_stmt_list attribute for each TAG_source_file entry in the
2032 ".debug" section contains the offset into the ".line" section for the
2033 start of the table for that file.
2035 The table itself has the following structure:
2037 <table length><base address><source statement entry>
2038 4 bytes 4 bytes 10 bytes
2040 The table length is the total size of the table, including the 4 bytes
2041 for the length information.
2043 The base address is the address of the first instruction generated
2044 for the source file.
2046 Each source statement entry has the following structure:
2048 <line number><statement position><address delta>
2049 4 bytes 2 bytes 4 bytes
2051 The line number is relative to the start of the file, starting with
2054 The statement position either -1 (0xFFFF) or the number of characters
2055 from the beginning of the line to the beginning of the statement.
2057 The address delta is the difference between the base address and
2058 the address of the first instruction for the statement.
2060 Note that we must copy the bytes from the packed table to our local
2061 variables before attempting to use them, to avoid alignment problems
2062 on some machines, particularly RISC processors.
2066 Does gdb expect the line numbers to be sorted? They are now by
2067 chance/luck, but are not required to be. (FIXME)
2069 The line with number 0 is unused, gdb apparently can discover the
2070 span of the last line some other way. How? (FIXME)
2074 decode_line_numbers (char *linetable
)
2078 unsigned long length
;
2083 if (linetable
!= NULL
)
2085 tblscan
= tblend
= linetable
;
2086 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2088 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2090 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2091 GET_UNSIGNED
, current_objfile
);
2092 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2094 while (tblscan
< tblend
)
2096 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2098 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2099 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2101 tblscan
+= SIZEOF_LINETBL_DELTA
;
2105 record_line (current_subfile
, line
, pc
);
2115 locval -- compute the value of a location attribute
2119 static int locval (struct dieinfo *dip)
2123 Given pointer to a string of bytes that define a location, compute
2124 the location and return the value.
2125 A location description containing no atoms indicates that the
2126 object is optimized out. The optimized_out flag is set for those,
2127 the return value is meaningless.
2129 When computing values involving the current value of the frame pointer,
2130 the value zero is used, which results in a value relative to the frame
2131 pointer, rather than the absolute value. This is what GDB wants
2134 When the result is a register number, the isreg flag is set, otherwise
2135 it is cleared. This is a kludge until we figure out a better
2136 way to handle the problem. Gdb's design does not mesh well with the
2137 DWARF notion of a location computing interpreter, which is a shame
2138 because the flexibility goes unused.
2142 Note that stack[0] is unused except as a default error return.
2143 Note that stack overflow is not yet handled.
2147 locval (struct dieinfo
*dip
)
2149 unsigned short nbytes
;
2150 unsigned short locsize
;
2151 auto long stack
[64];
2158 loc
= dip
->at_location
;
2159 nbytes
= attribute_size (AT_location
);
2160 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2162 end
= loc
+ locsize
;
2167 dip
->optimized_out
= 1;
2168 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2171 dip
->optimized_out
= 0;
2172 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2174 loc
+= SIZEOF_LOC_ATOM_CODE
;
2175 switch (loc_atom_code
)
2182 /* push register (number) */
2184 = DWARF_REG_TO_REGNUM (target_to_host (loc
, loc_value_size
,
2187 loc
+= loc_value_size
;
2191 /* push value of register (number) */
2192 /* Actually, we compute the value as if register has 0, so the
2193 value ends up being the offset from that register. */
2195 dip
->basereg
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2197 loc
+= loc_value_size
;
2198 stack
[++stacki
] = 0;
2201 /* push address (relocated address) */
2202 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2203 GET_UNSIGNED
, current_objfile
);
2204 loc
+= loc_value_size
;
2207 /* push constant (number) FIXME: signed or unsigned! */
2208 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2209 GET_SIGNED
, current_objfile
);
2210 loc
+= loc_value_size
;
2213 /* pop, deref and push 2 bytes (as a long) */
2214 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2216 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2217 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2219 case OP_ADD
: /* pop top 2 items, add, push result */
2220 stack
[stacki
- 1] += stack
[stacki
];
2225 return (stack
[stacki
]);
2232 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2236 static void read_ofile_symtab (struct partial_symtab *pst)
2240 When expanding a partial symbol table entry to a full symbol table
2241 entry, this is the function that gets called to read in the symbols
2242 for the compilation unit. A pointer to the newly constructed symtab,
2243 which is now the new first one on the objfile's symtab list, is
2244 stashed in the partial symbol table entry.
2248 read_ofile_symtab (struct partial_symtab
*pst
)
2250 struct cleanup
*back_to
;
2251 unsigned long lnsize
;
2254 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2256 abfd
= pst
->objfile
->obfd
;
2257 current_objfile
= pst
->objfile
;
2259 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2260 unit, seek to the location in the file, and read in all the DIE's. */
2263 dbsize
= DBLENGTH (pst
);
2264 dbbase
= xmalloc (dbsize
);
2265 dbroff
= DBROFF (pst
);
2266 foffset
= DBFOFF (pst
) + dbroff
;
2267 base_section_offsets
= pst
->section_offsets
;
2268 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2269 if (bfd_seek (abfd
, foffset
, SEEK_SET
) ||
2270 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2273 error ("can't read DWARF data");
2275 back_to
= make_cleanup (xfree
, dbbase
);
2277 /* If there is a line number table associated with this compilation unit
2278 then read the size of this fragment in bytes, from the fragment itself.
2279 Allocate a buffer for the fragment and read it in for future
2285 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2286 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2287 sizeof (lnsizedata
)))
2289 error ("can't read DWARF line number table size");
2291 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2292 GET_UNSIGNED
, pst
->objfile
);
2293 lnbase
= xmalloc (lnsize
);
2294 if (bfd_seek (abfd
, LNFOFF (pst
), SEEK_SET
) ||
2295 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2298 error ("can't read DWARF line numbers");
2300 make_cleanup (xfree
, lnbase
);
2303 process_dies (dbbase
, dbbase
+ dbsize
, pst
->objfile
);
2304 do_cleanups (back_to
);
2305 current_objfile
= NULL
;
2306 pst
->symtab
= pst
->objfile
->symtabs
;
2313 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2317 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2321 Called once for each partial symbol table entry that needs to be
2322 expanded into a full symbol table entry.
2327 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2330 struct cleanup
*old_chain
;
2336 warning ("psymtab for %s already read in. Shouldn't happen.",
2341 /* Read in all partial symtabs on which this one is dependent */
2342 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2344 if (!pst
->dependencies
[i
]->readin
)
2346 /* Inform about additional files that need to be read in. */
2349 fputs_filtered (" ", gdb_stdout
);
2351 fputs_filtered ("and ", gdb_stdout
);
2353 printf_filtered ("%s...",
2354 pst
->dependencies
[i
]->filename
);
2356 gdb_flush (gdb_stdout
); /* Flush output */
2358 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2361 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2364 old_chain
= make_cleanup (really_free_pendings
, 0);
2365 read_ofile_symtab (pst
);
2368 printf_filtered ("%d DIE's, sorting...", diecount
);
2370 gdb_flush (gdb_stdout
);
2372 sort_symtab_syms (pst
->symtab
);
2373 do_cleanups (old_chain
);
2384 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2388 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2392 This is the DWARF support entry point for building a full symbol
2393 table entry from a partial symbol table entry. We are passed a
2394 pointer to the partial symbol table entry that needs to be expanded.
2399 dwarf_psymtab_to_symtab (struct partial_symtab
*pst
)
2406 warning ("psymtab for %s already read in. Shouldn't happen.",
2411 if (DBLENGTH (pst
) || pst
->number_of_dependencies
)
2413 /* Print the message now, before starting serious work, to avoid
2414 disconcerting pauses. */
2417 printf_filtered ("Reading in symbols for %s...",
2419 gdb_flush (gdb_stdout
);
2422 psymtab_to_symtab_1 (pst
);
2424 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2425 we need to do an equivalent or is this something peculiar to
2427 Match with global symbols. This only needs to be done once,
2428 after all of the symtabs and dependencies have been read in.
2430 scan_file_globals (pst
->objfile
);
2433 /* Finish up the verbose info message. */
2436 printf_filtered ("done.\n");
2437 gdb_flush (gdb_stdout
);
2448 add_enum_psymbol -- add enumeration members to partial symbol table
2452 Given pointer to a DIE that is known to be for an enumeration,
2453 extract the symbolic names of the enumeration members and add
2454 partial symbols for them.
2458 add_enum_psymbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2462 unsigned short blocksz
;
2465 if ((scan
= dip
->at_element_list
) != NULL
)
2467 if (dip
->short_element_list
)
2469 nbytes
= attribute_size (AT_short_element_list
);
2473 nbytes
= attribute_size (AT_element_list
);
2475 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2477 listend
= scan
+ blocksz
;
2478 while (scan
< listend
)
2480 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2481 add_psymbol_to_list (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2482 &objfile
->static_psymbols
, 0, 0, cu_language
,
2484 scan
+= strlen (scan
) + 1;
2493 add_partial_symbol -- add symbol to partial symbol table
2497 Given a DIE, if it is one of the types that we want to
2498 add to a partial symbol table, finish filling in the die info
2499 and then add a partial symbol table entry for it.
2503 The caller must ensure that the DIE has a valid name attribute.
2507 add_partial_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2509 switch (dip
->die_tag
)
2511 case TAG_global_subroutine
:
2512 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2513 VAR_NAMESPACE
, LOC_BLOCK
,
2514 &objfile
->global_psymbols
,
2515 0, dip
->at_low_pc
, cu_language
, objfile
);
2517 case TAG_global_variable
:
2518 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2519 VAR_NAMESPACE
, LOC_STATIC
,
2520 &objfile
->global_psymbols
,
2521 0, 0, cu_language
, objfile
);
2523 case TAG_subroutine
:
2524 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2525 VAR_NAMESPACE
, LOC_BLOCK
,
2526 &objfile
->static_psymbols
,
2527 0, dip
->at_low_pc
, cu_language
, objfile
);
2529 case TAG_local_variable
:
2530 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2531 VAR_NAMESPACE
, LOC_STATIC
,
2532 &objfile
->static_psymbols
,
2533 0, 0, cu_language
, objfile
);
2536 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2537 VAR_NAMESPACE
, LOC_TYPEDEF
,
2538 &objfile
->static_psymbols
,
2539 0, 0, cu_language
, objfile
);
2541 case TAG_class_type
:
2542 case TAG_structure_type
:
2543 case TAG_union_type
:
2544 case TAG_enumeration_type
:
2545 /* Do not add opaque aggregate definitions to the psymtab. */
2546 if (!dip
->has_at_byte_size
)
2548 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2549 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2550 &objfile
->static_psymbols
,
2551 0, 0, cu_language
, objfile
);
2552 if (cu_language
== language_cplus
)
2554 /* For C++, these implicitly act as typedefs as well. */
2555 add_psymbol_to_list (dip
->at_name
, strlen (dip
->at_name
),
2556 VAR_NAMESPACE
, LOC_TYPEDEF
,
2557 &objfile
->static_psymbols
,
2558 0, 0, cu_language
, objfile
);
2568 scan_partial_symbols -- scan DIE's within a single compilation unit
2572 Process the DIE's within a single compilation unit, looking for
2573 interesting DIE's that contribute to the partial symbol table entry
2574 for this compilation unit.
2578 There are some DIE's that may appear both at file scope and within
2579 the scope of a function. We are only interested in the ones at file
2580 scope, and the only way to tell them apart is to keep track of the
2581 scope. For example, consider the test case:
2586 for which the relevant DWARF segment has the structure:
2589 0x23 global subrtn sibling 0x9b
2591 fund_type FT_integer
2596 0x23 local var sibling 0x97
2598 fund_type FT_integer
2599 location OP_BASEREG 0xe
2606 0x1d local var sibling 0xb8
2608 fund_type FT_integer
2609 location OP_ADDR 0x800025dc
2614 We want to include the symbol 'i' in the partial symbol table, but
2615 not the symbol 'j'. In essence, we want to skip all the dies within
2616 the scope of a TAG_global_subroutine DIE.
2618 Don't attempt to add anonymous structures or unions since they have
2619 no name. Anonymous enumerations however are processed, because we
2620 want to extract their member names (the check for a tag name is
2623 Also, for variables and subroutines, check that this is the place
2624 where the actual definition occurs, rather than just a reference
2632 scan_partial_symbols (char *thisdie
, char *enddie
, struct objfile
*objfile
)
2638 while (thisdie
< enddie
)
2640 basicdieinfo (&di
, thisdie
, objfile
);
2641 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2647 nextdie
= thisdie
+ di
.die_length
;
2648 /* To avoid getting complete die information for every die, we
2649 only do it (below) for the cases we are interested in. */
2652 case TAG_global_subroutine
:
2653 case TAG_subroutine
:
2654 completedieinfo (&di
, objfile
);
2655 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2657 add_partial_symbol (&di
, objfile
);
2658 /* If there is a sibling attribute, adjust the nextdie
2659 pointer to skip the entire scope of the subroutine.
2660 Apply some sanity checking to make sure we don't
2661 overrun or underrun the range of remaining DIE's */
2662 if (di
.at_sibling
!= 0)
2664 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2665 if ((temp
< thisdie
) || (temp
>= enddie
))
2667 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2677 case TAG_global_variable
:
2678 case TAG_local_variable
:
2679 completedieinfo (&di
, objfile
);
2680 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2682 add_partial_symbol (&di
, objfile
);
2686 case TAG_class_type
:
2687 case TAG_structure_type
:
2688 case TAG_union_type
:
2689 completedieinfo (&di
, objfile
);
2692 add_partial_symbol (&di
, objfile
);
2695 case TAG_enumeration_type
:
2696 completedieinfo (&di
, objfile
);
2699 add_partial_symbol (&di
, objfile
);
2701 add_enum_psymbol (&di
, objfile
);
2713 scan_compilation_units -- build a psymtab entry for each compilation
2717 This is the top level dwarf parsing routine for building partial
2720 It scans from the beginning of the DWARF table looking for the first
2721 TAG_compile_unit DIE, and then follows the sibling chain to locate
2722 each additional TAG_compile_unit DIE.
2724 For each TAG_compile_unit DIE it creates a partial symtab structure,
2725 calls a subordinate routine to collect all the compilation unit's
2726 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2727 new partial symtab structure into the partial symbol table. It also
2728 records the appropriate information in the partial symbol table entry
2729 to allow the chunk of DIE's and line number table for this compilation
2730 unit to be located and re-read later, to generate a complete symbol
2731 table entry for the compilation unit.
2733 Thus it effectively partitions up a chunk of DIE's for multiple
2734 compilation units into smaller DIE chunks and line number tables,
2735 and associates them with a partial symbol table entry.
2739 If any compilation unit has no line number table associated with
2740 it for some reason (a missing at_stmt_list attribute, rather than
2741 just one with a value of zero, which is valid) then we ensure that
2742 the recorded file offset is zero so that the routine which later
2743 reads line number table fragments knows that there is no fragment
2753 scan_compilation_units (char *thisdie
, char *enddie
, file_ptr dbfoff
,
2754 file_ptr lnoffset
, struct objfile
*objfile
)
2758 struct partial_symtab
*pst
;
2761 file_ptr curlnoffset
;
2763 while (thisdie
< enddie
)
2765 basicdieinfo (&di
, thisdie
, objfile
);
2766 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2770 else if (di
.die_tag
!= TAG_compile_unit
)
2772 nextdie
= thisdie
+ di
.die_length
;
2776 completedieinfo (&di
, objfile
);
2777 set_cu_language (&di
);
2778 if (di
.at_sibling
!= 0)
2780 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2784 nextdie
= thisdie
+ di
.die_length
;
2786 curoff
= thisdie
- dbbase
;
2787 culength
= nextdie
- thisdie
;
2788 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2790 /* First allocate a new partial symbol table structure */
2792 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2793 di
.at_name
, di
.at_low_pc
,
2794 objfile
->global_psymbols
.next
,
2795 objfile
->static_psymbols
.next
);
2797 pst
->texthigh
= di
.at_high_pc
;
2798 pst
->read_symtab_private
= (char *)
2799 obstack_alloc (&objfile
->psymbol_obstack
,
2800 sizeof (struct dwfinfo
));
2801 DBFOFF (pst
) = dbfoff
;
2802 DBROFF (pst
) = curoff
;
2803 DBLENGTH (pst
) = culength
;
2804 LNFOFF (pst
) = curlnoffset
;
2805 pst
->read_symtab
= dwarf_psymtab_to_symtab
;
2807 /* Now look for partial symbols */
2809 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2811 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
2812 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2813 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
2814 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2815 sort_pst_symbols (pst
);
2816 /* If there is already a psymtab or symtab for a file of this name,
2817 remove it. (If there is a symtab, more drastic things also
2818 happen.) This happens in VxWorks. */
2819 free_named_symtabs (pst
->filename
);
2829 new_symbol -- make a symbol table entry for a new symbol
2833 static struct symbol *new_symbol (struct dieinfo *dip,
2834 struct objfile *objfile)
2838 Given a pointer to a DWARF information entry, figure out if we need
2839 to make a symbol table entry for it, and if so, create a new entry
2840 and return a pointer to it.
2843 static struct symbol
*
2844 new_symbol (struct dieinfo
*dip
, struct objfile
*objfile
)
2846 struct symbol
*sym
= NULL
;
2848 if (dip
->at_name
!= NULL
)
2850 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
2851 sizeof (struct symbol
));
2852 OBJSTAT (objfile
, n_syms
++);
2853 memset (sym
, 0, sizeof (struct symbol
));
2854 SYMBOL_NAME (sym
) = create_name (dip
->at_name
,
2855 &objfile
->symbol_obstack
);
2856 /* default assumptions */
2857 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2858 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2859 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2861 /* If this symbol is from a C++ compilation, then attempt to cache the
2862 demangled form for future reference. This is a typical time versus
2863 space tradeoff, that was decided in favor of time because it sped up
2864 C++ symbol lookups by a factor of about 20. */
2866 SYMBOL_LANGUAGE (sym
) = cu_language
;
2867 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
2868 switch (dip
->die_tag
)
2871 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2872 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2874 case TAG_global_subroutine
:
2875 case TAG_subroutine
:
2876 SYMBOL_VALUE_ADDRESS (sym
) = dip
->at_low_pc
;
2877 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2878 if (dip
->at_prototyped
)
2879 TYPE_FLAGS (SYMBOL_TYPE (sym
)) |= TYPE_FLAG_PROTOTYPED
;
2880 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2881 if (dip
->die_tag
== TAG_global_subroutine
)
2883 add_symbol_to_list (sym
, &global_symbols
);
2887 add_symbol_to_list (sym
, list_in_scope
);
2890 case TAG_global_variable
:
2891 if (dip
->at_location
!= NULL
)
2893 SYMBOL_VALUE_ADDRESS (sym
) = locval (dip
);
2894 add_symbol_to_list (sym
, &global_symbols
);
2895 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2896 SYMBOL_VALUE (sym
) += baseaddr
;
2899 case TAG_local_variable
:
2900 if (dip
->at_location
!= NULL
)
2902 int loc
= locval (dip
);
2903 if (dip
->optimized_out
)
2905 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
2907 else if (dip
->isreg
)
2909 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2911 else if (dip
->offreg
)
2913 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
2914 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2918 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2919 SYMBOL_VALUE (sym
) += baseaddr
;
2921 if (SYMBOL_CLASS (sym
) == LOC_STATIC
)
2923 /* LOC_STATIC address class MUST use SYMBOL_VALUE_ADDRESS,
2924 which may store to a bigger location than SYMBOL_VALUE. */
2925 SYMBOL_VALUE_ADDRESS (sym
) = loc
;
2929 SYMBOL_VALUE (sym
) = loc
;
2931 add_symbol_to_list (sym
, list_in_scope
);
2934 case TAG_formal_parameter
:
2935 if (dip
->at_location
!= NULL
)
2937 SYMBOL_VALUE (sym
) = locval (dip
);
2939 add_symbol_to_list (sym
, list_in_scope
);
2942 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2944 else if (dip
->offreg
)
2946 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
2947 SYMBOL_BASEREG (sym
) = dip
->basereg
;
2951 SYMBOL_CLASS (sym
) = LOC_ARG
;
2954 case TAG_unspecified_parameters
:
2955 /* From varargs functions; gdb doesn't seem to have any interest in
2956 this information, so just ignore it for now. (FIXME?) */
2958 case TAG_class_type
:
2959 case TAG_structure_type
:
2960 case TAG_union_type
:
2961 case TAG_enumeration_type
:
2962 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2963 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2964 add_symbol_to_list (sym
, list_in_scope
);
2967 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2968 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2969 add_symbol_to_list (sym
, list_in_scope
);
2972 /* Not a tag we recognize. Hopefully we aren't processing trash
2973 data, but since we must specifically ignore things we don't
2974 recognize, there is nothing else we should do at this point. */
2985 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2989 static void synthesize_typedef (struct dieinfo *dip,
2990 struct objfile *objfile,
2995 Given a pointer to a DWARF information entry, synthesize a typedef
2996 for the name in the DIE, using the specified type.
2998 This is used for C++ class, structs, unions, and enumerations to
2999 set up the tag name as a type.
3004 synthesize_typedef (struct dieinfo
*dip
, struct objfile
*objfile
,
3007 struct symbol
*sym
= NULL
;
3009 if (dip
->at_name
!= NULL
)
3011 sym
= (struct symbol
*)
3012 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symbol
));
3013 OBJSTAT (objfile
, n_syms
++);
3014 memset (sym
, 0, sizeof (struct symbol
));
3015 SYMBOL_NAME (sym
) = create_name (dip
->at_name
,
3016 &objfile
->symbol_obstack
);
3017 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3018 SYMBOL_TYPE (sym
) = type
;
3019 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3020 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3021 add_symbol_to_list (sym
, list_in_scope
);
3029 decode_mod_fund_type -- decode a modified fundamental type
3033 static struct type *decode_mod_fund_type (char *typedata)
3037 Decode a block of data containing a modified fundamental
3038 type specification. TYPEDATA is a pointer to the block,
3039 which starts with a length containing the size of the rest
3040 of the block. At the end of the block is a fundmental type
3041 code value that gives the fundamental type. Everything
3042 in between are type modifiers.
3044 We simply compute the number of modifiers and call the general
3045 function decode_modified_type to do the actual work.
3048 static struct type
*
3049 decode_mod_fund_type (char *typedata
)
3051 struct type
*typep
= NULL
;
3052 unsigned short modcount
;
3055 /* Get the total size of the block, exclusive of the size itself */
3057 nbytes
= attribute_size (AT_mod_fund_type
);
3058 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3061 /* Deduct the size of the fundamental type bytes at the end of the block. */
3063 modcount
-= attribute_size (AT_fund_type
);
3065 /* Now do the actual decoding */
3067 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3075 decode_mod_u_d_type -- decode a modified user defined type
3079 static struct type *decode_mod_u_d_type (char *typedata)
3083 Decode a block of data containing a modified user defined
3084 type specification. TYPEDATA is a pointer to the block,
3085 which consists of a two byte length, containing the size
3086 of the rest of the block. At the end of the block is a
3087 four byte value that gives a reference to a user defined type.
3088 Everything in between are type modifiers.
3090 We simply compute the number of modifiers and call the general
3091 function decode_modified_type to do the actual work.
3094 static struct type
*
3095 decode_mod_u_d_type (char *typedata
)
3097 struct type
*typep
= NULL
;
3098 unsigned short modcount
;
3101 /* Get the total size of the block, exclusive of the size itself */
3103 nbytes
= attribute_size (AT_mod_u_d_type
);
3104 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3107 /* Deduct the size of the reference type bytes at the end of the block. */
3109 modcount
-= attribute_size (AT_user_def_type
);
3111 /* Now do the actual decoding */
3113 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3121 decode_modified_type -- decode modified user or fundamental type
3125 static struct type *decode_modified_type (char *modifiers,
3126 unsigned short modcount, int mtype)
3130 Decode a modified type, either a modified fundamental type or
3131 a modified user defined type. MODIFIERS is a pointer to the
3132 block of bytes that define MODCOUNT modifiers. Immediately
3133 following the last modifier is a short containing the fundamental
3134 type or a long containing the reference to the user defined
3135 type. Which one is determined by MTYPE, which is either
3136 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3137 type we are generating.
3139 We call ourself recursively to generate each modified type,`
3140 until MODCOUNT reaches zero, at which point we have consumed
3141 all the modifiers and generate either the fundamental type or
3142 user defined type. When the recursion unwinds, each modifier
3143 is applied in turn to generate the full modified type.
3147 If we find a modifier that we don't recognize, and it is not one
3148 of those reserved for application specific use, then we issue a
3149 warning and simply ignore the modifier.
3153 We currently ignore MOD_const and MOD_volatile. (FIXME)
3157 static struct type
*
3158 decode_modified_type (char *modifiers
, unsigned int modcount
, int mtype
)
3160 struct type
*typep
= NULL
;
3161 unsigned short fundtype
;
3170 case AT_mod_fund_type
:
3171 nbytes
= attribute_size (AT_fund_type
);
3172 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3174 typep
= decode_fund_type (fundtype
);
3176 case AT_mod_u_d_type
:
3177 nbytes
= attribute_size (AT_user_def_type
);
3178 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3180 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3182 typep
= alloc_utype (die_ref
, NULL
);
3186 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3187 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3193 modifier
= *modifiers
++;
3194 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3197 case MOD_pointer_to
:
3198 typep
= lookup_pointer_type (typep
);
3200 case MOD_reference_to
:
3201 typep
= lookup_reference_type (typep
);
3204 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3207 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3210 if (!(MOD_lo_user
<= (unsigned char) modifier
3211 && (unsigned char) modifier
<= MOD_hi_user
))
3213 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3225 decode_fund_type -- translate basic DWARF type to gdb base type
3229 Given an integer that is one of the fundamental DWARF types,
3230 translate it to one of the basic internal gdb types and return
3231 a pointer to the appropriate gdb type (a "struct type *").
3235 For robustness, if we are asked to translate a fundamental
3236 type that we are unprepared to deal with, we return int so
3237 callers can always depend upon a valid type being returned,
3238 and so gdb may at least do something reasonable by default.
3239 If the type is not in the range of those types defined as
3240 application specific types, we also issue a warning.
3243 static struct type
*
3244 decode_fund_type (unsigned int fundtype
)
3246 struct type
*typep
= NULL
;
3252 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3255 case FT_boolean
: /* Was FT_set in AT&T version */
3256 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3259 case FT_pointer
: /* (void *) */
3260 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3261 typep
= lookup_pointer_type (typep
);
3265 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3268 case FT_signed_char
:
3269 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3272 case FT_unsigned_char
:
3273 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3277 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3280 case FT_signed_short
:
3281 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3284 case FT_unsigned_short
:
3285 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3289 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3292 case FT_signed_integer
:
3293 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3296 case FT_unsigned_integer
:
3297 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3301 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3304 case FT_signed_long
:
3305 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3308 case FT_unsigned_long
:
3309 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3313 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3316 case FT_signed_long_long
:
3317 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3320 case FT_unsigned_long_long
:
3321 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3325 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3328 case FT_dbl_prec_float
:
3329 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3332 case FT_ext_prec_float
:
3333 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3337 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3340 case FT_dbl_prec_complex
:
3341 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3344 case FT_ext_prec_complex
:
3345 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3352 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3353 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3355 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3366 create_name -- allocate a fresh copy of a string on an obstack
3370 Given a pointer to a string and a pointer to an obstack, allocates
3371 a fresh copy of the string on the specified obstack.
3376 create_name (char *name
, struct obstack
*obstackp
)
3381 length
= strlen (name
) + 1;
3382 newname
= (char *) obstack_alloc (obstackp
, length
);
3383 strcpy (newname
, name
);
3391 basicdieinfo -- extract the minimal die info from raw die data
3395 void basicdieinfo (char *diep, struct dieinfo *dip,
3396 struct objfile *objfile)
3400 Given a pointer to raw DIE data, and a pointer to an instance of a
3401 die info structure, this function extracts the basic information
3402 from the DIE data required to continue processing this DIE, along
3403 with some bookkeeping information about the DIE.
3405 The information we absolutely must have includes the DIE tag,
3406 and the DIE length. If we need the sibling reference, then we
3407 will have to call completedieinfo() to process all the remaining
3410 Note that since there is no guarantee that the data is properly
3411 aligned in memory for the type of access required (indirection
3412 through anything other than a char pointer), and there is no
3413 guarantee that it is in the same byte order as the gdb host,
3414 we call a function which deals with both alignment and byte
3415 swapping issues. Possibly inefficient, but quite portable.
3417 We also take care of some other basic things at this point, such
3418 as ensuring that the instance of the die info structure starts
3419 out completely zero'd and that curdie is initialized for use
3420 in error reporting if we have a problem with the current die.
3424 All DIE's must have at least a valid length, thus the minimum
3425 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3426 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3427 are forced to be TAG_padding DIES.
3429 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3430 that if a padding DIE is used for alignment and the amount needed is
3431 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3432 enough to align to the next alignment boundry.
3434 We do some basic sanity checking here, such as verifying that the
3435 length of the die would not cause it to overrun the recorded end of
3436 the buffer holding the DIE info. If we find a DIE that is either
3437 too small or too large, we force it's length to zero which should
3438 cause the caller to take appropriate action.
3442 basicdieinfo (struct dieinfo
*dip
, char *diep
, struct objfile
*objfile
)
3445 memset (dip
, 0, sizeof (struct dieinfo
));
3447 dip
->die_ref
= dbroff
+ (diep
- dbbase
);
3448 dip
->die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3450 if ((dip
->die_length
< SIZEOF_DIE_LENGTH
) ||
3451 ((diep
+ dip
->die_length
) > (dbbase
+ dbsize
)))
3453 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
->die_length
);
3454 dip
->die_length
= 0;
3456 else if (dip
->die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3458 dip
->die_tag
= TAG_padding
;
3462 diep
+= SIZEOF_DIE_LENGTH
;
3463 dip
->die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3472 completedieinfo -- finish reading the information for a given DIE
3476 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3480 Given a pointer to an already partially initialized die info structure,
3481 scan the raw DIE data and finish filling in the die info structure
3482 from the various attributes found.
3484 Note that since there is no guarantee that the data is properly
3485 aligned in memory for the type of access required (indirection
3486 through anything other than a char pointer), and there is no
3487 guarantee that it is in the same byte order as the gdb host,
3488 we call a function which deals with both alignment and byte
3489 swapping issues. Possibly inefficient, but quite portable.
3493 Each time we are called, we increment the diecount variable, which
3494 keeps an approximate count of the number of dies processed for
3495 each compilation unit. This information is presented to the user
3496 if the info_verbose flag is set.
3501 completedieinfo (struct dieinfo
*dip
, struct objfile
*objfile
)
3503 char *diep
; /* Current pointer into raw DIE data */
3504 char *end
; /* Terminate DIE scan here */
3505 unsigned short attr
; /* Current attribute being scanned */
3506 unsigned short form
; /* Form of the attribute */
3507 int nbytes
; /* Size of next field to read */
3511 end
= diep
+ dip
->die_length
;
3512 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3515 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3516 diep
+= SIZEOF_ATTRIBUTE
;
3517 if ((nbytes
= attribute_size (attr
)) == -1)
3519 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3526 dip
->at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3530 dip
->at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3534 dip
->at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3538 dip
->at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3542 dip
->at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3544 dip
->has_at_stmt_list
= 1;
3547 dip
->at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3549 dip
->at_low_pc
+= baseaddr
;
3550 dip
->has_at_low_pc
= 1;
3553 dip
->at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3555 dip
->at_high_pc
+= baseaddr
;
3558 dip
->at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3561 case AT_user_def_type
:
3562 dip
->at_user_def_type
= target_to_host (diep
, nbytes
,
3563 GET_UNSIGNED
, objfile
);
3566 dip
->at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3568 dip
->has_at_byte_size
= 1;
3571 dip
->at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3575 dip
->at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3579 dip
->at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3583 dip
->at_location
= diep
;
3585 case AT_mod_fund_type
:
3586 dip
->at_mod_fund_type
= diep
;
3588 case AT_subscr_data
:
3589 dip
->at_subscr_data
= diep
;
3591 case AT_mod_u_d_type
:
3592 dip
->at_mod_u_d_type
= diep
;
3594 case AT_element_list
:
3595 dip
->at_element_list
= diep
;
3596 dip
->short_element_list
= 0;
3598 case AT_short_element_list
:
3599 dip
->at_element_list
= diep
;
3600 dip
->short_element_list
= 1;
3602 case AT_discr_value
:
3603 dip
->at_discr_value
= diep
;
3605 case AT_string_length
:
3606 dip
->at_string_length
= diep
;
3609 dip
->at_name
= diep
;
3612 /* For now, ignore any "hostname:" portion, since gdb doesn't
3613 know how to deal with it. (FIXME). */
3614 dip
->at_comp_dir
= strrchr (diep
, ':');
3615 if (dip
->at_comp_dir
!= NULL
)
3621 dip
->at_comp_dir
= diep
;
3625 dip
->at_producer
= diep
;
3627 case AT_start_scope
:
3628 dip
->at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3631 case AT_stride_size
:
3632 dip
->at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3636 dip
->at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3640 dip
->at_prototyped
= diep
;
3643 /* Found an attribute that we are unprepared to handle. However
3644 it is specifically one of the design goals of DWARF that
3645 consumers should ignore unknown attributes. As long as the
3646 form is one that we recognize (so we know how to skip it),
3647 we can just ignore the unknown attribute. */
3650 form
= FORM_FROM_ATTR (attr
);
3664 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3667 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3670 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3673 diep
+= strlen (diep
) + 1;
3676 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3687 target_to_host -- swap in target data to host
3691 target_to_host (char *from, int nbytes, int signextend,
3692 struct objfile *objfile)
3696 Given pointer to data in target format in FROM, a byte count for
3697 the size of the data in NBYTES, a flag indicating whether or not
3698 the data is signed in SIGNEXTEND, and a pointer to the current
3699 objfile in OBJFILE, convert the data to host format and return
3700 the converted value.
3704 FIXME: If we read data that is known to be signed, and expect to
3705 use it as signed data, then we need to explicitly sign extend the
3706 result until the bfd library is able to do this for us.
3708 FIXME: Would a 32 bit target ever need an 8 byte result?
3713 target_to_host (char *from
, int nbytes
, int signextend
, /* FIXME: Unused */
3714 struct objfile
*objfile
)
3721 rtnval
= bfd_get_64 (objfile
->obfd
, (bfd_byte
*) from
);
3724 rtnval
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) from
);
3727 rtnval
= bfd_get_16 (objfile
->obfd
, (bfd_byte
*) from
);
3730 rtnval
= bfd_get_8 (objfile
->obfd
, (bfd_byte
*) from
);
3733 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3744 attribute_size -- compute size of data for a DWARF attribute
3748 static int attribute_size (unsigned int attr)
3752 Given a DWARF attribute in ATTR, compute the size of the first
3753 piece of data associated with this attribute and return that
3756 Returns -1 for unrecognized attributes.
3761 attribute_size (unsigned int attr
)
3763 int nbytes
; /* Size of next data for this attribute */
3764 unsigned short form
; /* Form of the attribute */
3766 form
= FORM_FROM_ATTR (attr
);
3769 case FORM_STRING
: /* A variable length field is next */
3772 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3773 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3776 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3777 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3778 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3781 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3784 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3785 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3788 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);