1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
4 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 FIXME: Figure out how to get the frame pointer register number in the
25 execution environment of the target. Remove R_FP kludge
27 FIXME: Add generation of dependencies list to partial symtab code.
29 FIXME: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
49 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
50 #include "elf/dwarf.h"
53 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
55 #include "complaints.h"
59 #include <sys/types.h>
65 /* FIXME -- convert this to SEEK_SET a la POSIX, move to config files. */
70 /* Some macros to provide DIE info for complaints. */
72 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
73 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
75 /* Complaints that can be issued during DWARF debug info reading. */
77 struct complaint no_bfd_get_N
=
79 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
82 struct complaint malformed_die
=
84 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
87 struct complaint bad_die_ref
=
89 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
92 struct complaint unknown_attribute_form
=
94 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
97 struct complaint unknown_attribute_length
=
99 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
102 struct complaint unexpected_fund_type
=
104 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
107 struct complaint unknown_type_modifier
=
109 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
112 struct complaint volatile_ignored
=
114 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
117 struct complaint const_ignored
=
119 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
122 struct complaint botched_modified_type
=
124 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
127 struct complaint op_deref2
=
129 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
132 struct complaint op_deref4
=
134 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
137 struct complaint basereg_not_handled
=
139 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
142 struct complaint dup_user_type_allocation
=
144 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
147 struct complaint dup_user_type_definition
=
149 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
152 struct complaint missing_tag
=
154 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
157 struct complaint bad_array_element_type
=
159 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
162 struct complaint subscript_data_items
=
164 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
167 struct complaint unhandled_array_subscript_format
=
169 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
172 struct complaint unknown_array_subscript_format
=
174 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
177 struct complaint not_row_major
=
179 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
182 #ifndef R_FP /* FIXME */
183 #define R_FP 14 /* Kludge to get frame pointer register number */
186 typedef unsigned int DIE_REF
; /* Reference to a DIE */
189 #define GCC_PRODUCER "GNU C "
192 #ifndef GPLUS_PRODUCER
193 #define GPLUS_PRODUCER "GNU C++ "
197 #define LCC_PRODUCER "NCR C/C++"
200 #ifndef CFRONT_PRODUCER
201 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
204 /* start-sanitize-chill */
205 #ifndef CHILL_PRODUCER
206 #define CHILL_PRODUCER "GNU Chill "
208 /* end-sanitize-chill */
210 /* Flags to target_to_host() that tell whether or not the data object is
211 expected to be signed. Used, for example, when fetching a signed
212 integer in the target environment which is used as a signed integer
213 in the host environment, and the two environments have different sized
214 ints. In this case, *somebody* has to sign extend the smaller sized
217 #define GET_UNSIGNED 0 /* No sign extension required */
218 #define GET_SIGNED 1 /* Sign extension required */
220 /* Defines for things which are specified in the document "DWARF Debugging
221 Information Format" published by UNIX International, Programming Languages
222 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
224 #define SIZEOF_DIE_LENGTH 4
225 #define SIZEOF_DIE_TAG 2
226 #define SIZEOF_ATTRIBUTE 2
227 #define SIZEOF_FORMAT_SPECIFIER 1
228 #define SIZEOF_FMT_FT 2
229 #define SIZEOF_LINETBL_LENGTH 4
230 #define SIZEOF_LINETBL_LINENO 4
231 #define SIZEOF_LINETBL_STMT 2
232 #define SIZEOF_LINETBL_DELTA 4
233 #define SIZEOF_LOC_ATOM_CODE 1
235 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
237 /* Macros that return the sizes of various types of data in the target
240 FIXME: Currently these are just compile time constants (as they are in
241 other parts of gdb as well). They need to be able to get the right size
242 either from the bfd or possibly from the DWARF info. It would be nice if
243 the DWARF producer inserted DIES that describe the fundamental types in
244 the target environment into the DWARF info, similar to the way dbx stabs
245 producers produce information about their fundamental types. */
247 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
248 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
250 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
251 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
252 However, the Issue 2 DWARF specification from AT&T defines it as
253 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
254 For backwards compatibility with the AT&T compiler produced executables
255 we define AT_short_element_list for this variant. */
257 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
259 /* External variables referenced. */
261 extern int info_verbose
; /* From main.c; nonzero => verbose */
262 extern char *warning_pre_print
; /* From utils.c */
264 /* The DWARF debugging information consists of two major pieces,
265 one is a block of DWARF Information Entries (DIE's) and the other
266 is a line number table. The "struct dieinfo" structure contains
267 the information for a single DIE, the one currently being processed.
269 In order to make it easier to randomly access the attribute fields
270 of the current DIE, which are specifically unordered within the DIE,
271 each DIE is scanned and an instance of the "struct dieinfo"
272 structure is initialized.
274 Initialization is done in two levels. The first, done by basicdieinfo(),
275 just initializes those fields that are vital to deciding whether or not
276 to use this DIE, how to skip past it, etc. The second, done by the
277 function completedieinfo(), fills in the rest of the information.
279 Attributes which have block forms are not interpreted at the time
280 the DIE is scanned, instead we just save pointers to the start
281 of their value fields.
283 Some fields have a flag <name>_p that is set when the value of the
284 field is valid (I.E. we found a matching attribute in the DIE). Since
285 we may want to test for the presence of some attributes in the DIE,
286 such as AT_low_pc, without restricting the values of the field,
287 we need someway to note that we found such an attribute.
294 char * die
; /* Pointer to the raw DIE data */
295 unsigned long die_length
; /* Length of the raw DIE data */
296 DIE_REF die_ref
; /* Offset of this DIE */
297 unsigned short die_tag
; /* Tag for this DIE */
298 unsigned long at_padding
;
299 unsigned long at_sibling
;
302 unsigned short at_fund_type
;
303 BLOCK
* at_mod_fund_type
;
304 unsigned long at_user_def_type
;
305 BLOCK
* at_mod_u_d_type
;
306 unsigned short at_ordering
;
307 BLOCK
* at_subscr_data
;
308 unsigned long at_byte_size
;
309 unsigned short at_bit_offset
;
310 unsigned long at_bit_size
;
311 BLOCK
* at_element_list
;
312 unsigned long at_stmt_list
;
313 unsigned long at_low_pc
;
314 unsigned long at_high_pc
;
315 unsigned long at_language
;
316 unsigned long at_member
;
317 unsigned long at_discr
;
318 BLOCK
* at_discr_value
;
319 BLOCK
* at_string_length
;
322 unsigned long at_start_scope
;
323 unsigned long at_stride_size
;
324 unsigned long at_src_info
;
325 char * at_prototyped
;
326 unsigned int has_at_low_pc
:1;
327 unsigned int has_at_stmt_list
:1;
328 unsigned int has_at_byte_size
:1;
329 unsigned int short_element_list
:1;
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 */
339 static int isreg
; /* Kludge to identify register variables */
340 static int offreg
; /* Kludge to identify basereg references */
342 /* This value is added to each symbol value. FIXME: Generalize to
343 the section_offsets structure used by dbxread. */
344 static CORE_ADDR baseaddr
; /* Add to each symbol value */
346 /* The section offsets used in the current psymtab or symtab. FIXME,
347 only used to pass one value (baseaddr) at the moment. */
348 static struct section_offsets
*base_section_offsets
;
350 /* Each partial symbol table entry contains a pointer to private data for the
351 read_symtab() function to use when expanding a partial symbol table entry
352 to a full symbol table entry. For DWARF debugging info, this data is
353 contained in the following structure and macros are provided for easy
354 access to the members given a pointer to a partial symbol table entry.
356 dbfoff Always the absolute file offset to the start of the ".debug"
357 section for the file containing the DIE's being accessed.
359 dbroff Relative offset from the start of the ".debug" access to the
360 first DIE to be accessed. When building the partial symbol
361 table, this value will be zero since we are accessing the
362 entire ".debug" section. When expanding a partial symbol
363 table entry, this value will be the offset to the first
364 DIE for the compilation unit containing the symbol that
365 triggers the expansion.
367 dblength The size of the chunk of DIE's being examined, in bytes.
369 lnfoff The absolute file offset to the line table fragment. Ignored
370 when building partial symbol tables, but used when expanding
371 them, and contains the absolute file offset to the fragment
372 of the ".line" section containing the line numbers for the
373 current compilation unit.
377 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
378 int dbroff
; /* Relative offset from start of .debug section */
379 int dblength
; /* Size of the chunk of DIE's being examined */
380 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
383 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
384 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
385 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
386 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
388 /* The generic symbol table building routines have separate lists for
389 file scope symbols and all all other scopes (local scopes). So
390 we need to select the right one to pass to add_symbol_to_list().
391 We do it by keeping a pointer to the correct list in list_in_scope.
393 FIXME: The original dwarf code just treated the file scope as the first
394 local scope, and all other local scopes as nested local scopes, and worked
395 fine. Check to see if we really need to distinguish these in buildsym.c */
397 struct pending
**list_in_scope
= &file_symbols
;
399 /* DIES which have user defined types or modified user defined types refer to
400 other DIES for the type information. Thus we need to associate the offset
401 of a DIE for a user defined type with a pointer to the type information.
403 Originally this was done using a simple but expensive algorithm, with an
404 array of unsorted structures, each containing an offset/type-pointer pair.
405 This array was scanned linearly each time a lookup was done. The result
406 was that gdb was spending over half it's startup time munging through this
407 array of pointers looking for a structure that had the right offset member.
409 The second attempt used the same array of structures, but the array was
410 sorted using qsort each time a new offset/type was recorded, and a binary
411 search was used to find the type pointer for a given DIE offset. This was
412 even slower, due to the overhead of sorting the array each time a new
413 offset/type pair was entered.
415 The third attempt uses a fixed size array of type pointers, indexed by a
416 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
417 we can divide any DIE offset by 4 to obtain a unique index into this fixed
418 size array. Since each element is a 4 byte pointer, it takes exactly as
419 much memory to hold this array as to hold the DWARF info for a given
420 compilation unit. But it gets freed as soon as we are done with it.
421 This has worked well in practice, as a reasonable tradeoff between memory
422 consumption and speed, without having to resort to much more complicated
425 static struct type
**utypes
; /* Pointer to array of user type pointers */
426 static int numutypes
; /* Max number of user type pointers */
428 /* Maintain an array of referenced fundamental types for the current
429 compilation unit being read. For DWARF version 1, we have to construct
430 the fundamental types on the fly, since no information about the
431 fundamental types is supplied. Each such fundamental type is created by
432 calling a language dependent routine to create the type, and then a
433 pointer to that type is then placed in the array at the index specified
434 by it's FT_<TYPENAME> value. The array has a fixed size set by the
435 FT_NUM_MEMBERS compile time constant, which is the number of predefined
436 fundamental types gdb knows how to construct. */
438 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
440 /* Record the language for the compilation unit which is currently being
441 processed. We know it once we have seen the TAG_compile_unit DIE,
442 and we need it while processing the DIE's for that compilation unit.
443 It is eventually saved in the symtab structure, but we don't finalize
444 the symtab struct until we have processed all the DIE's for the
445 compilation unit. We also need to get and save a pointer to the
446 language struct for this language, so we can call the language
447 dependent routines for doing things such as creating fundamental
450 static enum language cu_language
;
451 static const struct language_defn
*cu_language_defn
;
453 /* Forward declarations of static functions so we don't have to worry
454 about ordering within this file. */
457 attribute_size
PARAMS ((unsigned int));
460 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
463 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
466 handle_producer
PARAMS ((char *));
469 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
472 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
475 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
479 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
482 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
483 file_ptr
, struct objfile
*));
486 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
489 init_psymbol_list
PARAMS ((struct objfile
*, int));
492 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
495 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
498 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
501 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
503 static struct symtab
*
504 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
507 process_dies
PARAMS ((char *, char *, struct objfile
*));
510 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
514 decode_array_element_type
PARAMS ((char *));
517 decode_subscript_data_item
PARAMS ((char *, char *));
520 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
523 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
526 read_tag_string_type
PARAMS ((struct dieinfo
*dip
));
529 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
532 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
535 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
538 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
541 decode_line_numbers
PARAMS ((char *));
544 decode_die_type
PARAMS ((struct dieinfo
*));
547 decode_mod_fund_type
PARAMS ((char *));
550 decode_mod_u_d_type
PARAMS ((char *));
553 decode_modified_type
PARAMS ((char *, unsigned int, int));
556 decode_fund_type
PARAMS ((unsigned int));
559 create_name
PARAMS ((char *, struct obstack
*));
562 lookup_utype
PARAMS ((DIE_REF
));
565 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
567 static struct symbol
*
568 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
571 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
575 locval
PARAMS ((char *));
578 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
582 set_cu_language
PARAMS ((struct dieinfo
*));
585 dwarf_fundamental_type
PARAMS ((struct objfile
*, int));
592 dwarf_fundamental_type -- lookup or create a fundamental type
597 dwarf_fundamental_type (struct objfile *objfile, int typeid)
601 DWARF version 1 doesn't supply any fundamental type information,
602 so gdb has to construct such types. It has a fixed number of
603 fundamental types that it knows how to construct, which is the
604 union of all types that it knows how to construct for all languages
605 that it knows about. These are enumerated in gdbtypes.h.
607 As an example, assume we find a DIE that references a DWARF
608 fundamental type of FT_integer. We first look in the ftypes
609 array to see if we already have such a type, indexed by the
610 gdb internal value of FT_INTEGER. If so, we simply return a
611 pointer to that type. If not, then we ask an appropriate
612 language dependent routine to create a type FT_INTEGER, using
613 defaults reasonable for the current target machine, and install
614 that type in ftypes for future reference.
618 Pointer to a fundamental type.
623 dwarf_fundamental_type (objfile
, typeid)
624 struct objfile
*objfile
;
627 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
629 error ("internal error - invalid fundamental type id %d", typeid);
632 /* Look for this particular type in the fundamental type vector. If one is
633 not found, create and install one appropriate for the current language
634 and the current target machine. */
636 if (ftypes
[typeid] == NULL
)
638 ftypes
[typeid] = cu_language_defn
-> la_fund_type(objfile
, typeid);
641 return (ftypes
[typeid]);
648 set_cu_language -- set local copy of language for compilation unit
653 set_cu_language (struct dieinfo *dip)
657 Decode the language attribute for a compilation unit DIE and
658 remember what the language was. We use this at various times
659 when processing DIE's for a given compilation unit.
668 set_cu_language (dip
)
671 switch (dip
-> at_language
)
675 cu_language
= language_c
;
677 case LANG_C_PLUS_PLUS
:
678 cu_language
= language_cplus
;
680 /* start-sanitize-chill */
682 cu_language
= language_chill
;
684 /* end-sanitize-chill */
686 cu_language
= language_m2
;
694 /* We don't know anything special about these yet. */
695 cu_language
= language_unknown
;
698 /* If no at_language, try to deduce one from the filename */
699 cu_language
= deduce_language_from_filename (dip
-> at_name
);
702 cu_language_defn
= language_def (cu_language
);
709 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
713 void dwarf_build_psymtabs (struct objfile *objfile,
714 struct section_offsets *section_offsets,
715 int mainline, file_ptr dbfoff, unsigned int dbfsize,
716 file_ptr lnoffset, unsigned int lnsize)
720 This function is called upon to build partial symtabs from files
721 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
723 It is passed a bfd* containing the DIES
724 and line number information, the corresponding filename for that
725 file, a base address for relocating the symbols, a flag indicating
726 whether or not this debugging information is from a "main symbol
727 table" rather than a shared library or dynamically linked file,
728 and file offset/size pairs for the DIE information and line number
738 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
740 struct objfile
*objfile
;
741 struct section_offsets
*section_offsets
;
744 unsigned int dbfsize
;
748 bfd
*abfd
= objfile
->obfd
;
749 struct cleanup
*back_to
;
751 current_objfile
= objfile
;
753 dbbase
= xmalloc (dbsize
);
755 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
756 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
759 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
761 back_to
= make_cleanup (free
, dbbase
);
763 /* If we are reinitializing, or if we have never loaded syms yet, init.
764 Since we have no idea how many DIES we are looking at, we just guess
765 some arbitrary value. */
767 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
768 objfile
-> static_psymbols
.size
== 0)
770 init_psymbol_list (objfile
, 1024);
773 /* Save the relocation factor where everybody can see it. */
775 base_section_offsets
= section_offsets
;
776 baseaddr
= ANOFFSET (section_offsets
, 0);
778 /* Follow the compilation unit sibling chain, building a partial symbol
779 table entry for each one. Save enough information about each compilation
780 unit to locate the full DWARF information later. */
782 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
784 do_cleanups (back_to
);
785 current_objfile
= NULL
;
793 record_minimal_symbol -- add entry to gdb's minimal symbol table
797 static void record_minimal_symbol (char *name, CORE_ADDR address,
798 enum minimal_symbol_type ms_type,
799 struct objfile *objfile)
803 Given a pointer to the name of a symbol that should be added to the
804 minimal symbol table, and the address associated with that
805 symbol, records this information for later use in building the
806 minimal symbol table.
811 record_minimal_symbol (name
, address
, ms_type
, objfile
)
814 enum minimal_symbol_type ms_type
;
815 struct objfile
*objfile
;
817 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
818 prim_record_minimal_symbol (name
, address
, ms_type
);
825 read_lexical_block_scope -- process all dies in a lexical block
829 static void read_lexical_block_scope (struct dieinfo *dip,
830 char *thisdie, char *enddie)
834 Process all the DIES contained within a lexical block scope.
835 Start a new scope, process the dies, and then close the scope.
840 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
844 struct objfile
*objfile
;
846 register struct context_stack
*new;
848 push_context (0, dip
-> at_low_pc
);
849 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
850 new = pop_context ();
851 if (local_symbols
!= NULL
)
853 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
854 dip
-> at_high_pc
, objfile
);
856 local_symbols
= new -> locals
;
863 lookup_utype -- look up a user defined type from die reference
867 static type *lookup_utype (DIE_REF die_ref)
871 Given a DIE reference, lookup the user defined type associated with
872 that DIE, if it has been registered already. If not registered, then
873 return NULL. Alloc_utype() can be called to register an empty
874 type for this reference, which will be filled in later when the
875 actual referenced DIE is processed.
879 lookup_utype (die_ref
)
882 struct type
*type
= NULL
;
885 utypeidx
= (die_ref
- dbroff
) / 4;
886 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
888 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
892 type
= *(utypes
+ utypeidx
);
902 alloc_utype -- add a user defined type for die reference
906 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
910 Given a die reference DIE_REF, and a possible pointer to a user
911 defined type UTYPEP, register that this reference has a user
912 defined type and either use the specified type in UTYPEP or
913 make a new empty type that will be filled in later.
915 We should only be called after calling lookup_utype() to verify that
916 there is not currently a type registered for DIE_REF.
920 alloc_utype (die_ref
, utypep
)
927 utypeidx
= (die_ref
- dbroff
) / 4;
928 typep
= utypes
+ utypeidx
;
929 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
931 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
932 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
934 else if (*typep
!= NULL
)
937 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
943 utypep
= alloc_type (current_objfile
);
954 decode_die_type -- return a type for a specified die
958 static struct type *decode_die_type (struct dieinfo *dip)
962 Given a pointer to a die information structure DIP, decode the
963 type of the die and return a pointer to the decoded type. All
964 dies without specific types default to type int.
968 decode_die_type (dip
)
971 struct type
*type
= NULL
;
973 if (dip
-> at_fund_type
!= 0)
975 type
= decode_fund_type (dip
-> at_fund_type
);
977 else if (dip
-> at_mod_fund_type
!= NULL
)
979 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
981 else if (dip
-> at_user_def_type
)
983 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
985 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
988 else if (dip
-> at_mod_u_d_type
)
990 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
994 type
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1003 struct_type -- compute and return the type for a struct or union
1007 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
1008 char *enddie, struct objfile *objfile)
1012 Given pointer to a die information structure for a die which
1013 defines a union or structure (and MUST define one or the other),
1014 and pointers to the raw die data that define the range of dies which
1015 define the members, compute and return the user defined type for the
1019 static struct type
*
1020 struct_type (dip
, thisdie
, enddie
, objfile
)
1021 struct dieinfo
*dip
;
1024 struct objfile
*objfile
;
1028 struct nextfield
*next
;
1031 struct nextfield
*list
= NULL
;
1032 struct nextfield
*new;
1038 #if !BITS_BIG_ENDIAN
1042 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1044 /* No forward references created an empty type, so install one now */
1045 type
= alloc_utype (dip
-> die_ref
, NULL
);
1047 INIT_CPLUS_SPECIFIC(type
);
1048 switch (dip
-> die_tag
)
1050 case TAG_class_type
:
1051 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
1054 case TAG_structure_type
:
1055 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1058 case TAG_union_type
:
1059 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1063 /* Should never happen */
1064 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
1066 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
1069 /* Some compilers try to be helpful by inventing "fake" names for
1070 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1071 Thanks, but no thanks... */
1072 if (dip
-> at_name
!= NULL
1073 && *dip
-> at_name
!= '~'
1074 && *dip
-> at_name
!= '.')
1076 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
1077 tpart1
, " ", dip
-> at_name
);
1079 /* Use whatever size is known. Zero is a valid size. We might however
1080 wish to check has_at_byte_size to make sure that some byte size was
1081 given explicitly, but DWARF doesn't specify that explicit sizes of
1082 zero have to present, so complaining about missing sizes should
1083 probably not be the default. */
1084 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1085 thisdie
+= dip
-> die_length
;
1086 while (thisdie
< enddie
)
1088 basicdieinfo (&mbr
, thisdie
, objfile
);
1089 completedieinfo (&mbr
, objfile
);
1090 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1094 else if (mbr
.at_sibling
!= 0)
1096 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1100 nextdie
= thisdie
+ mbr
.die_length
;
1102 switch (mbr
.die_tag
)
1105 /* Get space to record the next field's data. */
1106 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1109 /* Save the data. */
1110 list
-> field
.name
=
1111 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1112 &objfile
-> type_obstack
);
1113 list
-> field
.type
= decode_die_type (&mbr
);
1114 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
1115 /* Handle bit fields. */
1116 list
-> field
.bitsize
= mbr
.at_bit_size
;
1118 /* For big endian bits, the at_bit_offset gives the additional
1119 bit offset from the MSB of the containing anonymous object to
1120 the MSB of the field. We don't have to do anything special
1121 since we don't need to know the size of the anonymous object. */
1122 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
1124 /* For little endian bits, we need to have a non-zero at_bit_size,
1125 so that we know we are in fact dealing with a bitfield. Compute
1126 the bit offset to the MSB of the anonymous object, subtract off
1127 the number of bits from the MSB of the field to the MSB of the
1128 object, and then subtract off the number of bits of the field
1129 itself. The result is the bit offset of the LSB of the field. */
1130 if (mbr
.at_bit_size
> 0)
1132 if (mbr
.has_at_byte_size
)
1134 /* The size of the anonymous object containing the bit field
1135 is explicit, so use the indicated size (in bytes). */
1136 anonymous_size
= mbr
.at_byte_size
;
1140 /* The size of the anonymous object containing the bit field
1141 matches the size of an object of the bit field's type.
1142 DWARF allows at_byte_size to be left out in such cases,
1143 as a debug information size optimization. */
1144 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
1146 list
-> field
.bitpos
+=
1147 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1153 process_dies (thisdie
, nextdie
, objfile
);
1158 /* Now create the vector of fields, and record how big it is. We may
1159 not even have any fields, if this DIE was generated due to a reference
1160 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1161 set, which clues gdb in to the fact that it needs to search elsewhere
1162 for the full structure definition. */
1165 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1169 TYPE_NFIELDS (type
) = nfields
;
1170 TYPE_FIELDS (type
) = (struct field
*)
1171 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1172 /* Copy the saved-up fields into the field vector. */
1173 for (n
= nfields
; list
; list
= list
-> next
)
1175 TYPE_FIELD (type
, --n
) = list
-> field
;
1185 read_structure_scope -- process all dies within struct or union
1189 static void read_structure_scope (struct dieinfo *dip,
1190 char *thisdie, char *enddie, struct objfile *objfile)
1194 Called when we find the DIE that starts a structure or union
1195 scope (definition) to process all dies that define the members
1196 of the structure or union. DIP is a pointer to the die info
1197 struct for the DIE that names the structure or union.
1201 Note that we need to call struct_type regardless of whether or not
1202 the DIE has an at_name attribute, since it might be an anonymous
1203 structure or union. This gets the type entered into our set of
1206 However, if the structure is incomplete (an opaque struct/union)
1207 then suppress creating a symbol table entry for it since gdb only
1208 wants to find the one with the complete definition. Note that if
1209 it is complete, we just call new_symbol, which does it's own
1210 checking about whether the struct/union is anonymous or not (and
1211 suppresses creating a symbol table entry itself).
1216 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1217 struct dieinfo
*dip
;
1220 struct objfile
*objfile
;
1225 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1226 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1228 sym
= new_symbol (dip
, objfile
);
1231 SYMBOL_TYPE (sym
) = type
;
1232 if (cu_language
== language_cplus
)
1234 synthesize_typedef (dip
, objfile
, type
);
1244 decode_array_element_type -- decode type of the array elements
1248 static struct type *decode_array_element_type (char *scan, char *end)
1252 As the last step in decoding the array subscript information for an
1253 array DIE, we need to decode the type of the array elements. We are
1254 passed a pointer to this last part of the subscript information and
1255 must return the appropriate type. If the type attribute is not
1256 recognized, just warn about the problem and return type int.
1259 static struct type
*
1260 decode_array_element_type (scan
)
1265 unsigned short attribute
;
1266 unsigned short fundtype
;
1269 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1271 scan
+= SIZEOF_ATTRIBUTE
;
1272 if ((nbytes
= attribute_size (attribute
)) == -1)
1274 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1275 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1282 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1284 typep
= decode_fund_type (fundtype
);
1286 case AT_mod_fund_type
:
1287 typep
= decode_mod_fund_type (scan
);
1289 case AT_user_def_type
:
1290 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1292 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1294 typep
= alloc_utype (die_ref
, NULL
);
1297 case AT_mod_u_d_type
:
1298 typep
= decode_mod_u_d_type (scan
);
1301 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1302 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1313 decode_subscript_data_item -- decode array subscript item
1317 static struct type *
1318 decode_subscript_data_item (char *scan, char *end)
1322 The array subscripts and the data type of the elements of an
1323 array are described by a list of data items, stored as a block
1324 of contiguous bytes. There is a data item describing each array
1325 dimension, and a final data item describing the element type.
1326 The data items are ordered the same as their appearance in the
1327 source (I.E. leftmost dimension first, next to leftmost second,
1330 The data items describing each array dimension consist of four
1331 parts: (1) a format specifier, (2) type type of the subscript
1332 index, (3) a description of the low bound of the array dimension,
1333 and (4) a description of the high bound of the array dimension.
1335 The last data item is the description of the type of each of
1338 We are passed a pointer to the start of the block of bytes
1339 containing the remaining data items, and a pointer to the first
1340 byte past the data. This function recursively decodes the
1341 remaining data items and returns a type.
1343 If we somehow fail to decode some data, we complain about it
1344 and return a type "array of int".
1347 FIXME: This code only implements the forms currently used
1348 by the AT&T and GNU C compilers.
1350 The end pointer is supplied for error checking, maybe we should
1354 static struct type
*
1355 decode_subscript_data_item (scan
, end
)
1359 struct type
*typep
= NULL
; /* Array type we are building */
1360 struct type
*nexttype
; /* Type of each element (may be array) */
1361 struct type
*indextype
; /* Type of this index */
1362 struct type
*rangetype
;
1363 unsigned int format
;
1364 unsigned short fundtype
;
1365 unsigned long lowbound
;
1366 unsigned long highbound
;
1369 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1371 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1375 typep
= decode_array_element_type (scan
);
1378 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1380 indextype
= decode_fund_type (fundtype
);
1381 scan
+= SIZEOF_FMT_FT
;
1382 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1383 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1385 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1387 nexttype
= decode_subscript_data_item (scan
, end
);
1388 if (nexttype
== NULL
)
1390 /* Munged subscript data or other problem, fake it. */
1391 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1392 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1394 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1395 lowbound
, highbound
);
1396 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1405 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1406 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1407 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1408 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1411 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1412 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1413 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1414 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1424 dwarf_read_array_type -- read TAG_array_type DIE
1428 static void dwarf_read_array_type (struct dieinfo *dip)
1432 Extract all information from a TAG_array_type DIE and add to
1433 the user defined type vector.
1437 dwarf_read_array_type (dip
)
1438 struct dieinfo
*dip
;
1444 unsigned short blocksz
;
1447 if (dip
-> at_ordering
!= ORD_row_major
)
1449 /* FIXME: Can gdb even handle column major arrays? */
1450 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1452 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1454 nbytes
= attribute_size (AT_subscr_data
);
1455 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1456 subend
= sub
+ nbytes
+ blocksz
;
1458 type
= decode_subscript_data_item (sub
, subend
);
1459 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1461 /* Install user defined type that has not been referenced yet. */
1462 alloc_utype (dip
-> die_ref
, type
);
1464 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1466 /* Ick! A forward ref has already generated a blank type in our
1467 slot, and this type probably already has things pointing to it
1468 (which is what caused it to be created in the first place).
1469 If it's just a place holder we can plop our fully defined type
1470 on top of it. We can't recover the space allocated for our
1471 new type since it might be on an obstack, but we could reuse
1472 it if we kept a list of them, but it might not be worth it
1478 /* Double ick! Not only is a type already in our slot, but
1479 someone has decorated it. Complain and leave it alone. */
1480 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1489 read_tag_pointer_type -- read TAG_pointer_type DIE
1493 static void read_tag_pointer_type (struct dieinfo *dip)
1497 Extract all information from a TAG_pointer_type DIE and add to
1498 the user defined type vector.
1502 read_tag_pointer_type (dip
)
1503 struct dieinfo
*dip
;
1508 type
= decode_die_type (dip
);
1509 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1511 utype
= lookup_pointer_type (type
);
1512 alloc_utype (dip
-> die_ref
, utype
);
1516 TYPE_TARGET_TYPE (utype
) = type
;
1517 TYPE_POINTER_TYPE (type
) = utype
;
1519 /* We assume the machine has only one representation for pointers! */
1520 /* FIXME: This confuses host<->target data representations, and is a
1521 poor assumption besides. */
1523 TYPE_LENGTH (utype
) = sizeof (char *);
1524 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1532 read_tag_string_type -- read TAG_string_type DIE
1536 static void read_tag_string_type (struct dieinfo *dip)
1540 Extract all information from a TAG_string_type DIE and add to
1541 the user defined type vector. It isn't really a user defined
1542 type, but it behaves like one, with other DIE's using an
1543 AT_user_def_type attribute to reference it.
1547 read_tag_string_type (dip
)
1548 struct dieinfo
*dip
;
1551 struct type
*indextype
;
1552 struct type
*rangetype
;
1553 unsigned long lowbound
= 0;
1554 unsigned long highbound
;
1556 if ((utype
= lookup_utype (dip
-> die_ref
)) != NULL
)
1558 /* Ack, someone has stuck a type in the slot we want. Complain
1560 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1564 if (dip
-> has_at_byte_size
)
1566 /* A fixed bounds string */
1567 highbound
= dip
-> at_byte_size
- 1;
1571 /* A varying length string. Stub for now. (FIXME) */
1574 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1575 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1576 lowbound
, highbound
);
1577 utype
= create_string_type ((struct type
*) NULL
, rangetype
);
1578 alloc_utype (dip
-> die_ref
, utype
);
1586 read_subroutine_type -- process TAG_subroutine_type dies
1590 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1595 Handle DIES due to C code like:
1598 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1604 The parameter DIES are currently ignored. See if gdb has a way to
1605 include this info in it's type system, and decode them if so. Is
1606 this what the type structure's "arg_types" field is for? (FIXME)
1610 read_subroutine_type (dip
, thisdie
, enddie
)
1611 struct dieinfo
*dip
;
1615 struct type
*type
; /* Type that this function returns */
1616 struct type
*ftype
; /* Function that returns above type */
1618 /* Decode the type that this subroutine returns */
1620 type
= decode_die_type (dip
);
1622 /* Check to see if we already have a partially constructed user
1623 defined type for this DIE, from a forward reference. */
1625 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1627 /* This is the first reference to one of these types. Make
1628 a new one and place it in the user defined types. */
1629 ftype
= lookup_function_type (type
);
1630 alloc_utype (dip
-> die_ref
, ftype
);
1632 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1634 /* We have an existing partially constructed type, so bash it
1635 into the correct type. */
1636 TYPE_TARGET_TYPE (ftype
) = type
;
1637 TYPE_FUNCTION_TYPE (type
) = ftype
;
1638 TYPE_LENGTH (ftype
) = 1;
1639 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1643 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1651 read_enumeration -- process dies which define an enumeration
1655 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1656 char *enddie, struct objfile *objfile)
1660 Given a pointer to a die which begins an enumeration, process all
1661 the dies that define the members of the enumeration.
1665 Note that we need to call enum_type regardless of whether or not we
1666 have a symbol, since we might have an enum without a tag name (thus
1667 no symbol for the tagname).
1671 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1672 struct dieinfo
*dip
;
1675 struct objfile
*objfile
;
1680 type
= enum_type (dip
, objfile
);
1681 sym
= new_symbol (dip
, objfile
);
1684 SYMBOL_TYPE (sym
) = type
;
1685 if (cu_language
== language_cplus
)
1687 synthesize_typedef (dip
, objfile
, type
);
1696 enum_type -- decode and return a type for an enumeration
1700 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1704 Given a pointer to a die information structure for the die which
1705 starts an enumeration, process all the dies that define the members
1706 of the enumeration and return a type pointer for the enumeration.
1708 At the same time, for each member of the enumeration, create a
1709 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1710 and give it the type of the enumeration itself.
1714 Note that the DWARF specification explicitly mandates that enum
1715 constants occur in reverse order from the source program order,
1716 for "consistency" and because this ordering is easier for many
1717 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1718 Entries). Because gdb wants to see the enum members in program
1719 source order, we have to ensure that the order gets reversed while
1720 we are processing them.
1723 static struct type
*
1724 enum_type (dip
, objfile
)
1725 struct dieinfo
*dip
;
1726 struct objfile
*objfile
;
1730 struct nextfield
*next
;
1733 struct nextfield
*list
= NULL
;
1734 struct nextfield
*new;
1739 unsigned short blocksz
;
1743 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1745 /* No forward references created an empty type, so install one now */
1746 type
= alloc_utype (dip
-> die_ref
, NULL
);
1748 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1749 /* Some compilers try to be helpful by inventing "fake" names for
1750 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1751 Thanks, but no thanks... */
1752 if (dip
-> at_name
!= NULL
1753 && *dip
-> at_name
!= '~'
1754 && *dip
-> at_name
!= '.')
1756 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1757 " ", dip
-> at_name
);
1759 if (dip
-> at_byte_size
!= 0)
1761 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1763 if ((scan
= dip
-> at_element_list
) != NULL
)
1765 if (dip
-> short_element_list
)
1767 nbytes
= attribute_size (AT_short_element_list
);
1771 nbytes
= attribute_size (AT_element_list
);
1773 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1774 listend
= scan
+ nbytes
+ blocksz
;
1776 while (scan
< listend
)
1778 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1781 list
-> field
.type
= NULL
;
1782 list
-> field
.bitsize
= 0;
1783 list
-> field
.bitpos
=
1784 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1786 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1787 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1788 &objfile
-> type_obstack
);
1789 scan
+= strlen (scan
) + 1;
1791 /* Handcraft a new symbol for this enum member. */
1792 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1793 sizeof (struct symbol
));
1794 memset (sym
, 0, sizeof (struct symbol
));
1795 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1796 &objfile
->symbol_obstack
);
1797 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1798 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1799 SYMBOL_CLASS (sym
) = LOC_CONST
;
1800 SYMBOL_TYPE (sym
) = type
;
1801 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1802 add_symbol_to_list (sym
, list_in_scope
);
1804 /* Now create the vector of fields, and record how big it is. This is
1805 where we reverse the order, by pulling the members off the list in
1806 reverse order from how they were inserted. If we have no fields
1807 (this is apparently possible in C++) then skip building a field
1811 TYPE_NFIELDS (type
) = nfields
;
1812 TYPE_FIELDS (type
) = (struct field
*)
1813 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1814 /* Copy the saved-up fields into the field vector. */
1815 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1817 TYPE_FIELD (type
, n
++) = list
-> field
;
1828 read_func_scope -- process all dies within a function scope
1832 Process all dies within a given function scope. We are passed
1833 a die information structure pointer DIP for the die which
1834 starts the function scope, and pointers into the raw die data
1835 that define the dies within the function scope.
1837 For now, we ignore lexical block scopes within the function.
1838 The problem is that AT&T cc does not define a DWARF lexical
1839 block scope for the function itself, while gcc defines a
1840 lexical block scope for the function. We need to think about
1841 how to handle this difference, or if it is even a problem.
1846 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1847 struct dieinfo
*dip
;
1850 struct objfile
*objfile
;
1852 register struct context_stack
*new;
1854 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1855 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1857 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1858 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1860 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1862 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1863 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1865 new = push_context (0, dip
-> at_low_pc
);
1866 new -> name
= new_symbol (dip
, objfile
);
1867 list_in_scope
= &local_symbols
;
1868 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1869 new = pop_context ();
1870 /* Make a block for the local symbols within. */
1871 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1872 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1873 list_in_scope
= &file_symbols
;
1881 handle_producer -- process the AT_producer attribute
1885 Perform any operations that depend on finding a particular
1886 AT_producer attribute.
1891 handle_producer (producer
)
1895 /* If this compilation unit was compiled with g++ or gcc, then set the
1896 processing_gcc_compilation flag. */
1898 processing_gcc_compilation
=
1899 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1900 /* start-sanitize-chill */
1901 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1902 /* end-sanitize-chill */
1903 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1905 /* Select a demangling style if we can identify the producer and if
1906 the current style is auto. We leave the current style alone if it
1907 is not auto. We also leave the demangling style alone if we find a
1908 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1910 #if 1 /* Works, but is experimental. -fnf */
1911 if (AUTO_DEMANGLING
)
1913 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1915 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1917 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1919 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1921 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1923 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1934 read_file_scope -- process all dies within a file scope
1938 Process all dies within a given file scope. We are passed a
1939 pointer to the die information structure for the die which
1940 starts the file scope, and pointers into the raw die data which
1941 mark the range of dies within the file scope.
1943 When the partial symbol table is built, the file offset for the line
1944 number table for each compilation unit is saved in the partial symbol
1945 table entry for that compilation unit. As the symbols for each
1946 compilation unit are read, the line number table is read into memory
1947 and the variable lnbase is set to point to it. Thus all we have to
1948 do is use lnbase to access the line number table for the current
1953 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1954 struct dieinfo
*dip
;
1957 struct objfile
*objfile
;
1959 struct cleanup
*back_to
;
1960 struct symtab
*symtab
;
1962 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1963 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1965 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1966 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1968 set_cu_language (dip
);
1969 if (dip
-> at_producer
!= NULL
)
1971 handle_producer (dip
-> at_producer
);
1973 numutypes
= (enddie
- thisdie
) / 4;
1974 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1975 back_to
= make_cleanup (free
, utypes
);
1976 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1977 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1978 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1979 decode_line_numbers (lnbase
);
1980 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1981 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1984 symtab
-> language
= cu_language
;
1986 do_cleanups (back_to
);
1995 process_dies -- process a range of DWARF Information Entries
1999 static void process_dies (char *thisdie, char *enddie,
2000 struct objfile *objfile)
2004 Process all DIE's in a specified range. May be (and almost
2005 certainly will be) called recursively.
2009 process_dies (thisdie
, enddie
, objfile
)
2012 struct objfile
*objfile
;
2017 while (thisdie
< enddie
)
2019 basicdieinfo (&di
, thisdie
, objfile
);
2020 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2024 else if (di
.die_tag
== TAG_padding
)
2026 nextdie
= thisdie
+ di
.die_length
;
2030 completedieinfo (&di
, objfile
);
2031 if (di
.at_sibling
!= 0)
2033 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2037 nextdie
= thisdie
+ di
.die_length
;
2041 case TAG_compile_unit
:
2042 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
2044 case TAG_global_subroutine
:
2045 case TAG_subroutine
:
2046 if (di
.has_at_low_pc
)
2048 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
2051 case TAG_lexical_block
:
2052 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
2054 case TAG_class_type
:
2055 case TAG_structure_type
:
2056 case TAG_union_type
:
2057 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
2059 case TAG_enumeration_type
:
2060 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
2062 case TAG_subroutine_type
:
2063 read_subroutine_type (&di
, thisdie
, nextdie
);
2065 case TAG_array_type
:
2066 dwarf_read_array_type (&di
);
2068 case TAG_pointer_type
:
2069 read_tag_pointer_type (&di
);
2071 case TAG_string_type
:
2072 read_tag_string_type (&di
);
2075 new_symbol (&di
, objfile
);
2087 decode_line_numbers -- decode a line number table fragment
2091 static void decode_line_numbers (char *tblscan, char *tblend,
2092 long length, long base, long line, long pc)
2096 Translate the DWARF line number information to gdb form.
2098 The ".line" section contains one or more line number tables, one for
2099 each ".line" section from the objects that were linked.
2101 The AT_stmt_list attribute for each TAG_source_file entry in the
2102 ".debug" section contains the offset into the ".line" section for the
2103 start of the table for that file.
2105 The table itself has the following structure:
2107 <table length><base address><source statement entry>
2108 4 bytes 4 bytes 10 bytes
2110 The table length is the total size of the table, including the 4 bytes
2111 for the length information.
2113 The base address is the address of the first instruction generated
2114 for the source file.
2116 Each source statement entry has the following structure:
2118 <line number><statement position><address delta>
2119 4 bytes 2 bytes 4 bytes
2121 The line number is relative to the start of the file, starting with
2124 The statement position either -1 (0xFFFF) or the number of characters
2125 from the beginning of the line to the beginning of the statement.
2127 The address delta is the difference between the base address and
2128 the address of the first instruction for the statement.
2130 Note that we must copy the bytes from the packed table to our local
2131 variables before attempting to use them, to avoid alignment problems
2132 on some machines, particularly RISC processors.
2136 Does gdb expect the line numbers to be sorted? They are now by
2137 chance/luck, but are not required to be. (FIXME)
2139 The line with number 0 is unused, gdb apparently can discover the
2140 span of the last line some other way. How? (FIXME)
2144 decode_line_numbers (linetable
)
2149 unsigned long length
;
2154 if (linetable
!= NULL
)
2156 tblscan
= tblend
= linetable
;
2157 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2159 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2161 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2162 GET_UNSIGNED
, current_objfile
);
2163 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2165 while (tblscan
< tblend
)
2167 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2169 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2170 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2172 tblscan
+= SIZEOF_LINETBL_DELTA
;
2176 record_line (current_subfile
, line
, pc
);
2186 locval -- compute the value of a location attribute
2190 static int locval (char *loc)
2194 Given pointer to a string of bytes that define a location, compute
2195 the location and return the value.
2197 When computing values involving the current value of the frame pointer,
2198 the value zero is used, which results in a value relative to the frame
2199 pointer, rather than the absolute value. This is what GDB wants
2202 When the result is a register number, the global isreg flag is set,
2203 otherwise it is cleared. This is a kludge until we figure out a better
2204 way to handle the problem. Gdb's design does not mesh well with the
2205 DWARF notion of a location computing interpreter, which is a shame
2206 because the flexibility goes unused.
2210 Note that stack[0] is unused except as a default error return.
2211 Note that stack overflow is not yet handled.
2218 unsigned short nbytes
;
2219 unsigned short locsize
;
2220 auto long stack
[64];
2227 nbytes
= attribute_size (AT_location
);
2228 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2230 end
= loc
+ locsize
;
2235 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2238 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2240 loc
+= SIZEOF_LOC_ATOM_CODE
;
2241 switch (loc_atom_code
)
2248 /* push register (number) */
2249 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2250 GET_UNSIGNED
, current_objfile
);
2251 loc
+= loc_value_size
;
2255 /* push value of register (number) */
2256 /* Actually, we compute the value as if register has 0 */
2258 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2260 loc
+= loc_value_size
;
2263 stack
[++stacki
] = 0;
2267 stack
[++stacki
] = 0;
2269 complain (&basereg_not_handled
, DIE_ID
, DIE_NAME
, regno
);
2273 /* push address (relocated address) */
2274 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2275 GET_UNSIGNED
, current_objfile
);
2276 loc
+= loc_value_size
;
2279 /* push constant (number) FIXME: signed or unsigned! */
2280 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2281 GET_SIGNED
, current_objfile
);
2282 loc
+= loc_value_size
;
2285 /* pop, deref and push 2 bytes (as a long) */
2286 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2288 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2289 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2291 case OP_ADD
: /* pop top 2 items, add, push result */
2292 stack
[stacki
- 1] += stack
[stacki
];
2297 return (stack
[stacki
]);
2304 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2308 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2312 When expanding a partial symbol table entry to a full symbol table
2313 entry, this is the function that gets called to read in the symbols
2314 for the compilation unit.
2316 Returns a pointer to the newly constructed symtab (which is now
2317 the new first one on the objfile's symtab list).
2320 static struct symtab
*
2321 read_ofile_symtab (pst
)
2322 struct partial_symtab
*pst
;
2324 struct cleanup
*back_to
;
2325 unsigned long lnsize
;
2328 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2330 abfd
= pst
-> objfile
-> obfd
;
2331 current_objfile
= pst
-> objfile
;
2333 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2334 unit, seek to the location in the file, and read in all the DIE's. */
2337 dbsize
= DBLENGTH (pst
);
2338 dbbase
= xmalloc (dbsize
);
2339 dbroff
= DBROFF(pst
);
2340 foffset
= DBFOFF(pst
) + dbroff
;
2341 base_section_offsets
= pst
->section_offsets
;
2342 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2343 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2344 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2347 error ("can't read DWARF data");
2349 back_to
= make_cleanup (free
, dbbase
);
2351 /* If there is a line number table associated with this compilation unit
2352 then read the size of this fragment in bytes, from the fragment itself.
2353 Allocate a buffer for the fragment and read it in for future
2359 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2360 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2361 sizeof (lnsizedata
)))
2363 error ("can't read DWARF line number table size");
2365 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2366 GET_UNSIGNED
, pst
-> objfile
);
2367 lnbase
= xmalloc (lnsize
);
2368 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2369 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2372 error ("can't read DWARF line numbers");
2374 make_cleanup (free
, lnbase
);
2377 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2378 do_cleanups (back_to
);
2379 current_objfile
= NULL
;
2380 return (pst
-> objfile
-> symtabs
);
2387 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2391 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2395 Called once for each partial symbol table entry that needs to be
2396 expanded into a full symbol table entry.
2401 psymtab_to_symtab_1 (pst
)
2402 struct partial_symtab
*pst
;
2405 struct cleanup
*old_chain
;
2411 warning ("psymtab for %s already read in. Shouldn't happen.",
2416 /* Read in all partial symtabs on which this one is dependent */
2417 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2419 if (!pst
-> dependencies
[i
] -> readin
)
2421 /* Inform about additional files that need to be read in. */
2424 fputs_filtered (" ", stdout
);
2426 fputs_filtered ("and ", stdout
);
2428 printf_filtered ("%s...",
2429 pst
-> dependencies
[i
] -> filename
);
2431 fflush (stdout
); /* Flush output */
2433 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2436 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2439 old_chain
= make_cleanup (really_free_pendings
, 0);
2440 pst
-> symtab
= read_ofile_symtab (pst
);
2443 printf_filtered ("%d DIE's, sorting...", diecount
);
2447 sort_symtab_syms (pst
-> symtab
);
2448 do_cleanups (old_chain
);
2459 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2463 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2467 This is the DWARF support entry point for building a full symbol
2468 table entry from a partial symbol table entry. We are passed a
2469 pointer to the partial symbol table entry that needs to be expanded.
2474 dwarf_psymtab_to_symtab (pst
)
2475 struct partial_symtab
*pst
;
2482 warning ("psymtab for %s already read in. Shouldn't happen.",
2487 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2489 /* Print the message now, before starting serious work, to avoid
2490 disconcerting pauses. */
2493 printf_filtered ("Reading in symbols for %s...",
2498 psymtab_to_symtab_1 (pst
);
2500 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2501 we need to do an equivalent or is this something peculiar to
2503 Match with global symbols. This only needs to be done once,
2504 after all of the symtabs and dependencies have been read in.
2506 scan_file_globals (pst
-> objfile
);
2509 /* Finish up the verbose info message. */
2512 printf_filtered ("done.\n");
2524 init_psymbol_list -- initialize storage for partial symbols
2528 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2532 Initializes storage for all of the partial symbols that will be
2533 created by dwarf_build_psymtabs and subsidiaries.
2537 init_psymbol_list (objfile
, total_symbols
)
2538 struct objfile
*objfile
;
2541 /* Free any previously allocated psymbol lists. */
2543 if (objfile
-> global_psymbols
.list
)
2545 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2547 if (objfile
-> static_psymbols
.list
)
2549 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2552 /* Current best guess is that there are approximately a twentieth
2553 of the total symbols (in a debugging file) are global or static
2556 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2557 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2558 objfile
-> global_psymbols
.next
=
2559 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2560 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2561 * sizeof (struct partial_symbol
));
2562 objfile
-> static_psymbols
.next
=
2563 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2564 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2565 * sizeof (struct partial_symbol
));
2572 add_enum_psymbol -- add enumeration members to partial symbol table
2576 Given pointer to a DIE that is known to be for an enumeration,
2577 extract the symbolic names of the enumeration members and add
2578 partial symbols for them.
2582 add_enum_psymbol (dip
, objfile
)
2583 struct dieinfo
*dip
;
2584 struct objfile
*objfile
;
2588 unsigned short blocksz
;
2591 if ((scan
= dip
-> at_element_list
) != NULL
)
2593 if (dip
-> short_element_list
)
2595 nbytes
= attribute_size (AT_short_element_list
);
2599 nbytes
= attribute_size (AT_element_list
);
2601 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2603 listend
= scan
+ blocksz
;
2604 while (scan
< listend
)
2606 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2607 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2608 objfile
-> static_psymbols
, 0, cu_language
,
2610 scan
+= strlen (scan
) + 1;
2619 add_partial_symbol -- add symbol to partial symbol table
2623 Given a DIE, if it is one of the types that we want to
2624 add to a partial symbol table, finish filling in the die info
2625 and then add a partial symbol table entry for it.
2629 The caller must ensure that the DIE has a valid name attribute.
2633 add_partial_symbol (dip
, objfile
)
2634 struct dieinfo
*dip
;
2635 struct objfile
*objfile
;
2637 switch (dip
-> die_tag
)
2639 case TAG_global_subroutine
:
2640 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2642 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2643 VAR_NAMESPACE
, LOC_BLOCK
,
2644 objfile
-> global_psymbols
,
2645 dip
-> at_low_pc
, cu_language
, objfile
);
2647 case TAG_global_variable
:
2648 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2650 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2651 VAR_NAMESPACE
, LOC_STATIC
,
2652 objfile
-> global_psymbols
,
2653 0, cu_language
, objfile
);
2655 case TAG_subroutine
:
2656 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2657 VAR_NAMESPACE
, LOC_BLOCK
,
2658 objfile
-> static_psymbols
,
2659 dip
-> at_low_pc
, cu_language
, objfile
);
2661 case TAG_local_variable
:
2662 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2663 VAR_NAMESPACE
, LOC_STATIC
,
2664 objfile
-> static_psymbols
,
2665 0, cu_language
, objfile
);
2668 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2669 VAR_NAMESPACE
, LOC_TYPEDEF
,
2670 objfile
-> static_psymbols
,
2671 0, cu_language
, objfile
);
2673 case TAG_class_type
:
2674 case TAG_structure_type
:
2675 case TAG_union_type
:
2676 case TAG_enumeration_type
:
2677 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2678 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2679 objfile
-> static_psymbols
,
2680 0, cu_language
, objfile
);
2681 if (cu_language
== language_cplus
)
2683 /* For C++, these implicitly act as typedefs as well. */
2684 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2685 VAR_NAMESPACE
, LOC_TYPEDEF
,
2686 objfile
-> static_psymbols
,
2687 0, cu_language
, objfile
);
2697 scan_partial_symbols -- scan DIE's within a single compilation unit
2701 Process the DIE's within a single compilation unit, looking for
2702 interesting DIE's that contribute to the partial symbol table entry
2703 for this compilation unit.
2707 There are some DIE's that may appear both at file scope and within
2708 the scope of a function. We are only interested in the ones at file
2709 scope, and the only way to tell them apart is to keep track of the
2710 scope. For example, consider the test case:
2715 for which the relevant DWARF segment has the structure:
2718 0x23 global subrtn sibling 0x9b
2720 fund_type FT_integer
2725 0x23 local var sibling 0x97
2727 fund_type FT_integer
2728 location OP_BASEREG 0xe
2735 0x1d local var sibling 0xb8
2737 fund_type FT_integer
2738 location OP_ADDR 0x800025dc
2743 We want to include the symbol 'i' in the partial symbol table, but
2744 not the symbol 'j'. In essence, we want to skip all the dies within
2745 the scope of a TAG_global_subroutine DIE.
2747 Don't attempt to add anonymous structures or unions since they have
2748 no name. Anonymous enumerations however are processed, because we
2749 want to extract their member names (the check for a tag name is
2752 Also, for variables and subroutines, check that this is the place
2753 where the actual definition occurs, rather than just a reference
2758 scan_partial_symbols (thisdie
, enddie
, objfile
)
2761 struct objfile
*objfile
;
2767 while (thisdie
< enddie
)
2769 basicdieinfo (&di
, thisdie
, objfile
);
2770 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2776 nextdie
= thisdie
+ di
.die_length
;
2777 /* To avoid getting complete die information for every die, we
2778 only do it (below) for the cases we are interested in. */
2781 case TAG_global_subroutine
:
2782 case TAG_subroutine
:
2783 completedieinfo (&di
, objfile
);
2784 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2786 add_partial_symbol (&di
, objfile
);
2787 /* If there is a sibling attribute, adjust the nextdie
2788 pointer to skip the entire scope of the subroutine.
2789 Apply some sanity checking to make sure we don't
2790 overrun or underrun the range of remaining DIE's */
2791 if (di
.at_sibling
!= 0)
2793 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2794 if ((temp
< thisdie
) || (temp
>= enddie
))
2796 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2806 case TAG_global_variable
:
2807 case TAG_local_variable
:
2808 completedieinfo (&di
, objfile
);
2809 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2811 add_partial_symbol (&di
, objfile
);
2815 case TAG_class_type
:
2816 case TAG_structure_type
:
2817 case TAG_union_type
:
2818 completedieinfo (&di
, objfile
);
2821 add_partial_symbol (&di
, objfile
);
2824 case TAG_enumeration_type
:
2825 completedieinfo (&di
, objfile
);
2828 add_partial_symbol (&di
, objfile
);
2830 add_enum_psymbol (&di
, objfile
);
2842 scan_compilation_units -- build a psymtab entry for each compilation
2846 This is the top level dwarf parsing routine for building partial
2849 It scans from the beginning of the DWARF table looking for the first
2850 TAG_compile_unit DIE, and then follows the sibling chain to locate
2851 each additional TAG_compile_unit DIE.
2853 For each TAG_compile_unit DIE it creates a partial symtab structure,
2854 calls a subordinate routine to collect all the compilation unit's
2855 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2856 new partial symtab structure into the partial symbol table. It also
2857 records the appropriate information in the partial symbol table entry
2858 to allow the chunk of DIE's and line number table for this compilation
2859 unit to be located and re-read later, to generate a complete symbol
2860 table entry for the compilation unit.
2862 Thus it effectively partitions up a chunk of DIE's for multiple
2863 compilation units into smaller DIE chunks and line number tables,
2864 and associates them with a partial symbol table entry.
2868 If any compilation unit has no line number table associated with
2869 it for some reason (a missing at_stmt_list attribute, rather than
2870 just one with a value of zero, which is valid) then we ensure that
2871 the recorded file offset is zero so that the routine which later
2872 reads line number table fragments knows that there is no fragment
2882 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2887 struct objfile
*objfile
;
2891 struct partial_symtab
*pst
;
2894 file_ptr curlnoffset
;
2896 while (thisdie
< enddie
)
2898 basicdieinfo (&di
, thisdie
, objfile
);
2899 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2903 else if (di
.die_tag
!= TAG_compile_unit
)
2905 nextdie
= thisdie
+ di
.die_length
;
2909 completedieinfo (&di
, objfile
);
2910 set_cu_language (&di
);
2911 if (di
.at_sibling
!= 0)
2913 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2917 nextdie
= thisdie
+ di
.die_length
;
2919 curoff
= thisdie
- dbbase
;
2920 culength
= nextdie
- thisdie
;
2921 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2923 /* First allocate a new partial symbol table structure */
2925 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2926 di
.at_name
, di
.at_low_pc
,
2927 objfile
-> global_psymbols
.next
,
2928 objfile
-> static_psymbols
.next
);
2930 pst
-> texthigh
= di
.at_high_pc
;
2931 pst
-> read_symtab_private
= (char *)
2932 obstack_alloc (&objfile
-> psymbol_obstack
,
2933 sizeof (struct dwfinfo
));
2934 DBFOFF (pst
) = dbfoff
;
2935 DBROFF (pst
) = curoff
;
2936 DBLENGTH (pst
) = culength
;
2937 LNFOFF (pst
) = curlnoffset
;
2938 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2940 /* Now look for partial symbols */
2942 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2944 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2945 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2946 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2947 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2948 sort_pst_symbols (pst
);
2949 /* If there is already a psymtab or symtab for a file of this name,
2950 remove it. (If there is a symtab, more drastic things also
2951 happen.) This happens in VxWorks. */
2952 free_named_symtabs (pst
-> filename
);
2962 new_symbol -- make a symbol table entry for a new symbol
2966 static struct symbol *new_symbol (struct dieinfo *dip,
2967 struct objfile *objfile)
2971 Given a pointer to a DWARF information entry, figure out if we need
2972 to make a symbol table entry for it, and if so, create a new entry
2973 and return a pointer to it.
2976 static struct symbol
*
2977 new_symbol (dip
, objfile
)
2978 struct dieinfo
*dip
;
2979 struct objfile
*objfile
;
2981 struct symbol
*sym
= NULL
;
2983 if (dip
-> at_name
!= NULL
)
2985 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2986 sizeof (struct symbol
));
2987 memset (sym
, 0, sizeof (struct symbol
));
2988 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2989 &objfile
->symbol_obstack
);
2990 /* default assumptions */
2991 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2992 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2993 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2995 /* If this symbol is from a C++ compilation, then attempt to cache the
2996 demangled form for future reference. This is a typical time versus
2997 space tradeoff, that was decided in favor of time because it sped up
2998 C++ symbol lookups by a factor of about 20. */
3000 SYMBOL_LANGUAGE (sym
) = cu_language
;
3001 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
-> symbol_obstack
);
3002 switch (dip
-> die_tag
)
3005 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
3006 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3008 case TAG_global_subroutine
:
3009 case TAG_subroutine
:
3010 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
3011 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
3012 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3013 if (dip
-> die_tag
== TAG_global_subroutine
)
3015 add_symbol_to_list (sym
, &global_symbols
);
3019 add_symbol_to_list (sym
, list_in_scope
);
3022 case TAG_global_variable
:
3023 if (dip
-> at_location
!= NULL
)
3025 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3026 add_symbol_to_list (sym
, &global_symbols
);
3027 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3028 SYMBOL_VALUE (sym
) += baseaddr
;
3031 case TAG_local_variable
:
3032 if (dip
-> at_location
!= NULL
)
3034 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3035 add_symbol_to_list (sym
, list_in_scope
);
3038 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3042 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3046 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3047 SYMBOL_VALUE (sym
) += baseaddr
;
3051 case TAG_formal_parameter
:
3052 if (dip
-> at_location
!= NULL
)
3054 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3056 add_symbol_to_list (sym
, list_in_scope
);
3059 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3063 SYMBOL_CLASS (sym
) = LOC_ARG
;
3066 case TAG_unspecified_parameters
:
3067 /* From varargs functions; gdb doesn't seem to have any interest in
3068 this information, so just ignore it for now. (FIXME?) */
3070 case TAG_class_type
:
3071 case TAG_structure_type
:
3072 case TAG_union_type
:
3073 case TAG_enumeration_type
:
3074 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3075 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3076 add_symbol_to_list (sym
, list_in_scope
);
3079 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3080 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3081 add_symbol_to_list (sym
, list_in_scope
);
3084 /* Not a tag we recognize. Hopefully we aren't processing trash
3085 data, but since we must specifically ignore things we don't
3086 recognize, there is nothing else we should do at this point. */
3097 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3101 static void synthesize_typedef (struct dieinfo *dip,
3102 struct objfile *objfile,
3107 Given a pointer to a DWARF information entry, synthesize a typedef
3108 for the name in the DIE, using the specified type.
3110 This is used for C++ class, structs, unions, and enumerations to
3111 set up the tag name as a type.
3116 synthesize_typedef (dip
, objfile
, type
)
3117 struct dieinfo
*dip
;
3118 struct objfile
*objfile
;
3121 struct symbol
*sym
= NULL
;
3123 if (dip
-> at_name
!= NULL
)
3125 sym
= (struct symbol
*)
3126 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3127 memset (sym
, 0, sizeof (struct symbol
));
3128 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3129 &objfile
->symbol_obstack
);
3130 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3131 SYMBOL_TYPE (sym
) = type
;
3132 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3133 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3134 add_symbol_to_list (sym
, list_in_scope
);
3142 decode_mod_fund_type -- decode a modified fundamental type
3146 static struct type *decode_mod_fund_type (char *typedata)
3150 Decode a block of data containing a modified fundamental
3151 type specification. TYPEDATA is a pointer to the block,
3152 which starts with a length containing the size of the rest
3153 of the block. At the end of the block is a fundmental type
3154 code value that gives the fundamental type. Everything
3155 in between are type modifiers.
3157 We simply compute the number of modifiers and call the general
3158 function decode_modified_type to do the actual work.
3161 static struct type
*
3162 decode_mod_fund_type (typedata
)
3165 struct type
*typep
= NULL
;
3166 unsigned short modcount
;
3169 /* Get the total size of the block, exclusive of the size itself */
3171 nbytes
= attribute_size (AT_mod_fund_type
);
3172 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3175 /* Deduct the size of the fundamental type bytes at the end of the block. */
3177 modcount
-= attribute_size (AT_fund_type
);
3179 /* Now do the actual decoding */
3181 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3189 decode_mod_u_d_type -- decode a modified user defined type
3193 static struct type *decode_mod_u_d_type (char *typedata)
3197 Decode a block of data containing a modified user defined
3198 type specification. TYPEDATA is a pointer to the block,
3199 which consists of a two byte length, containing the size
3200 of the rest of the block. At the end of the block is a
3201 four byte value that gives a reference to a user defined type.
3202 Everything in between are type modifiers.
3204 We simply compute the number of modifiers and call the general
3205 function decode_modified_type to do the actual work.
3208 static struct type
*
3209 decode_mod_u_d_type (typedata
)
3212 struct type
*typep
= NULL
;
3213 unsigned short modcount
;
3216 /* Get the total size of the block, exclusive of the size itself */
3218 nbytes
= attribute_size (AT_mod_u_d_type
);
3219 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3222 /* Deduct the size of the reference type bytes at the end of the block. */
3224 modcount
-= attribute_size (AT_user_def_type
);
3226 /* Now do the actual decoding */
3228 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3236 decode_modified_type -- decode modified user or fundamental type
3240 static struct type *decode_modified_type (char *modifiers,
3241 unsigned short modcount, int mtype)
3245 Decode a modified type, either a modified fundamental type or
3246 a modified user defined type. MODIFIERS is a pointer to the
3247 block of bytes that define MODCOUNT modifiers. Immediately
3248 following the last modifier is a short containing the fundamental
3249 type or a long containing the reference to the user defined
3250 type. Which one is determined by MTYPE, which is either
3251 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3252 type we are generating.
3254 We call ourself recursively to generate each modified type,`
3255 until MODCOUNT reaches zero, at which point we have consumed
3256 all the modifiers and generate either the fundamental type or
3257 user defined type. When the recursion unwinds, each modifier
3258 is applied in turn to generate the full modified type.
3262 If we find a modifier that we don't recognize, and it is not one
3263 of those reserved for application specific use, then we issue a
3264 warning and simply ignore the modifier.
3268 We currently ignore MOD_const and MOD_volatile. (FIXME)
3272 static struct type
*
3273 decode_modified_type (modifiers
, modcount
, mtype
)
3275 unsigned int modcount
;
3278 struct type
*typep
= NULL
;
3279 unsigned short fundtype
;
3288 case AT_mod_fund_type
:
3289 nbytes
= attribute_size (AT_fund_type
);
3290 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3292 typep
= decode_fund_type (fundtype
);
3294 case AT_mod_u_d_type
:
3295 nbytes
= attribute_size (AT_user_def_type
);
3296 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3298 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3300 typep
= alloc_utype (die_ref
, NULL
);
3304 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3305 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3311 modifier
= *modifiers
++;
3312 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3315 case MOD_pointer_to
:
3316 typep
= lookup_pointer_type (typep
);
3318 case MOD_reference_to
:
3319 typep
= lookup_reference_type (typep
);
3322 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3325 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3328 if (!(MOD_lo_user
<= (unsigned char) modifier
3329 && (unsigned char) modifier
<= MOD_hi_user
))
3331 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3343 decode_fund_type -- translate basic DWARF type to gdb base type
3347 Given an integer that is one of the fundamental DWARF types,
3348 translate it to one of the basic internal gdb types and return
3349 a pointer to the appropriate gdb type (a "struct type *").
3353 For robustness, if we are asked to translate a fundamental
3354 type that we are unprepared to deal with, we return int so
3355 callers can always depend upon a valid type being returned,
3356 and so gdb may at least do something reasonable by default.
3357 If the type is not in the range of those types defined as
3358 application specific types, we also issue a warning.
3361 static struct type
*
3362 decode_fund_type (fundtype
)
3363 unsigned int fundtype
;
3365 struct type
*typep
= NULL
;
3371 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3374 case FT_boolean
: /* Was FT_set in AT&T version */
3375 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3378 case FT_pointer
: /* (void *) */
3379 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3380 typep
= lookup_pointer_type (typep
);
3384 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3387 case FT_signed_char
:
3388 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3391 case FT_unsigned_char
:
3392 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3396 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3399 case FT_signed_short
:
3400 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3403 case FT_unsigned_short
:
3404 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3408 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3411 case FT_signed_integer
:
3412 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3415 case FT_unsigned_integer
:
3416 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3420 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3423 case FT_signed_long
:
3424 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3427 case FT_unsigned_long
:
3428 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3432 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3435 case FT_signed_long_long
:
3436 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3439 case FT_unsigned_long_long
:
3440 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3444 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3447 case FT_dbl_prec_float
:
3448 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3451 case FT_ext_prec_float
:
3452 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3456 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3459 case FT_dbl_prec_complex
:
3460 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3463 case FT_ext_prec_complex
:
3464 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3471 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3472 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3474 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3485 create_name -- allocate a fresh copy of a string on an obstack
3489 Given a pointer to a string and a pointer to an obstack, allocates
3490 a fresh copy of the string on the specified obstack.
3495 create_name (name
, obstackp
)
3497 struct obstack
*obstackp
;
3502 length
= strlen (name
) + 1;
3503 newname
= (char *) obstack_alloc (obstackp
, length
);
3504 strcpy (newname
, name
);
3512 basicdieinfo -- extract the minimal die info from raw die data
3516 void basicdieinfo (char *diep, struct dieinfo *dip,
3517 struct objfile *objfile)
3521 Given a pointer to raw DIE data, and a pointer to an instance of a
3522 die info structure, this function extracts the basic information
3523 from the DIE data required to continue processing this DIE, along
3524 with some bookkeeping information about the DIE.
3526 The information we absolutely must have includes the DIE tag,
3527 and the DIE length. If we need the sibling reference, then we
3528 will have to call completedieinfo() to process all the remaining
3531 Note that since there is no guarantee that the data is properly
3532 aligned in memory for the type of access required (indirection
3533 through anything other than a char pointer), and there is no
3534 guarantee that it is in the same byte order as the gdb host,
3535 we call a function which deals with both alignment and byte
3536 swapping issues. Possibly inefficient, but quite portable.
3538 We also take care of some other basic things at this point, such
3539 as ensuring that the instance of the die info structure starts
3540 out completely zero'd and that curdie is initialized for use
3541 in error reporting if we have a problem with the current die.
3545 All DIE's must have at least a valid length, thus the minimum
3546 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3547 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3548 are forced to be TAG_padding DIES.
3550 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3551 that if a padding DIE is used for alignment and the amount needed is
3552 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3553 enough to align to the next alignment boundry.
3555 We do some basic sanity checking here, such as verifying that the
3556 length of the die would not cause it to overrun the recorded end of
3557 the buffer holding the DIE info. If we find a DIE that is either
3558 too small or too large, we force it's length to zero which should
3559 cause the caller to take appropriate action.
3563 basicdieinfo (dip
, diep
, objfile
)
3564 struct dieinfo
*dip
;
3566 struct objfile
*objfile
;
3569 memset (dip
, 0, sizeof (struct dieinfo
));
3571 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3572 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3574 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3575 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3577 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3578 dip
-> die_length
= 0;
3580 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3582 dip
-> die_tag
= TAG_padding
;
3586 diep
+= SIZEOF_DIE_LENGTH
;
3587 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3596 completedieinfo -- finish reading the information for a given DIE
3600 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3604 Given a pointer to an already partially initialized die info structure,
3605 scan the raw DIE data and finish filling in the die info structure
3606 from the various attributes found.
3608 Note that since there is no guarantee that the data is properly
3609 aligned in memory for the type of access required (indirection
3610 through anything other than a char pointer), and there is no
3611 guarantee that it is in the same byte order as the gdb host,
3612 we call a function which deals with both alignment and byte
3613 swapping issues. Possibly inefficient, but quite portable.
3617 Each time we are called, we increment the diecount variable, which
3618 keeps an approximate count of the number of dies processed for
3619 each compilation unit. This information is presented to the user
3620 if the info_verbose flag is set.
3625 completedieinfo (dip
, objfile
)
3626 struct dieinfo
*dip
;
3627 struct objfile
*objfile
;
3629 char *diep
; /* Current pointer into raw DIE data */
3630 char *end
; /* Terminate DIE scan here */
3631 unsigned short attr
; /* Current attribute being scanned */
3632 unsigned short form
; /* Form of the attribute */
3633 int nbytes
; /* Size of next field to read */
3637 end
= diep
+ dip
-> die_length
;
3638 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3641 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3642 diep
+= SIZEOF_ATTRIBUTE
;
3643 if ((nbytes
= attribute_size (attr
)) == -1)
3645 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3652 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3656 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3660 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3664 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3668 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3670 dip
-> has_at_stmt_list
= 1;
3673 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3675 dip
-> at_low_pc
+= baseaddr
;
3676 dip
-> has_at_low_pc
= 1;
3679 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3681 dip
-> at_high_pc
+= baseaddr
;
3684 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3687 case AT_user_def_type
:
3688 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3689 GET_UNSIGNED
, objfile
);
3692 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3694 dip
-> has_at_byte_size
= 1;
3697 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3701 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3705 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3709 dip
-> at_location
= diep
;
3711 case AT_mod_fund_type
:
3712 dip
-> at_mod_fund_type
= diep
;
3714 case AT_subscr_data
:
3715 dip
-> at_subscr_data
= diep
;
3717 case AT_mod_u_d_type
:
3718 dip
-> at_mod_u_d_type
= diep
;
3720 case AT_element_list
:
3721 dip
-> at_element_list
= diep
;
3722 dip
-> short_element_list
= 0;
3724 case AT_short_element_list
:
3725 dip
-> at_element_list
= diep
;
3726 dip
-> short_element_list
= 1;
3728 case AT_discr_value
:
3729 dip
-> at_discr_value
= diep
;
3731 case AT_string_length
:
3732 dip
-> at_string_length
= diep
;
3735 dip
-> at_name
= diep
;
3738 /* For now, ignore any "hostname:" portion, since gdb doesn't
3739 know how to deal with it. (FIXME). */
3740 dip
-> at_comp_dir
= strrchr (diep
, ':');
3741 if (dip
-> at_comp_dir
!= NULL
)
3743 dip
-> at_comp_dir
++;
3747 dip
-> at_comp_dir
= diep
;
3751 dip
-> at_producer
= diep
;
3753 case AT_start_scope
:
3754 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3757 case AT_stride_size
:
3758 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3762 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3766 dip
-> at_prototyped
= diep
;
3769 /* Found an attribute that we are unprepared to handle. However
3770 it is specifically one of the design goals of DWARF that
3771 consumers should ignore unknown attributes. As long as the
3772 form is one that we recognize (so we know how to skip it),
3773 we can just ignore the unknown attribute. */
3776 form
= FORM_FROM_ATTR (attr
);
3790 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3793 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3796 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3799 diep
+= strlen (diep
) + 1;
3802 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3813 target_to_host -- swap in target data to host
3817 target_to_host (char *from, int nbytes, int signextend,
3818 struct objfile *objfile)
3822 Given pointer to data in target format in FROM, a byte count for
3823 the size of the data in NBYTES, a flag indicating whether or not
3824 the data is signed in SIGNEXTEND, and a pointer to the current
3825 objfile in OBJFILE, convert the data to host format and return
3826 the converted value.
3830 FIXME: If we read data that is known to be signed, and expect to
3831 use it as signed data, then we need to explicitly sign extend the
3832 result until the bfd library is able to do this for us.
3836 static unsigned long
3837 target_to_host (from
, nbytes
, signextend
, objfile
)
3840 int signextend
; /* FIXME: Unused */
3841 struct objfile
*objfile
;
3843 unsigned long rtnval
;
3848 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3851 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3854 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3857 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3860 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3871 attribute_size -- compute size of data for a DWARF attribute
3875 static int attribute_size (unsigned int attr)
3879 Given a DWARF attribute in ATTR, compute the size of the first
3880 piece of data associated with this attribute and return that
3883 Returns -1 for unrecognized attributes.
3888 attribute_size (attr
)
3891 int nbytes
; /* Size of next data for this attribute */
3892 unsigned short form
; /* Form of the attribute */
3894 form
= FORM_FROM_ATTR (attr
);
3897 case FORM_STRING
: /* A variable length field is next */
3900 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3901 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3904 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3905 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3906 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3909 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3912 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3913 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3916 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);