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 /* start-sanitize-chill */
201 #ifndef CHILL_PRODUCER
202 #define CHILL_PRODUCER "GNU Chill "
204 /* end-sanitize-chill */
206 /* Flags to target_to_host() that tell whether or not the data object is
207 expected to be signed. Used, for example, when fetching a signed
208 integer in the target environment which is used as a signed integer
209 in the host environment, and the two environments have different sized
210 ints. In this case, *somebody* has to sign extend the smaller sized
213 #define GET_UNSIGNED 0 /* No sign extension required */
214 #define GET_SIGNED 1 /* Sign extension required */
216 /* Defines for things which are specified in the document "DWARF Debugging
217 Information Format" published by UNIX International, Programming Languages
218 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
220 #define SIZEOF_DIE_LENGTH 4
221 #define SIZEOF_DIE_TAG 2
222 #define SIZEOF_ATTRIBUTE 2
223 #define SIZEOF_FORMAT_SPECIFIER 1
224 #define SIZEOF_FMT_FT 2
225 #define SIZEOF_LINETBL_LENGTH 4
226 #define SIZEOF_LINETBL_LINENO 4
227 #define SIZEOF_LINETBL_STMT 2
228 #define SIZEOF_LINETBL_DELTA 4
229 #define SIZEOF_LOC_ATOM_CODE 1
231 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
233 /* Macros that return the sizes of various types of data in the target
236 FIXME: Currently these are just compile time constants (as they are in
237 other parts of gdb as well). They need to be able to get the right size
238 either from the bfd or possibly from the DWARF info. It would be nice if
239 the DWARF producer inserted DIES that describe the fundamental types in
240 the target environment into the DWARF info, similar to the way dbx stabs
241 producers produce information about their fundamental types. */
243 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
244 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
246 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
247 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
248 However, the Issue 2 DWARF specification from AT&T defines it as
249 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
250 For backwards compatibility with the AT&T compiler produced executables
251 we define AT_short_element_list for this variant. */
253 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
255 /* External variables referenced. */
257 extern int info_verbose
; /* From main.c; nonzero => verbose */
258 extern char *warning_pre_print
; /* From utils.c */
260 /* The DWARF debugging information consists of two major pieces,
261 one is a block of DWARF Information Entries (DIE's) and the other
262 is a line number table. The "struct dieinfo" structure contains
263 the information for a single DIE, the one currently being processed.
265 In order to make it easier to randomly access the attribute fields
266 of the current DIE, which are specifically unordered within the DIE,
267 each DIE is scanned and an instance of the "struct dieinfo"
268 structure is initialized.
270 Initialization is done in two levels. The first, done by basicdieinfo(),
271 just initializes those fields that are vital to deciding whether or not
272 to use this DIE, how to skip past it, etc. The second, done by the
273 function completedieinfo(), fills in the rest of the information.
275 Attributes which have block forms are not interpreted at the time
276 the DIE is scanned, instead we just save pointers to the start
277 of their value fields.
279 Some fields have a flag <name>_p that is set when the value of the
280 field is valid (I.E. we found a matching attribute in the DIE). Since
281 we may want to test for the presence of some attributes in the DIE,
282 such as AT_low_pc, without restricting the values of the field,
283 we need someway to note that we found such an attribute.
290 char * die
; /* Pointer to the raw DIE data */
291 unsigned long die_length
; /* Length of the raw DIE data */
292 DIE_REF die_ref
; /* Offset of this DIE */
293 unsigned short die_tag
; /* Tag for this DIE */
294 unsigned long at_padding
;
295 unsigned long at_sibling
;
298 unsigned short at_fund_type
;
299 BLOCK
* at_mod_fund_type
;
300 unsigned long at_user_def_type
;
301 BLOCK
* at_mod_u_d_type
;
302 unsigned short at_ordering
;
303 BLOCK
* at_subscr_data
;
304 unsigned long at_byte_size
;
305 unsigned short at_bit_offset
;
306 unsigned long at_bit_size
;
307 BLOCK
* at_element_list
;
308 unsigned long at_stmt_list
;
309 unsigned long at_low_pc
;
310 unsigned long at_high_pc
;
311 unsigned long at_language
;
312 unsigned long at_member
;
313 unsigned long at_discr
;
314 BLOCK
* at_discr_value
;
315 BLOCK
* at_string_length
;
318 unsigned long at_start_scope
;
319 unsigned long at_stride_size
;
320 unsigned long at_src_info
;
321 char * at_prototyped
;
322 unsigned int has_at_low_pc
:1;
323 unsigned int has_at_stmt_list
:1;
324 unsigned int has_at_byte_size
:1;
325 unsigned int short_element_list
:1;
328 static int diecount
; /* Approximate count of dies for compilation unit */
329 static struct dieinfo
*curdie
; /* For warnings and such */
331 static char *dbbase
; /* Base pointer to dwarf info */
332 static int dbsize
; /* Size of dwarf info in bytes */
333 static int dbroff
; /* Relative offset from start of .debug section */
334 static char *lnbase
; /* Base pointer to line section */
335 static int isreg
; /* Kludge to identify register variables */
336 static int offreg
; /* Kludge to identify basereg references */
338 /* This value is added to each symbol value. FIXME: Generalize to
339 the section_offsets structure used by dbxread (once this is done,
340 pass the appropriate section number to end_symtab). */
341 static CORE_ADDR baseaddr
; /* Add to each symbol value */
343 /* The section offsets used in the current psymtab or symtab. FIXME,
344 only used to pass one value (baseaddr) at the moment. */
345 static struct section_offsets
*base_section_offsets
;
347 /* Each partial symbol table entry contains a pointer to private data for the
348 read_symtab() function to use when expanding a partial symbol table entry
349 to a full symbol table entry. For DWARF debugging info, this data is
350 contained in the following structure and macros are provided for easy
351 access to the members given a pointer to a partial symbol table entry.
353 dbfoff Always the absolute file offset to the start of the ".debug"
354 section for the file containing the DIE's being accessed.
356 dbroff Relative offset from the start of the ".debug" access to the
357 first DIE to be accessed. When building the partial symbol
358 table, this value will be zero since we are accessing the
359 entire ".debug" section. When expanding a partial symbol
360 table entry, this value will be the offset to the first
361 DIE for the compilation unit containing the symbol that
362 triggers the expansion.
364 dblength The size of the chunk of DIE's being examined, in bytes.
366 lnfoff The absolute file offset to the line table fragment. Ignored
367 when building partial symbol tables, but used when expanding
368 them, and contains the absolute file offset to the fragment
369 of the ".line" section containing the line numbers for the
370 current compilation unit.
374 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
375 int dbroff
; /* Relative offset from start of .debug section */
376 int dblength
; /* Size of the chunk of DIE's being examined */
377 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
380 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
381 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
382 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
383 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
385 /* The generic symbol table building routines have separate lists for
386 file scope symbols and all all other scopes (local scopes). So
387 we need to select the right one to pass to add_symbol_to_list().
388 We do it by keeping a pointer to the correct list in list_in_scope.
390 FIXME: The original dwarf code just treated the file scope as the first
391 local scope, and all other local scopes as nested local scopes, and worked
392 fine. Check to see if we really need to distinguish these in buildsym.c */
394 struct pending
**list_in_scope
= &file_symbols
;
396 /* DIES which have user defined types or modified user defined types refer to
397 other DIES for the type information. Thus we need to associate the offset
398 of a DIE for a user defined type with a pointer to the type information.
400 Originally this was done using a simple but expensive algorithm, with an
401 array of unsorted structures, each containing an offset/type-pointer pair.
402 This array was scanned linearly each time a lookup was done. The result
403 was that gdb was spending over half it's startup time munging through this
404 array of pointers looking for a structure that had the right offset member.
406 The second attempt used the same array of structures, but the array was
407 sorted using qsort each time a new offset/type was recorded, and a binary
408 search was used to find the type pointer for a given DIE offset. This was
409 even slower, due to the overhead of sorting the array each time a new
410 offset/type pair was entered.
412 The third attempt uses a fixed size array of type pointers, indexed by a
413 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
414 we can divide any DIE offset by 4 to obtain a unique index into this fixed
415 size array. Since each element is a 4 byte pointer, it takes exactly as
416 much memory to hold this array as to hold the DWARF info for a given
417 compilation unit. But it gets freed as soon as we are done with it.
418 This has worked well in practice, as a reasonable tradeoff between memory
419 consumption and speed, without having to resort to much more complicated
422 static struct type
**utypes
; /* Pointer to array of user type pointers */
423 static int numutypes
; /* Max number of user type pointers */
425 /* Maintain an array of referenced fundamental types for the current
426 compilation unit being read. For DWARF version 1, we have to construct
427 the fundamental types on the fly, since no information about the
428 fundamental types is supplied. Each such fundamental type is created by
429 calling a language dependent routine to create the type, and then a
430 pointer to that type is then placed in the array at the index specified
431 by it's FT_<TYPENAME> value. The array has a fixed size set by the
432 FT_NUM_MEMBERS compile time constant, which is the number of predefined
433 fundamental types gdb knows how to construct. */
435 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
437 /* Record the language for the compilation unit which is currently being
438 processed. We know it once we have seen the TAG_compile_unit DIE,
439 and we need it while processing the DIE's for that compilation unit.
440 It is eventually saved in the symtab structure, but we don't finalize
441 the symtab struct until we have processed all the DIE's for the
442 compilation unit. We also need to get and save a pointer to the
443 language struct for this language, so we can call the language
444 dependent routines for doing things such as creating fundamental
447 static enum language cu_language
;
448 static const struct language_defn
*cu_language_defn
;
450 /* Forward declarations of static functions so we don't have to worry
451 about ordering within this file. */
454 attribute_size
PARAMS ((unsigned int));
457 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
460 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
463 handle_producer
PARAMS ((char *));
466 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
469 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
472 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
476 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
479 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
480 file_ptr
, struct objfile
*));
483 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
486 init_psymbol_list
PARAMS ((struct objfile
*, int));
489 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
492 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
495 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
498 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
500 static struct symtab
*
501 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
504 process_dies
PARAMS ((char *, char *, struct objfile
*));
507 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
511 decode_array_element_type
PARAMS ((char *));
514 decode_subscript_data_item
PARAMS ((char *, char *));
517 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
520 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
523 read_tag_string_type
PARAMS ((struct dieinfo
*dip
));
526 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
529 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
532 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
535 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
538 decode_line_numbers
PARAMS ((char *));
541 decode_die_type
PARAMS ((struct dieinfo
*));
544 decode_mod_fund_type
PARAMS ((char *));
547 decode_mod_u_d_type
PARAMS ((char *));
550 decode_modified_type
PARAMS ((char *, unsigned int, int));
553 decode_fund_type
PARAMS ((unsigned int));
556 create_name
PARAMS ((char *, struct obstack
*));
559 lookup_utype
PARAMS ((DIE_REF
));
562 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
564 static struct symbol
*
565 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
568 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
572 locval
PARAMS ((char *));
575 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
579 set_cu_language
PARAMS ((struct dieinfo
*));
582 dwarf_fundamental_type
PARAMS ((struct objfile
*, int));
589 dwarf_fundamental_type -- lookup or create a fundamental type
594 dwarf_fundamental_type (struct objfile *objfile, int typeid)
598 DWARF version 1 doesn't supply any fundamental type information,
599 so gdb has to construct such types. It has a fixed number of
600 fundamental types that it knows how to construct, which is the
601 union of all types that it knows how to construct for all languages
602 that it knows about. These are enumerated in gdbtypes.h.
604 As an example, assume we find a DIE that references a DWARF
605 fundamental type of FT_integer. We first look in the ftypes
606 array to see if we already have such a type, indexed by the
607 gdb internal value of FT_INTEGER. If so, we simply return a
608 pointer to that type. If not, then we ask an appropriate
609 language dependent routine to create a type FT_INTEGER, using
610 defaults reasonable for the current target machine, and install
611 that type in ftypes for future reference.
615 Pointer to a fundamental type.
620 dwarf_fundamental_type (objfile
, typeid)
621 struct objfile
*objfile
;
624 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
626 error ("internal error - invalid fundamental type id %d", typeid);
629 /* Look for this particular type in the fundamental type vector. If one is
630 not found, create and install one appropriate for the current language
631 and the current target machine. */
633 if (ftypes
[typeid] == NULL
)
635 ftypes
[typeid] = cu_language_defn
-> la_fund_type(objfile
, typeid);
638 return (ftypes
[typeid]);
645 set_cu_language -- set local copy of language for compilation unit
650 set_cu_language (struct dieinfo *dip)
654 Decode the language attribute for a compilation unit DIE and
655 remember what the language was. We use this at various times
656 when processing DIE's for a given compilation unit.
665 set_cu_language (dip
)
668 switch (dip
-> at_language
)
672 cu_language
= language_c
;
674 case LANG_C_PLUS_PLUS
:
675 cu_language
= language_cplus
;
677 /* start-sanitize-chill */
679 cu_language
= language_chill
;
681 /* end-sanitize-chill */
683 cu_language
= language_m2
;
691 /* We don't know anything special about these yet. */
692 cu_language
= language_unknown
;
695 /* If no at_language, try to deduce one from the filename */
696 cu_language
= deduce_language_from_filename (dip
-> at_name
);
699 cu_language_defn
= language_def (cu_language
);
706 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
710 void dwarf_build_psymtabs (struct objfile *objfile,
711 struct section_offsets *section_offsets,
712 int mainline, file_ptr dbfoff, unsigned int dbfsize,
713 file_ptr lnoffset, unsigned int lnsize)
717 This function is called upon to build partial symtabs from files
718 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
720 It is passed a bfd* containing the DIES
721 and line number information, the corresponding filename for that
722 file, a base address for relocating the symbols, a flag indicating
723 whether or not this debugging information is from a "main symbol
724 table" rather than a shared library or dynamically linked file,
725 and file offset/size pairs for the DIE information and line number
735 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
737 struct objfile
*objfile
;
738 struct section_offsets
*section_offsets
;
741 unsigned int dbfsize
;
745 bfd
*abfd
= objfile
->obfd
;
746 struct cleanup
*back_to
;
748 current_objfile
= objfile
;
750 dbbase
= xmalloc (dbsize
);
752 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
753 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
756 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
758 back_to
= make_cleanup (free
, dbbase
);
760 /* If we are reinitializing, or if we have never loaded syms yet, init.
761 Since we have no idea how many DIES we are looking at, we just guess
762 some arbitrary value. */
764 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
765 objfile
-> static_psymbols
.size
== 0)
767 init_psymbol_list (objfile
, 1024);
770 /* Save the relocation factor where everybody can see it. */
772 base_section_offsets
= section_offsets
;
773 baseaddr
= ANOFFSET (section_offsets
, 0);
775 /* Follow the compilation unit sibling chain, building a partial symbol
776 table entry for each one. Save enough information about each compilation
777 unit to locate the full DWARF information later. */
779 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
781 do_cleanups (back_to
);
782 current_objfile
= NULL
;
790 record_minimal_symbol -- add entry to gdb's minimal symbol table
794 static void record_minimal_symbol (char *name, CORE_ADDR address,
795 enum minimal_symbol_type ms_type,
796 struct objfile *objfile)
800 Given a pointer to the name of a symbol that should be added to the
801 minimal symbol table, and the address associated with that
802 symbol, records this information for later use in building the
803 minimal symbol table.
808 record_minimal_symbol (name
, address
, ms_type
, objfile
)
811 enum minimal_symbol_type ms_type
;
812 struct objfile
*objfile
;
814 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
815 prim_record_minimal_symbol (name
, address
, ms_type
);
822 read_lexical_block_scope -- process all dies in a lexical block
826 static void read_lexical_block_scope (struct dieinfo *dip,
827 char *thisdie, char *enddie)
831 Process all the DIES contained within a lexical block scope.
832 Start a new scope, process the dies, and then close the scope.
837 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
841 struct objfile
*objfile
;
843 register struct context_stack
*new;
845 push_context (0, dip
-> at_low_pc
);
846 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
847 new = pop_context ();
848 if (local_symbols
!= NULL
)
850 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
851 dip
-> at_high_pc
, objfile
);
853 local_symbols
= new -> locals
;
860 lookup_utype -- look up a user defined type from die reference
864 static type *lookup_utype (DIE_REF die_ref)
868 Given a DIE reference, lookup the user defined type associated with
869 that DIE, if it has been registered already. If not registered, then
870 return NULL. Alloc_utype() can be called to register an empty
871 type for this reference, which will be filled in later when the
872 actual referenced DIE is processed.
876 lookup_utype (die_ref
)
879 struct type
*type
= NULL
;
882 utypeidx
= (die_ref
- dbroff
) / 4;
883 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
885 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
889 type
= *(utypes
+ utypeidx
);
899 alloc_utype -- add a user defined type for die reference
903 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
907 Given a die reference DIE_REF, and a possible pointer to a user
908 defined type UTYPEP, register that this reference has a user
909 defined type and either use the specified type in UTYPEP or
910 make a new empty type that will be filled in later.
912 We should only be called after calling lookup_utype() to verify that
913 there is not currently a type registered for DIE_REF.
917 alloc_utype (die_ref
, utypep
)
924 utypeidx
= (die_ref
- dbroff
) / 4;
925 typep
= utypes
+ utypeidx
;
926 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
928 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
929 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
931 else if (*typep
!= NULL
)
934 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
940 utypep
= alloc_type (current_objfile
);
951 decode_die_type -- return a type for a specified die
955 static struct type *decode_die_type (struct dieinfo *dip)
959 Given a pointer to a die information structure DIP, decode the
960 type of the die and return a pointer to the decoded type. All
961 dies without specific types default to type int.
965 decode_die_type (dip
)
968 struct type
*type
= NULL
;
970 if (dip
-> at_fund_type
!= 0)
972 type
= decode_fund_type (dip
-> at_fund_type
);
974 else if (dip
-> at_mod_fund_type
!= NULL
)
976 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
978 else if (dip
-> at_user_def_type
)
980 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
982 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
985 else if (dip
-> at_mod_u_d_type
)
987 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
991 type
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1000 struct_type -- compute and return the type for a struct or union
1004 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
1005 char *enddie, struct objfile *objfile)
1009 Given pointer to a die information structure for a die which
1010 defines a union or structure (and MUST define one or the other),
1011 and pointers to the raw die data that define the range of dies which
1012 define the members, compute and return the user defined type for the
1016 static struct type
*
1017 struct_type (dip
, thisdie
, enddie
, objfile
)
1018 struct dieinfo
*dip
;
1021 struct objfile
*objfile
;
1025 struct nextfield
*next
;
1028 struct nextfield
*list
= NULL
;
1029 struct nextfield
*new;
1035 #if !BITS_BIG_ENDIAN
1039 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1041 /* No forward references created an empty type, so install one now */
1042 type
= alloc_utype (dip
-> die_ref
, NULL
);
1044 INIT_CPLUS_SPECIFIC(type
);
1045 switch (dip
-> die_tag
)
1047 case TAG_class_type
:
1048 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
1051 case TAG_structure_type
:
1052 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1055 case TAG_union_type
:
1056 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1060 /* Should never happen */
1061 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
1063 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
1066 /* Some compilers try to be helpful by inventing "fake" names for
1067 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1068 Thanks, but no thanks... */
1069 if (dip
-> at_name
!= NULL
1070 && *dip
-> at_name
!= '~'
1071 && *dip
-> at_name
!= '.')
1073 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
1074 tpart1
, " ", dip
-> at_name
);
1076 /* Use whatever size is known. Zero is a valid size. We might however
1077 wish to check has_at_byte_size to make sure that some byte size was
1078 given explicitly, but DWARF doesn't specify that explicit sizes of
1079 zero have to present, so complaining about missing sizes should
1080 probably not be the default. */
1081 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1082 thisdie
+= dip
-> die_length
;
1083 while (thisdie
< enddie
)
1085 basicdieinfo (&mbr
, thisdie
, objfile
);
1086 completedieinfo (&mbr
, objfile
);
1087 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1091 else if (mbr
.at_sibling
!= 0)
1093 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1097 nextdie
= thisdie
+ mbr
.die_length
;
1099 switch (mbr
.die_tag
)
1102 /* Get space to record the next field's data. */
1103 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1106 /* Save the data. */
1107 list
-> field
.name
=
1108 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1109 &objfile
-> type_obstack
);
1110 list
-> field
.type
= decode_die_type (&mbr
);
1111 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
1112 /* Handle bit fields. */
1113 list
-> field
.bitsize
= mbr
.at_bit_size
;
1115 /* For big endian bits, the at_bit_offset gives the additional
1116 bit offset from the MSB of the containing anonymous object to
1117 the MSB of the field. We don't have to do anything special
1118 since we don't need to know the size of the anonymous object. */
1119 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
1121 /* For little endian bits, we need to have a non-zero at_bit_size,
1122 so that we know we are in fact dealing with a bitfield. Compute
1123 the bit offset to the MSB of the anonymous object, subtract off
1124 the number of bits from the MSB of the field to the MSB of the
1125 object, and then subtract off the number of bits of the field
1126 itself. The result is the bit offset of the LSB of the field. */
1127 if (mbr
.at_bit_size
> 0)
1129 if (mbr
.has_at_byte_size
)
1131 /* The size of the anonymous object containing the bit field
1132 is explicit, so use the indicated size (in bytes). */
1133 anonymous_size
= mbr
.at_byte_size
;
1137 /* The size of the anonymous object containing the bit field
1138 matches the size of an object of the bit field's type.
1139 DWARF allows at_byte_size to be left out in such cases,
1140 as a debug information size optimization. */
1141 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
1143 list
-> field
.bitpos
+=
1144 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1150 process_dies (thisdie
, nextdie
, objfile
);
1155 /* Now create the vector of fields, and record how big it is. We may
1156 not even have any fields, if this DIE was generated due to a reference
1157 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1158 set, which clues gdb in to the fact that it needs to search elsewhere
1159 for the full structure definition. */
1162 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1166 TYPE_NFIELDS (type
) = nfields
;
1167 TYPE_FIELDS (type
) = (struct field
*)
1168 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1169 /* Copy the saved-up fields into the field vector. */
1170 for (n
= nfields
; list
; list
= list
-> next
)
1172 TYPE_FIELD (type
, --n
) = list
-> field
;
1182 read_structure_scope -- process all dies within struct or union
1186 static void read_structure_scope (struct dieinfo *dip,
1187 char *thisdie, char *enddie, struct objfile *objfile)
1191 Called when we find the DIE that starts a structure or union
1192 scope (definition) to process all dies that define the members
1193 of the structure or union. DIP is a pointer to the die info
1194 struct for the DIE that names the structure or union.
1198 Note that we need to call struct_type regardless of whether or not
1199 the DIE has an at_name attribute, since it might be an anonymous
1200 structure or union. This gets the type entered into our set of
1203 However, if the structure is incomplete (an opaque struct/union)
1204 then suppress creating a symbol table entry for it since gdb only
1205 wants to find the one with the complete definition. Note that if
1206 it is complete, we just call new_symbol, which does it's own
1207 checking about whether the struct/union is anonymous or not (and
1208 suppresses creating a symbol table entry itself).
1213 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1214 struct dieinfo
*dip
;
1217 struct objfile
*objfile
;
1222 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1223 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1225 sym
= new_symbol (dip
, objfile
);
1228 SYMBOL_TYPE (sym
) = type
;
1229 if (cu_language
== language_cplus
)
1231 synthesize_typedef (dip
, objfile
, type
);
1241 decode_array_element_type -- decode type of the array elements
1245 static struct type *decode_array_element_type (char *scan, char *end)
1249 As the last step in decoding the array subscript information for an
1250 array DIE, we need to decode the type of the array elements. We are
1251 passed a pointer to this last part of the subscript information and
1252 must return the appropriate type. If the type attribute is not
1253 recognized, just warn about the problem and return type int.
1256 static struct type
*
1257 decode_array_element_type (scan
)
1262 unsigned short attribute
;
1263 unsigned short fundtype
;
1266 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1268 scan
+= SIZEOF_ATTRIBUTE
;
1269 if ((nbytes
= attribute_size (attribute
)) == -1)
1271 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1272 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1279 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1281 typep
= decode_fund_type (fundtype
);
1283 case AT_mod_fund_type
:
1284 typep
= decode_mod_fund_type (scan
);
1286 case AT_user_def_type
:
1287 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1289 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1291 typep
= alloc_utype (die_ref
, NULL
);
1294 case AT_mod_u_d_type
:
1295 typep
= decode_mod_u_d_type (scan
);
1298 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1299 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1310 decode_subscript_data_item -- decode array subscript item
1314 static struct type *
1315 decode_subscript_data_item (char *scan, char *end)
1319 The array subscripts and the data type of the elements of an
1320 array are described by a list of data items, stored as a block
1321 of contiguous bytes. There is a data item describing each array
1322 dimension, and a final data item describing the element type.
1323 The data items are ordered the same as their appearance in the
1324 source (I.E. leftmost dimension first, next to leftmost second,
1327 The data items describing each array dimension consist of four
1328 parts: (1) a format specifier, (2) type type of the subscript
1329 index, (3) a description of the low bound of the array dimension,
1330 and (4) a description of the high bound of the array dimension.
1332 The last data item is the description of the type of each of
1335 We are passed a pointer to the start of the block of bytes
1336 containing the remaining data items, and a pointer to the first
1337 byte past the data. This function recursively decodes the
1338 remaining data items and returns a type.
1340 If we somehow fail to decode some data, we complain about it
1341 and return a type "array of int".
1344 FIXME: This code only implements the forms currently used
1345 by the AT&T and GNU C compilers.
1347 The end pointer is supplied for error checking, maybe we should
1351 static struct type
*
1352 decode_subscript_data_item (scan
, end
)
1356 struct type
*typep
= NULL
; /* Array type we are building */
1357 struct type
*nexttype
; /* Type of each element (may be array) */
1358 struct type
*indextype
; /* Type of this index */
1359 struct type
*rangetype
;
1360 unsigned int format
;
1361 unsigned short fundtype
;
1362 unsigned long lowbound
;
1363 unsigned long highbound
;
1366 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1368 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1372 typep
= decode_array_element_type (scan
);
1375 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1377 indextype
= decode_fund_type (fundtype
);
1378 scan
+= SIZEOF_FMT_FT
;
1379 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1380 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1382 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1384 nexttype
= decode_subscript_data_item (scan
, end
);
1385 if (nexttype
== NULL
)
1387 /* Munged subscript data or other problem, fake it. */
1388 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1389 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1391 rangetype
= create_range_type ((struct type
*) NULL
, indextype
,
1392 lowbound
, highbound
);
1393 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1402 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1403 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1404 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1405 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1408 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1409 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1410 rangetype
= create_range_type ((struct type
*) NULL
, nexttype
, 0, 0);
1411 typep
= create_array_type ((struct type
*) NULL
, nexttype
, rangetype
);
1421 dwarf_read_array_type -- read TAG_array_type DIE
1425 static void dwarf_read_array_type (struct dieinfo *dip)
1429 Extract all information from a TAG_array_type DIE and add to
1430 the user defined type vector.
1434 dwarf_read_array_type (dip
)
1435 struct dieinfo
*dip
;
1441 unsigned short blocksz
;
1444 if (dip
-> at_ordering
!= ORD_row_major
)
1446 /* FIXME: Can gdb even handle column major arrays? */
1447 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1449 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1451 nbytes
= attribute_size (AT_subscr_data
);
1452 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1453 subend
= sub
+ nbytes
+ blocksz
;
1455 type
= decode_subscript_data_item (sub
, subend
);
1456 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1458 /* Install user defined type that has not been referenced yet. */
1459 alloc_utype (dip
-> die_ref
, type
);
1461 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1463 /* Ick! A forward ref has already generated a blank type in our
1464 slot, and this type probably already has things pointing to it
1465 (which is what caused it to be created in the first place).
1466 If it's just a place holder we can plop our fully defined type
1467 on top of it. We can't recover the space allocated for our
1468 new type since it might be on an obstack, but we could reuse
1469 it if we kept a list of them, but it might not be worth it
1475 /* Double ick! Not only is a type already in our slot, but
1476 someone has decorated it. Complain and leave it alone. */
1477 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1486 read_tag_pointer_type -- read TAG_pointer_type DIE
1490 static void read_tag_pointer_type (struct dieinfo *dip)
1494 Extract all information from a TAG_pointer_type DIE and add to
1495 the user defined type vector.
1499 read_tag_pointer_type (dip
)
1500 struct dieinfo
*dip
;
1505 type
= decode_die_type (dip
);
1506 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1508 utype
= lookup_pointer_type (type
);
1509 alloc_utype (dip
-> die_ref
, utype
);
1513 TYPE_TARGET_TYPE (utype
) = type
;
1514 TYPE_POINTER_TYPE (type
) = utype
;
1516 /* We assume the machine has only one representation for pointers! */
1517 /* FIXME: This confuses host<->target data representations, and is a
1518 poor assumption besides. */
1520 TYPE_LENGTH (utype
) = sizeof (char *);
1521 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1529 read_tag_string_type -- read TAG_string_type DIE
1533 static void read_tag_string_type (struct dieinfo *dip)
1537 Extract all information from a TAG_string_type DIE and add to
1538 the user defined type vector. It isn't really a user defined
1539 type, but it behaves like one, with other DIE's using an
1540 AT_user_def_type attribute to reference it.
1544 read_tag_string_type (dip
)
1545 struct dieinfo
*dip
;
1548 struct type
*indextype
;
1549 struct type
*rangetype
;
1550 unsigned long lowbound
= 0;
1551 unsigned long highbound
;
1553 if (dip
-> has_at_byte_size
)
1555 /* A fixed bounds string */
1556 highbound
= dip
-> at_byte_size
- 1;
1560 /* A varying length string. Stub for now. (FIXME) */
1563 indextype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1564 rangetype
= create_range_type ((struct type
*) NULL
, indextype
, lowbound
,
1567 utype
= lookup_utype (dip
-> die_ref
);
1570 /* No type defined, go ahead and create a blank one to use. */
1571 utype
= alloc_utype (dip
-> die_ref
, (struct type
*) NULL
);
1575 /* Already a type in our slot due to a forward reference. Make sure it
1576 is a blank one. If not, complain and leave it alone. */
1577 if (TYPE_CODE (utype
) != TYPE_CODE_UNDEF
)
1579 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1584 /* Create the string type using the blank type we either found or created. */
1585 utype
= create_string_type (utype
, rangetype
);
1592 read_subroutine_type -- process TAG_subroutine_type dies
1596 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1601 Handle DIES due to C code like:
1604 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1610 The parameter DIES are currently ignored. See if gdb has a way to
1611 include this info in it's type system, and decode them if so. Is
1612 this what the type structure's "arg_types" field is for? (FIXME)
1616 read_subroutine_type (dip
, thisdie
, enddie
)
1617 struct dieinfo
*dip
;
1621 struct type
*type
; /* Type that this function returns */
1622 struct type
*ftype
; /* Function that returns above type */
1624 /* Decode the type that this subroutine returns */
1626 type
= decode_die_type (dip
);
1628 /* Check to see if we already have a partially constructed user
1629 defined type for this DIE, from a forward reference. */
1631 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1633 /* This is the first reference to one of these types. Make
1634 a new one and place it in the user defined types. */
1635 ftype
= lookup_function_type (type
);
1636 alloc_utype (dip
-> die_ref
, ftype
);
1638 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1640 /* We have an existing partially constructed type, so bash it
1641 into the correct type. */
1642 TYPE_TARGET_TYPE (ftype
) = type
;
1643 TYPE_FUNCTION_TYPE (type
) = ftype
;
1644 TYPE_LENGTH (ftype
) = 1;
1645 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1649 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1657 read_enumeration -- process dies which define an enumeration
1661 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1662 char *enddie, struct objfile *objfile)
1666 Given a pointer to a die which begins an enumeration, process all
1667 the dies that define the members of the enumeration.
1671 Note that we need to call enum_type regardless of whether or not we
1672 have a symbol, since we might have an enum without a tag name (thus
1673 no symbol for the tagname).
1677 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1678 struct dieinfo
*dip
;
1681 struct objfile
*objfile
;
1686 type
= enum_type (dip
, objfile
);
1687 sym
= new_symbol (dip
, objfile
);
1690 SYMBOL_TYPE (sym
) = type
;
1691 if (cu_language
== language_cplus
)
1693 synthesize_typedef (dip
, objfile
, type
);
1702 enum_type -- decode and return a type for an enumeration
1706 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1710 Given a pointer to a die information structure for the die which
1711 starts an enumeration, process all the dies that define the members
1712 of the enumeration and return a type pointer for the enumeration.
1714 At the same time, for each member of the enumeration, create a
1715 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1716 and give it the type of the enumeration itself.
1720 Note that the DWARF specification explicitly mandates that enum
1721 constants occur in reverse order from the source program order,
1722 for "consistency" and because this ordering is easier for many
1723 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1724 Entries). Because gdb wants to see the enum members in program
1725 source order, we have to ensure that the order gets reversed while
1726 we are processing them.
1729 static struct type
*
1730 enum_type (dip
, objfile
)
1731 struct dieinfo
*dip
;
1732 struct objfile
*objfile
;
1736 struct nextfield
*next
;
1739 struct nextfield
*list
= NULL
;
1740 struct nextfield
*new;
1745 unsigned short blocksz
;
1749 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1751 /* No forward references created an empty type, so install one now */
1752 type
= alloc_utype (dip
-> die_ref
, NULL
);
1754 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1755 /* Some compilers try to be helpful by inventing "fake" names for
1756 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1757 Thanks, but no thanks... */
1758 if (dip
-> at_name
!= NULL
1759 && *dip
-> at_name
!= '~'
1760 && *dip
-> at_name
!= '.')
1762 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1763 " ", dip
-> at_name
);
1765 if (dip
-> at_byte_size
!= 0)
1767 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1769 if ((scan
= dip
-> at_element_list
) != NULL
)
1771 if (dip
-> short_element_list
)
1773 nbytes
= attribute_size (AT_short_element_list
);
1777 nbytes
= attribute_size (AT_element_list
);
1779 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1780 listend
= scan
+ nbytes
+ blocksz
;
1782 while (scan
< listend
)
1784 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1787 list
-> field
.type
= NULL
;
1788 list
-> field
.bitsize
= 0;
1789 list
-> field
.bitpos
=
1790 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1792 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1793 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1794 &objfile
-> type_obstack
);
1795 scan
+= strlen (scan
) + 1;
1797 /* Handcraft a new symbol for this enum member. */
1798 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1799 sizeof (struct symbol
));
1800 memset (sym
, 0, sizeof (struct symbol
));
1801 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1802 &objfile
->symbol_obstack
);
1803 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1804 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1805 SYMBOL_CLASS (sym
) = LOC_CONST
;
1806 SYMBOL_TYPE (sym
) = type
;
1807 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1808 add_symbol_to_list (sym
, list_in_scope
);
1810 /* Now create the vector of fields, and record how big it is. This is
1811 where we reverse the order, by pulling the members off the list in
1812 reverse order from how they were inserted. If we have no fields
1813 (this is apparently possible in C++) then skip building a field
1817 TYPE_NFIELDS (type
) = nfields
;
1818 TYPE_FIELDS (type
) = (struct field
*)
1819 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1820 /* Copy the saved-up fields into the field vector. */
1821 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1823 TYPE_FIELD (type
, n
++) = list
-> field
;
1834 read_func_scope -- process all dies within a function scope
1838 Process all dies within a given function scope. We are passed
1839 a die information structure pointer DIP for the die which
1840 starts the function scope, and pointers into the raw die data
1841 that define the dies within the function scope.
1843 For now, we ignore lexical block scopes within the function.
1844 The problem is that AT&T cc does not define a DWARF lexical
1845 block scope for the function itself, while gcc defines a
1846 lexical block scope for the function. We need to think about
1847 how to handle this difference, or if it is even a problem.
1852 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1853 struct dieinfo
*dip
;
1856 struct objfile
*objfile
;
1858 register struct context_stack
*new;
1860 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1861 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1863 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1864 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1866 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1868 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1869 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1871 new = push_context (0, dip
-> at_low_pc
);
1872 new -> name
= new_symbol (dip
, objfile
);
1873 list_in_scope
= &local_symbols
;
1874 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1875 new = pop_context ();
1876 /* Make a block for the local symbols within. */
1877 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1878 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1879 list_in_scope
= &file_symbols
;
1887 handle_producer -- process the AT_producer attribute
1891 Perform any operations that depend on finding a particular
1892 AT_producer attribute.
1897 handle_producer (producer
)
1901 /* If this compilation unit was compiled with g++ or gcc, then set the
1902 processing_gcc_compilation flag. */
1904 processing_gcc_compilation
=
1905 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1906 /* start-sanitize-chill */
1907 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1908 /* end-sanitize-chill */
1909 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1911 /* Select a demangling style if we can identify the producer and if
1912 the current style is auto. We leave the current style alone if it
1913 is not auto. We also leave the demangling style alone if we find a
1914 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1916 if (AUTO_DEMANGLING
)
1918 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1920 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1922 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1924 set_demangling_style (LUCID_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
);
1982 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
, 0);
1985 symtab
-> language
= cu_language
;
1987 do_cleanups (back_to
);
1996 process_dies -- process a range of DWARF Information Entries
2000 static void process_dies (char *thisdie, char *enddie,
2001 struct objfile *objfile)
2005 Process all DIE's in a specified range. May be (and almost
2006 certainly will be) called recursively.
2010 process_dies (thisdie
, enddie
, objfile
)
2013 struct objfile
*objfile
;
2018 while (thisdie
< enddie
)
2020 basicdieinfo (&di
, thisdie
, objfile
);
2021 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2025 else if (di
.die_tag
== TAG_padding
)
2027 nextdie
= thisdie
+ di
.die_length
;
2031 completedieinfo (&di
, objfile
);
2032 if (di
.at_sibling
!= 0)
2034 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2038 nextdie
= thisdie
+ di
.die_length
;
2042 case TAG_compile_unit
:
2043 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
2045 case TAG_global_subroutine
:
2046 case TAG_subroutine
:
2047 if (di
.has_at_low_pc
)
2049 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
2052 case TAG_lexical_block
:
2053 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
2055 case TAG_class_type
:
2056 case TAG_structure_type
:
2057 case TAG_union_type
:
2058 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
2060 case TAG_enumeration_type
:
2061 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
2063 case TAG_subroutine_type
:
2064 read_subroutine_type (&di
, thisdie
, nextdie
);
2066 case TAG_array_type
:
2067 dwarf_read_array_type (&di
);
2069 case TAG_pointer_type
:
2070 read_tag_pointer_type (&di
);
2072 case TAG_string_type
:
2073 read_tag_string_type (&di
);
2076 new_symbol (&di
, objfile
);
2088 decode_line_numbers -- decode a line number table fragment
2092 static void decode_line_numbers (char *tblscan, char *tblend,
2093 long length, long base, long line, long pc)
2097 Translate the DWARF line number information to gdb form.
2099 The ".line" section contains one or more line number tables, one for
2100 each ".line" section from the objects that were linked.
2102 The AT_stmt_list attribute for each TAG_source_file entry in the
2103 ".debug" section contains the offset into the ".line" section for the
2104 start of the table for that file.
2106 The table itself has the following structure:
2108 <table length><base address><source statement entry>
2109 4 bytes 4 bytes 10 bytes
2111 The table length is the total size of the table, including the 4 bytes
2112 for the length information.
2114 The base address is the address of the first instruction generated
2115 for the source file.
2117 Each source statement entry has the following structure:
2119 <line number><statement position><address delta>
2120 4 bytes 2 bytes 4 bytes
2122 The line number is relative to the start of the file, starting with
2125 The statement position either -1 (0xFFFF) or the number of characters
2126 from the beginning of the line to the beginning of the statement.
2128 The address delta is the difference between the base address and
2129 the address of the first instruction for the statement.
2131 Note that we must copy the bytes from the packed table to our local
2132 variables before attempting to use them, to avoid alignment problems
2133 on some machines, particularly RISC processors.
2137 Does gdb expect the line numbers to be sorted? They are now by
2138 chance/luck, but are not required to be. (FIXME)
2140 The line with number 0 is unused, gdb apparently can discover the
2141 span of the last line some other way. How? (FIXME)
2145 decode_line_numbers (linetable
)
2150 unsigned long length
;
2155 if (linetable
!= NULL
)
2157 tblscan
= tblend
= linetable
;
2158 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2160 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2162 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2163 GET_UNSIGNED
, current_objfile
);
2164 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2166 while (tblscan
< tblend
)
2168 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2170 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2171 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2173 tblscan
+= SIZEOF_LINETBL_DELTA
;
2177 record_line (current_subfile
, line
, pc
);
2187 locval -- compute the value of a location attribute
2191 static int locval (char *loc)
2195 Given pointer to a string of bytes that define a location, compute
2196 the location and return the value.
2198 When computing values involving the current value of the frame pointer,
2199 the value zero is used, which results in a value relative to the frame
2200 pointer, rather than the absolute value. This is what GDB wants
2203 When the result is a register number, the global isreg flag is set,
2204 otherwise it is cleared. This is a kludge until we figure out a better
2205 way to handle the problem. Gdb's design does not mesh well with the
2206 DWARF notion of a location computing interpreter, which is a shame
2207 because the flexibility goes unused.
2211 Note that stack[0] is unused except as a default error return.
2212 Note that stack overflow is not yet handled.
2219 unsigned short nbytes
;
2220 unsigned short locsize
;
2221 auto long stack
[64];
2228 nbytes
= attribute_size (AT_location
);
2229 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2231 end
= loc
+ locsize
;
2236 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2239 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2241 loc
+= SIZEOF_LOC_ATOM_CODE
;
2242 switch (loc_atom_code
)
2249 /* push register (number) */
2250 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2251 GET_UNSIGNED
, current_objfile
);
2252 loc
+= loc_value_size
;
2256 /* push value of register (number) */
2257 /* Actually, we compute the value as if register has 0 */
2259 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2261 loc
+= loc_value_size
;
2264 stack
[++stacki
] = 0;
2268 stack
[++stacki
] = 0;
2270 complain (&basereg_not_handled
, DIE_ID
, DIE_NAME
, regno
);
2274 /* push address (relocated address) */
2275 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2276 GET_UNSIGNED
, current_objfile
);
2277 loc
+= loc_value_size
;
2280 /* push constant (number) FIXME: signed or unsigned! */
2281 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2282 GET_SIGNED
, current_objfile
);
2283 loc
+= loc_value_size
;
2286 /* pop, deref and push 2 bytes (as a long) */
2287 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2289 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2290 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2292 case OP_ADD
: /* pop top 2 items, add, push result */
2293 stack
[stacki
- 1] += stack
[stacki
];
2298 return (stack
[stacki
]);
2305 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2309 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2313 When expanding a partial symbol table entry to a full symbol table
2314 entry, this is the function that gets called to read in the symbols
2315 for the compilation unit.
2317 Returns a pointer to the newly constructed symtab (which is now
2318 the new first one on the objfile's symtab list).
2321 static struct symtab
*
2322 read_ofile_symtab (pst
)
2323 struct partial_symtab
*pst
;
2325 struct cleanup
*back_to
;
2326 unsigned long lnsize
;
2329 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2331 abfd
= pst
-> objfile
-> obfd
;
2332 current_objfile
= pst
-> objfile
;
2334 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2335 unit, seek to the location in the file, and read in all the DIE's. */
2338 dbsize
= DBLENGTH (pst
);
2339 dbbase
= xmalloc (dbsize
);
2340 dbroff
= DBROFF(pst
);
2341 foffset
= DBFOFF(pst
) + dbroff
;
2342 base_section_offsets
= pst
->section_offsets
;
2343 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2344 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2345 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2348 error ("can't read DWARF data");
2350 back_to
= make_cleanup (free
, dbbase
);
2352 /* If there is a line number table associated with this compilation unit
2353 then read the size of this fragment in bytes, from the fragment itself.
2354 Allocate a buffer for the fragment and read it in for future
2360 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2361 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2362 sizeof (lnsizedata
)))
2364 error ("can't read DWARF line number table size");
2366 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2367 GET_UNSIGNED
, pst
-> objfile
);
2368 lnbase
= xmalloc (lnsize
);
2369 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2370 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2373 error ("can't read DWARF line numbers");
2375 make_cleanup (free
, lnbase
);
2378 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2379 do_cleanups (back_to
);
2380 current_objfile
= NULL
;
2381 return (pst
-> objfile
-> symtabs
);
2388 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2392 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2396 Called once for each partial symbol table entry that needs to be
2397 expanded into a full symbol table entry.
2402 psymtab_to_symtab_1 (pst
)
2403 struct partial_symtab
*pst
;
2406 struct cleanup
*old_chain
;
2412 warning ("psymtab for %s already read in. Shouldn't happen.",
2417 /* Read in all partial symtabs on which this one is dependent */
2418 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2420 if (!pst
-> dependencies
[i
] -> readin
)
2422 /* Inform about additional files that need to be read in. */
2425 fputs_filtered (" ", stdout
);
2427 fputs_filtered ("and ", stdout
);
2429 printf_filtered ("%s...",
2430 pst
-> dependencies
[i
] -> filename
);
2432 fflush (stdout
); /* Flush output */
2434 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2437 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2440 old_chain
= make_cleanup (really_free_pendings
, 0);
2441 pst
-> symtab
= read_ofile_symtab (pst
);
2444 printf_filtered ("%d DIE's, sorting...", diecount
);
2448 sort_symtab_syms (pst
-> symtab
);
2449 do_cleanups (old_chain
);
2460 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2464 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2468 This is the DWARF support entry point for building a full symbol
2469 table entry from a partial symbol table entry. We are passed a
2470 pointer to the partial symbol table entry that needs to be expanded.
2475 dwarf_psymtab_to_symtab (pst
)
2476 struct partial_symtab
*pst
;
2483 warning ("psymtab for %s already read in. Shouldn't happen.",
2488 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2490 /* Print the message now, before starting serious work, to avoid
2491 disconcerting pauses. */
2494 printf_filtered ("Reading in symbols for %s...",
2499 psymtab_to_symtab_1 (pst
);
2501 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2502 we need to do an equivalent or is this something peculiar to
2504 Match with global symbols. This only needs to be done once,
2505 after all of the symtabs and dependencies have been read in.
2507 scan_file_globals (pst
-> objfile
);
2510 /* Finish up the verbose info message. */
2513 printf_filtered ("done.\n");
2525 init_psymbol_list -- initialize storage for partial symbols
2529 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2533 Initializes storage for all of the partial symbols that will be
2534 created by dwarf_build_psymtabs and subsidiaries.
2538 init_psymbol_list (objfile
, total_symbols
)
2539 struct objfile
*objfile
;
2542 /* Free any previously allocated psymbol lists. */
2544 if (objfile
-> global_psymbols
.list
)
2546 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2548 if (objfile
-> static_psymbols
.list
)
2550 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2553 /* Current best guess is that there are approximately a twentieth
2554 of the total symbols (in a debugging file) are global or static
2557 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2558 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2559 objfile
-> global_psymbols
.next
=
2560 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2561 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2562 * sizeof (struct partial_symbol
));
2563 objfile
-> static_psymbols
.next
=
2564 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2565 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2566 * sizeof (struct partial_symbol
));
2573 add_enum_psymbol -- add enumeration members to partial symbol table
2577 Given pointer to a DIE that is known to be for an enumeration,
2578 extract the symbolic names of the enumeration members and add
2579 partial symbols for them.
2583 add_enum_psymbol (dip
, objfile
)
2584 struct dieinfo
*dip
;
2585 struct objfile
*objfile
;
2589 unsigned short blocksz
;
2592 if ((scan
= dip
-> at_element_list
) != NULL
)
2594 if (dip
-> short_element_list
)
2596 nbytes
= attribute_size (AT_short_element_list
);
2600 nbytes
= attribute_size (AT_element_list
);
2602 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2604 listend
= scan
+ blocksz
;
2605 while (scan
< listend
)
2607 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2608 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2609 objfile
-> static_psymbols
, 0, cu_language
,
2611 scan
+= strlen (scan
) + 1;
2620 add_partial_symbol -- add symbol to partial symbol table
2624 Given a DIE, if it is one of the types that we want to
2625 add to a partial symbol table, finish filling in the die info
2626 and then add a partial symbol table entry for it.
2630 The caller must ensure that the DIE has a valid name attribute.
2634 add_partial_symbol (dip
, objfile
)
2635 struct dieinfo
*dip
;
2636 struct objfile
*objfile
;
2638 switch (dip
-> die_tag
)
2640 case TAG_global_subroutine
:
2641 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2643 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2644 VAR_NAMESPACE
, LOC_BLOCK
,
2645 objfile
-> global_psymbols
,
2646 dip
-> at_low_pc
, cu_language
, objfile
);
2648 case TAG_global_variable
:
2649 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2651 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2652 VAR_NAMESPACE
, LOC_STATIC
,
2653 objfile
-> global_psymbols
,
2654 0, cu_language
, objfile
);
2656 case TAG_subroutine
:
2657 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2658 VAR_NAMESPACE
, LOC_BLOCK
,
2659 objfile
-> static_psymbols
,
2660 dip
-> at_low_pc
, cu_language
, objfile
);
2662 case TAG_local_variable
:
2663 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2664 VAR_NAMESPACE
, LOC_STATIC
,
2665 objfile
-> static_psymbols
,
2666 0, cu_language
, objfile
);
2669 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2670 VAR_NAMESPACE
, LOC_TYPEDEF
,
2671 objfile
-> static_psymbols
,
2672 0, cu_language
, objfile
);
2674 case TAG_class_type
:
2675 case TAG_structure_type
:
2676 case TAG_union_type
:
2677 case TAG_enumeration_type
:
2678 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2679 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2680 objfile
-> static_psymbols
,
2681 0, cu_language
, objfile
);
2682 if (cu_language
== language_cplus
)
2684 /* For C++, these implicitly act as typedefs as well. */
2685 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2686 VAR_NAMESPACE
, LOC_TYPEDEF
,
2687 objfile
-> static_psymbols
,
2688 0, cu_language
, objfile
);
2698 scan_partial_symbols -- scan DIE's within a single compilation unit
2702 Process the DIE's within a single compilation unit, looking for
2703 interesting DIE's that contribute to the partial symbol table entry
2704 for this compilation unit.
2708 There are some DIE's that may appear both at file scope and within
2709 the scope of a function. We are only interested in the ones at file
2710 scope, and the only way to tell them apart is to keep track of the
2711 scope. For example, consider the test case:
2716 for which the relevant DWARF segment has the structure:
2719 0x23 global subrtn sibling 0x9b
2721 fund_type FT_integer
2726 0x23 local var sibling 0x97
2728 fund_type FT_integer
2729 location OP_BASEREG 0xe
2736 0x1d local var sibling 0xb8
2738 fund_type FT_integer
2739 location OP_ADDR 0x800025dc
2744 We want to include the symbol 'i' in the partial symbol table, but
2745 not the symbol 'j'. In essence, we want to skip all the dies within
2746 the scope of a TAG_global_subroutine DIE.
2748 Don't attempt to add anonymous structures or unions since they have
2749 no name. Anonymous enumerations however are processed, because we
2750 want to extract their member names (the check for a tag name is
2753 Also, for variables and subroutines, check that this is the place
2754 where the actual definition occurs, rather than just a reference
2759 scan_partial_symbols (thisdie
, enddie
, objfile
)
2762 struct objfile
*objfile
;
2768 while (thisdie
< enddie
)
2770 basicdieinfo (&di
, thisdie
, objfile
);
2771 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2777 nextdie
= thisdie
+ di
.die_length
;
2778 /* To avoid getting complete die information for every die, we
2779 only do it (below) for the cases we are interested in. */
2782 case TAG_global_subroutine
:
2783 case TAG_subroutine
:
2784 completedieinfo (&di
, objfile
);
2785 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2787 add_partial_symbol (&di
, objfile
);
2788 /* If there is a sibling attribute, adjust the nextdie
2789 pointer to skip the entire scope of the subroutine.
2790 Apply some sanity checking to make sure we don't
2791 overrun or underrun the range of remaining DIE's */
2792 if (di
.at_sibling
!= 0)
2794 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2795 if ((temp
< thisdie
) || (temp
>= enddie
))
2797 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2807 case TAG_global_variable
:
2808 case TAG_local_variable
:
2809 completedieinfo (&di
, objfile
);
2810 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2812 add_partial_symbol (&di
, objfile
);
2816 case TAG_class_type
:
2817 case TAG_structure_type
:
2818 case TAG_union_type
:
2819 completedieinfo (&di
, objfile
);
2822 add_partial_symbol (&di
, objfile
);
2825 case TAG_enumeration_type
:
2826 completedieinfo (&di
, objfile
);
2829 add_partial_symbol (&di
, objfile
);
2831 add_enum_psymbol (&di
, objfile
);
2843 scan_compilation_units -- build a psymtab entry for each compilation
2847 This is the top level dwarf parsing routine for building partial
2850 It scans from the beginning of the DWARF table looking for the first
2851 TAG_compile_unit DIE, and then follows the sibling chain to locate
2852 each additional TAG_compile_unit DIE.
2854 For each TAG_compile_unit DIE it creates a partial symtab structure,
2855 calls a subordinate routine to collect all the compilation unit's
2856 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2857 new partial symtab structure into the partial symbol table. It also
2858 records the appropriate information in the partial symbol table entry
2859 to allow the chunk of DIE's and line number table for this compilation
2860 unit to be located and re-read later, to generate a complete symbol
2861 table entry for the compilation unit.
2863 Thus it effectively partitions up a chunk of DIE's for multiple
2864 compilation units into smaller DIE chunks and line number tables,
2865 and associates them with a partial symbol table entry.
2869 If any compilation unit has no line number table associated with
2870 it for some reason (a missing at_stmt_list attribute, rather than
2871 just one with a value of zero, which is valid) then we ensure that
2872 the recorded file offset is zero so that the routine which later
2873 reads line number table fragments knows that there is no fragment
2883 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2888 struct objfile
*objfile
;
2892 struct partial_symtab
*pst
;
2895 file_ptr curlnoffset
;
2897 while (thisdie
< enddie
)
2899 basicdieinfo (&di
, thisdie
, objfile
);
2900 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2904 else if (di
.die_tag
!= TAG_compile_unit
)
2906 nextdie
= thisdie
+ di
.die_length
;
2910 completedieinfo (&di
, objfile
);
2911 set_cu_language (&di
);
2912 if (di
.at_sibling
!= 0)
2914 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2918 nextdie
= thisdie
+ di
.die_length
;
2920 curoff
= thisdie
- dbbase
;
2921 culength
= nextdie
- thisdie
;
2922 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2924 /* First allocate a new partial symbol table structure */
2926 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2927 di
.at_name
, di
.at_low_pc
,
2928 objfile
-> global_psymbols
.next
,
2929 objfile
-> static_psymbols
.next
);
2931 pst
-> texthigh
= di
.at_high_pc
;
2932 pst
-> read_symtab_private
= (char *)
2933 obstack_alloc (&objfile
-> psymbol_obstack
,
2934 sizeof (struct dwfinfo
));
2935 DBFOFF (pst
) = dbfoff
;
2936 DBROFF (pst
) = curoff
;
2937 DBLENGTH (pst
) = culength
;
2938 LNFOFF (pst
) = curlnoffset
;
2939 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2941 /* Now look for partial symbols */
2943 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2945 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2946 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2947 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2948 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2949 sort_pst_symbols (pst
);
2950 /* If there is already a psymtab or symtab for a file of this name,
2951 remove it. (If there is a symtab, more drastic things also
2952 happen.) This happens in VxWorks. */
2953 free_named_symtabs (pst
-> filename
);
2963 new_symbol -- make a symbol table entry for a new symbol
2967 static struct symbol *new_symbol (struct dieinfo *dip,
2968 struct objfile *objfile)
2972 Given a pointer to a DWARF information entry, figure out if we need
2973 to make a symbol table entry for it, and if so, create a new entry
2974 and return a pointer to it.
2977 static struct symbol
*
2978 new_symbol (dip
, objfile
)
2979 struct dieinfo
*dip
;
2980 struct objfile
*objfile
;
2982 struct symbol
*sym
= NULL
;
2984 if (dip
-> at_name
!= NULL
)
2986 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2987 sizeof (struct symbol
));
2988 memset (sym
, 0, sizeof (struct symbol
));
2989 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2990 &objfile
->symbol_obstack
);
2991 /* default assumptions */
2992 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2993 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2994 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2996 /* If this symbol is from a C++ compilation, then attempt to cache the
2997 demangled form for future reference. This is a typical time versus
2998 space tradeoff, that was decided in favor of time because it sped up
2999 C++ symbol lookups by a factor of about 20. */
3001 SYMBOL_LANGUAGE (sym
) = cu_language
;
3002 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
-> symbol_obstack
);
3003 switch (dip
-> die_tag
)
3006 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
3007 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3009 case TAG_global_subroutine
:
3010 case TAG_subroutine
:
3011 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
3012 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
3013 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3014 if (dip
-> die_tag
== TAG_global_subroutine
)
3016 add_symbol_to_list (sym
, &global_symbols
);
3020 add_symbol_to_list (sym
, list_in_scope
);
3023 case TAG_global_variable
:
3024 if (dip
-> at_location
!= NULL
)
3026 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3027 add_symbol_to_list (sym
, &global_symbols
);
3028 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3029 SYMBOL_VALUE (sym
) += baseaddr
;
3032 case TAG_local_variable
:
3033 if (dip
-> at_location
!= NULL
)
3035 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3036 add_symbol_to_list (sym
, list_in_scope
);
3039 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3043 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3047 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3048 SYMBOL_VALUE (sym
) += baseaddr
;
3052 case TAG_formal_parameter
:
3053 if (dip
-> at_location
!= NULL
)
3055 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3057 add_symbol_to_list (sym
, list_in_scope
);
3060 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3064 SYMBOL_CLASS (sym
) = LOC_ARG
;
3067 case TAG_unspecified_parameters
:
3068 /* From varargs functions; gdb doesn't seem to have any interest in
3069 this information, so just ignore it for now. (FIXME?) */
3071 case TAG_class_type
:
3072 case TAG_structure_type
:
3073 case TAG_union_type
:
3074 case TAG_enumeration_type
:
3075 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3076 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3077 add_symbol_to_list (sym
, list_in_scope
);
3080 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3081 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3082 add_symbol_to_list (sym
, list_in_scope
);
3085 /* Not a tag we recognize. Hopefully we aren't processing trash
3086 data, but since we must specifically ignore things we don't
3087 recognize, there is nothing else we should do at this point. */
3098 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3102 static void synthesize_typedef (struct dieinfo *dip,
3103 struct objfile *objfile,
3108 Given a pointer to a DWARF information entry, synthesize a typedef
3109 for the name in the DIE, using the specified type.
3111 This is used for C++ class, structs, unions, and enumerations to
3112 set up the tag name as a type.
3117 synthesize_typedef (dip
, objfile
, type
)
3118 struct dieinfo
*dip
;
3119 struct objfile
*objfile
;
3122 struct symbol
*sym
= NULL
;
3124 if (dip
-> at_name
!= NULL
)
3126 sym
= (struct symbol
*)
3127 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3128 memset (sym
, 0, sizeof (struct symbol
));
3129 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3130 &objfile
->symbol_obstack
);
3131 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3132 SYMBOL_TYPE (sym
) = type
;
3133 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3134 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3135 add_symbol_to_list (sym
, list_in_scope
);
3143 decode_mod_fund_type -- decode a modified fundamental type
3147 static struct type *decode_mod_fund_type (char *typedata)
3151 Decode a block of data containing a modified fundamental
3152 type specification. TYPEDATA is a pointer to the block,
3153 which starts with a length containing the size of the rest
3154 of the block. At the end of the block is a fundmental type
3155 code value that gives the fundamental type. Everything
3156 in between are type modifiers.
3158 We simply compute the number of modifiers and call the general
3159 function decode_modified_type to do the actual work.
3162 static struct type
*
3163 decode_mod_fund_type (typedata
)
3166 struct type
*typep
= NULL
;
3167 unsigned short modcount
;
3170 /* Get the total size of the block, exclusive of the size itself */
3172 nbytes
= attribute_size (AT_mod_fund_type
);
3173 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3176 /* Deduct the size of the fundamental type bytes at the end of the block. */
3178 modcount
-= attribute_size (AT_fund_type
);
3180 /* Now do the actual decoding */
3182 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3190 decode_mod_u_d_type -- decode a modified user defined type
3194 static struct type *decode_mod_u_d_type (char *typedata)
3198 Decode a block of data containing a modified user defined
3199 type specification. TYPEDATA is a pointer to the block,
3200 which consists of a two byte length, containing the size
3201 of the rest of the block. At the end of the block is a
3202 four byte value that gives a reference to a user defined type.
3203 Everything in between are type modifiers.
3205 We simply compute the number of modifiers and call the general
3206 function decode_modified_type to do the actual work.
3209 static struct type
*
3210 decode_mod_u_d_type (typedata
)
3213 struct type
*typep
= NULL
;
3214 unsigned short modcount
;
3217 /* Get the total size of the block, exclusive of the size itself */
3219 nbytes
= attribute_size (AT_mod_u_d_type
);
3220 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3223 /* Deduct the size of the reference type bytes at the end of the block. */
3225 modcount
-= attribute_size (AT_user_def_type
);
3227 /* Now do the actual decoding */
3229 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3237 decode_modified_type -- decode modified user or fundamental type
3241 static struct type *decode_modified_type (char *modifiers,
3242 unsigned short modcount, int mtype)
3246 Decode a modified type, either a modified fundamental type or
3247 a modified user defined type. MODIFIERS is a pointer to the
3248 block of bytes that define MODCOUNT modifiers. Immediately
3249 following the last modifier is a short containing the fundamental
3250 type or a long containing the reference to the user defined
3251 type. Which one is determined by MTYPE, which is either
3252 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3253 type we are generating.
3255 We call ourself recursively to generate each modified type,`
3256 until MODCOUNT reaches zero, at which point we have consumed
3257 all the modifiers and generate either the fundamental type or
3258 user defined type. When the recursion unwinds, each modifier
3259 is applied in turn to generate the full modified type.
3263 If we find a modifier that we don't recognize, and it is not one
3264 of those reserved for application specific use, then we issue a
3265 warning and simply ignore the modifier.
3269 We currently ignore MOD_const and MOD_volatile. (FIXME)
3273 static struct type
*
3274 decode_modified_type (modifiers
, modcount
, mtype
)
3276 unsigned int modcount
;
3279 struct type
*typep
= NULL
;
3280 unsigned short fundtype
;
3289 case AT_mod_fund_type
:
3290 nbytes
= attribute_size (AT_fund_type
);
3291 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3293 typep
= decode_fund_type (fundtype
);
3295 case AT_mod_u_d_type
:
3296 nbytes
= attribute_size (AT_user_def_type
);
3297 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3299 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3301 typep
= alloc_utype (die_ref
, NULL
);
3305 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3306 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3312 modifier
= *modifiers
++;
3313 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3316 case MOD_pointer_to
:
3317 typep
= lookup_pointer_type (typep
);
3319 case MOD_reference_to
:
3320 typep
= lookup_reference_type (typep
);
3323 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3326 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3329 if (!(MOD_lo_user
<= (unsigned char) modifier
3330 && (unsigned char) modifier
<= MOD_hi_user
))
3332 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3344 decode_fund_type -- translate basic DWARF type to gdb base type
3348 Given an integer that is one of the fundamental DWARF types,
3349 translate it to one of the basic internal gdb types and return
3350 a pointer to the appropriate gdb type (a "struct type *").
3354 For robustness, if we are asked to translate a fundamental
3355 type that we are unprepared to deal with, we return int so
3356 callers can always depend upon a valid type being returned,
3357 and so gdb may at least do something reasonable by default.
3358 If the type is not in the range of those types defined as
3359 application specific types, we also issue a warning.
3362 static struct type
*
3363 decode_fund_type (fundtype
)
3364 unsigned int fundtype
;
3366 struct type
*typep
= NULL
;
3372 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3375 case FT_boolean
: /* Was FT_set in AT&T version */
3376 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3379 case FT_pointer
: /* (void *) */
3380 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3381 typep
= lookup_pointer_type (typep
);
3385 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3388 case FT_signed_char
:
3389 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3392 case FT_unsigned_char
:
3393 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3397 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3400 case FT_signed_short
:
3401 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3404 case FT_unsigned_short
:
3405 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3409 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3412 case FT_signed_integer
:
3413 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3416 case FT_unsigned_integer
:
3417 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3421 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3424 case FT_signed_long
:
3425 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3428 case FT_unsigned_long
:
3429 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3433 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3436 case FT_signed_long_long
:
3437 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3440 case FT_unsigned_long_long
:
3441 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3445 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3448 case FT_dbl_prec_float
:
3449 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3452 case FT_ext_prec_float
:
3453 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3457 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3460 case FT_dbl_prec_complex
:
3461 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3464 case FT_ext_prec_complex
:
3465 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3472 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3473 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3475 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3486 create_name -- allocate a fresh copy of a string on an obstack
3490 Given a pointer to a string and a pointer to an obstack, allocates
3491 a fresh copy of the string on the specified obstack.
3496 create_name (name
, obstackp
)
3498 struct obstack
*obstackp
;
3503 length
= strlen (name
) + 1;
3504 newname
= (char *) obstack_alloc (obstackp
, length
);
3505 strcpy (newname
, name
);
3513 basicdieinfo -- extract the minimal die info from raw die data
3517 void basicdieinfo (char *diep, struct dieinfo *dip,
3518 struct objfile *objfile)
3522 Given a pointer to raw DIE data, and a pointer to an instance of a
3523 die info structure, this function extracts the basic information
3524 from the DIE data required to continue processing this DIE, along
3525 with some bookkeeping information about the DIE.
3527 The information we absolutely must have includes the DIE tag,
3528 and the DIE length. If we need the sibling reference, then we
3529 will have to call completedieinfo() to process all the remaining
3532 Note that since there is no guarantee that the data is properly
3533 aligned in memory for the type of access required (indirection
3534 through anything other than a char pointer), and there is no
3535 guarantee that it is in the same byte order as the gdb host,
3536 we call a function which deals with both alignment and byte
3537 swapping issues. Possibly inefficient, but quite portable.
3539 We also take care of some other basic things at this point, such
3540 as ensuring that the instance of the die info structure starts
3541 out completely zero'd and that curdie is initialized for use
3542 in error reporting if we have a problem with the current die.
3546 All DIE's must have at least a valid length, thus the minimum
3547 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3548 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3549 are forced to be TAG_padding DIES.
3551 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3552 that if a padding DIE is used for alignment and the amount needed is
3553 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3554 enough to align to the next alignment boundry.
3556 We do some basic sanity checking here, such as verifying that the
3557 length of the die would not cause it to overrun the recorded end of
3558 the buffer holding the DIE info. If we find a DIE that is either
3559 too small or too large, we force it's length to zero which should
3560 cause the caller to take appropriate action.
3564 basicdieinfo (dip
, diep
, objfile
)
3565 struct dieinfo
*dip
;
3567 struct objfile
*objfile
;
3570 memset (dip
, 0, sizeof (struct dieinfo
));
3572 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3573 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3575 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3576 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3578 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3579 dip
-> die_length
= 0;
3581 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3583 dip
-> die_tag
= TAG_padding
;
3587 diep
+= SIZEOF_DIE_LENGTH
;
3588 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3597 completedieinfo -- finish reading the information for a given DIE
3601 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3605 Given a pointer to an already partially initialized die info structure,
3606 scan the raw DIE data and finish filling in the die info structure
3607 from the various attributes found.
3609 Note that since there is no guarantee that the data is properly
3610 aligned in memory for the type of access required (indirection
3611 through anything other than a char pointer), and there is no
3612 guarantee that it is in the same byte order as the gdb host,
3613 we call a function which deals with both alignment and byte
3614 swapping issues. Possibly inefficient, but quite portable.
3618 Each time we are called, we increment the diecount variable, which
3619 keeps an approximate count of the number of dies processed for
3620 each compilation unit. This information is presented to the user
3621 if the info_verbose flag is set.
3626 completedieinfo (dip
, objfile
)
3627 struct dieinfo
*dip
;
3628 struct objfile
*objfile
;
3630 char *diep
; /* Current pointer into raw DIE data */
3631 char *end
; /* Terminate DIE scan here */
3632 unsigned short attr
; /* Current attribute being scanned */
3633 unsigned short form
; /* Form of the attribute */
3634 int nbytes
; /* Size of next field to read */
3638 end
= diep
+ dip
-> die_length
;
3639 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3642 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3643 diep
+= SIZEOF_ATTRIBUTE
;
3644 if ((nbytes
= attribute_size (attr
)) == -1)
3646 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3653 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3657 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3661 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3665 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3669 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3671 dip
-> has_at_stmt_list
= 1;
3674 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3676 dip
-> at_low_pc
+= baseaddr
;
3677 dip
-> has_at_low_pc
= 1;
3680 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3682 dip
-> at_high_pc
+= baseaddr
;
3685 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3688 case AT_user_def_type
:
3689 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3690 GET_UNSIGNED
, objfile
);
3693 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3695 dip
-> has_at_byte_size
= 1;
3698 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3702 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3706 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3710 dip
-> at_location
= diep
;
3712 case AT_mod_fund_type
:
3713 dip
-> at_mod_fund_type
= diep
;
3715 case AT_subscr_data
:
3716 dip
-> at_subscr_data
= diep
;
3718 case AT_mod_u_d_type
:
3719 dip
-> at_mod_u_d_type
= diep
;
3721 case AT_element_list
:
3722 dip
-> at_element_list
= diep
;
3723 dip
-> short_element_list
= 0;
3725 case AT_short_element_list
:
3726 dip
-> at_element_list
= diep
;
3727 dip
-> short_element_list
= 1;
3729 case AT_discr_value
:
3730 dip
-> at_discr_value
= diep
;
3732 case AT_string_length
:
3733 dip
-> at_string_length
= diep
;
3736 dip
-> at_name
= diep
;
3739 /* For now, ignore any "hostname:" portion, since gdb doesn't
3740 know how to deal with it. (FIXME). */
3741 dip
-> at_comp_dir
= strrchr (diep
, ':');
3742 if (dip
-> at_comp_dir
!= NULL
)
3744 dip
-> at_comp_dir
++;
3748 dip
-> at_comp_dir
= diep
;
3752 dip
-> at_producer
= diep
;
3754 case AT_start_scope
:
3755 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3758 case AT_stride_size
:
3759 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3763 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3767 dip
-> at_prototyped
= diep
;
3770 /* Found an attribute that we are unprepared to handle. However
3771 it is specifically one of the design goals of DWARF that
3772 consumers should ignore unknown attributes. As long as the
3773 form is one that we recognize (so we know how to skip it),
3774 we can just ignore the unknown attribute. */
3777 form
= FORM_FROM_ATTR (attr
);
3791 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3794 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3797 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3800 diep
+= strlen (diep
) + 1;
3803 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3814 target_to_host -- swap in target data to host
3818 target_to_host (char *from, int nbytes, int signextend,
3819 struct objfile *objfile)
3823 Given pointer to data in target format in FROM, a byte count for
3824 the size of the data in NBYTES, a flag indicating whether or not
3825 the data is signed in SIGNEXTEND, and a pointer to the current
3826 objfile in OBJFILE, convert the data to host format and return
3827 the converted value.
3831 FIXME: If we read data that is known to be signed, and expect to
3832 use it as signed data, then we need to explicitly sign extend the
3833 result until the bfd library is able to do this for us.
3837 static unsigned long
3838 target_to_host (from
, nbytes
, signextend
, objfile
)
3841 int signextend
; /* FIXME: Unused */
3842 struct objfile
*objfile
;
3844 unsigned long rtnval
;
3849 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3852 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3855 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3858 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3861 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3872 attribute_size -- compute size of data for a DWARF attribute
3876 static int attribute_size (unsigned int attr)
3880 Given a DWARF attribute in ATTR, compute the size of the first
3881 piece of data associated with this attribute and return that
3884 Returns -1 for unrecognized attributes.
3889 attribute_size (attr
)
3892 int nbytes
; /* Size of next data for this attribute */
3893 unsigned short form
; /* Form of the attribute */
3895 form
= FORM_FROM_ATTR (attr
);
3898 case FORM_STRING
: /* A variable length field is next */
3901 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3902 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3905 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3906 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3907 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3910 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3913 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3914 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3917 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);