1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
4 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 FIXME: Figure out how to get the frame pointer register number in the
25 execution environment of the target. Remove R_FP kludge
27 FIXME: Add generation of dependencies list to partial symtab code.
29 FIXME: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
49 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
50 #include "elf/dwarf.h"
53 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
55 #include "complaints.h"
59 #include <sys/types.h>
65 /* FIXME -- convert this to SEEK_SET a la POSIX, move to config files. */
70 /* Some macros to provide DIE info for complaints. */
72 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
73 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
75 /* Complaints that can be issued during DWARF debug info reading. */
77 struct complaint no_bfd_get_N
=
79 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
82 struct complaint malformed_die
=
84 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
87 struct complaint bad_die_ref
=
89 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
92 struct complaint unknown_attribute_form
=
94 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
97 struct complaint unknown_attribute_length
=
99 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
102 struct complaint unexpected_fund_type
=
104 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
107 struct complaint unknown_type_modifier
=
109 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
112 struct complaint volatile_ignored
=
114 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
117 struct complaint const_ignored
=
119 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
122 struct complaint botched_modified_type
=
124 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
127 struct complaint op_deref2
=
129 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
132 struct complaint op_deref4
=
134 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
137 struct complaint basereg_not_handled
=
139 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
142 struct complaint dup_user_type_allocation
=
144 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
147 struct complaint dup_user_type_definition
=
149 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
152 struct complaint missing_tag
=
154 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
157 struct complaint bad_array_element_type
=
159 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
162 struct complaint subscript_data_items
=
164 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
167 struct complaint unhandled_array_subscript_format
=
169 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
172 struct complaint unknown_array_subscript_format
=
174 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
177 struct complaint not_row_major
=
179 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
182 #ifndef R_FP /* FIXME */
183 #define R_FP 14 /* Kludge to get frame pointer register number */
186 typedef unsigned int DIE_REF
; /* Reference to a DIE */
189 #define GCC_PRODUCER "GNU C "
192 #ifndef GPLUS_PRODUCER
193 #define GPLUS_PRODUCER "GNU C++ "
197 #define LCC_PRODUCER "NCR C/C++"
200 #ifndef CFRONT_PRODUCER
201 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
204 /* start-sanitize-chill */
205 #ifndef CHILL_PRODUCER
206 #define CHILL_PRODUCER "GNU Chill "
208 /* end-sanitize-chill */
210 /* Flags to target_to_host() that tell whether or not the data object is
211 expected to be signed. Used, for example, when fetching a signed
212 integer in the target environment which is used as a signed integer
213 in the host environment, and the two environments have different sized
214 ints. In this case, *somebody* has to sign extend the smaller sized
217 #define GET_UNSIGNED 0 /* No sign extension required */
218 #define GET_SIGNED 1 /* Sign extension required */
220 /* Defines for things which are specified in the document "DWARF Debugging
221 Information Format" published by UNIX International, Programming Languages
222 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
224 #define SIZEOF_DIE_LENGTH 4
225 #define SIZEOF_DIE_TAG 2
226 #define SIZEOF_ATTRIBUTE 2
227 #define SIZEOF_FORMAT_SPECIFIER 1
228 #define SIZEOF_FMT_FT 2
229 #define SIZEOF_LINETBL_LENGTH 4
230 #define SIZEOF_LINETBL_LINENO 4
231 #define SIZEOF_LINETBL_STMT 2
232 #define SIZEOF_LINETBL_DELTA 4
233 #define SIZEOF_LOC_ATOM_CODE 1
235 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
237 /* Macros that return the sizes of various types of data in the target
240 FIXME: Currently these are just compile time constants (as they are in
241 other parts of gdb as well). They need to be able to get the right size
242 either from the bfd or possibly from the DWARF info. It would be nice if
243 the DWARF producer inserted DIES that describe the fundamental types in
244 the target environment into the DWARF info, similar to the way dbx stabs
245 producers produce information about their fundamental types. */
247 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
248 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
250 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
251 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
252 However, the Issue 2 DWARF specification from AT&T defines it as
253 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
254 For backwards compatibility with the AT&T compiler produced executables
255 we define AT_short_element_list for this variant. */
257 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
259 /* External variables referenced. */
261 extern int info_verbose
; /* From main.c; nonzero => verbose */
262 extern char *warning_pre_print
; /* From utils.c */
264 /* The DWARF debugging information consists of two major pieces,
265 one is a block of DWARF Information Entries (DIE's) and the other
266 is a line number table. The "struct dieinfo" structure contains
267 the information for a single DIE, the one currently being processed.
269 In order to make it easier to randomly access the attribute fields
270 of the current DIE, which are specifically unordered within the DIE,
271 each DIE is scanned and an instance of the "struct dieinfo"
272 structure is initialized.
274 Initialization is done in two levels. The first, done by basicdieinfo(),
275 just initializes those fields that are vital to deciding whether or not
276 to use this DIE, how to skip past it, etc. The second, done by the
277 function completedieinfo(), fills in the rest of the information.
279 Attributes which have block forms are not interpreted at the time
280 the DIE is scanned, instead we just save pointers to the start
281 of their value fields.
283 Some fields have a flag <name>_p that is set when the value of the
284 field is valid (I.E. we found a matching attribute in the DIE). Since
285 we may want to test for the presence of some attributes in the DIE,
286 such as AT_low_pc, without restricting the values of the field,
287 we need someway to note that we found such an attribute.
294 char * die
; /* Pointer to the raw DIE data */
295 unsigned long die_length
; /* Length of the raw DIE data */
296 DIE_REF die_ref
; /* Offset of this DIE */
297 unsigned short die_tag
; /* Tag for this DIE */
298 unsigned long at_padding
;
299 unsigned long at_sibling
;
302 unsigned short at_fund_type
;
303 BLOCK
* at_mod_fund_type
;
304 unsigned long at_user_def_type
;
305 BLOCK
* at_mod_u_d_type
;
306 unsigned short at_ordering
;
307 BLOCK
* at_subscr_data
;
308 unsigned long at_byte_size
;
309 unsigned short at_bit_offset
;
310 unsigned long at_bit_size
;
311 BLOCK
* at_element_list
;
312 unsigned long at_stmt_list
;
313 unsigned long at_low_pc
;
314 unsigned long at_high_pc
;
315 unsigned long at_language
;
316 unsigned long at_member
;
317 unsigned long at_discr
;
318 BLOCK
* at_discr_value
;
319 BLOCK
* at_string_length
;
322 unsigned long at_start_scope
;
323 unsigned long at_stride_size
;
324 unsigned long at_src_info
;
325 char * at_prototyped
;
326 unsigned int has_at_low_pc
:1;
327 unsigned int has_at_stmt_list
:1;
328 unsigned int has_at_byte_size
:1;
329 unsigned int short_element_list
:1;
332 static int diecount
; /* Approximate count of dies for compilation unit */
333 static struct dieinfo
*curdie
; /* For warnings and such */
335 static char *dbbase
; /* Base pointer to dwarf info */
336 static int dbsize
; /* Size of dwarf info in bytes */
337 static int dbroff
; /* Relative offset from start of .debug section */
338 static char *lnbase
; /* Base pointer to line section */
339 static int isreg
; /* Kludge to identify register variables */
340 static int offreg
; /* Kludge to identify basereg references */
342 /* This value is added to each symbol value. FIXME: Generalize to
343 the section_offsets structure used by dbxread. */
344 static CORE_ADDR baseaddr
; /* Add to each symbol value */
346 /* The section offsets used in the current psymtab or symtab. FIXME,
347 only used to pass one value (baseaddr) at the moment. */
348 static struct section_offsets
*base_section_offsets
;
350 /* Each partial symbol table entry contains a pointer to private data for the
351 read_symtab() function to use when expanding a partial symbol table entry
352 to a full symbol table entry. For DWARF debugging info, this data is
353 contained in the following structure and macros are provided for easy
354 access to the members given a pointer to a partial symbol table entry.
356 dbfoff Always the absolute file offset to the start of the ".debug"
357 section for the file containing the DIE's being accessed.
359 dbroff Relative offset from the start of the ".debug" access to the
360 first DIE to be accessed. When building the partial symbol
361 table, this value will be zero since we are accessing the
362 entire ".debug" section. When expanding a partial symbol
363 table entry, this value will be the offset to the first
364 DIE for the compilation unit containing the symbol that
365 triggers the expansion.
367 dblength The size of the chunk of DIE's being examined, in bytes.
369 lnfoff The absolute file offset to the line table fragment. Ignored
370 when building partial symbol tables, but used when expanding
371 them, and contains the absolute file offset to the fragment
372 of the ".line" section containing the line numbers for the
373 current compilation unit.
377 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
378 int dbroff
; /* Relative offset from start of .debug section */
379 int dblength
; /* Size of the chunk of DIE's being examined */
380 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
383 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
384 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
385 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
386 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
388 /* The generic symbol table building routines have separate lists for
389 file scope symbols and all all other scopes (local scopes). So
390 we need to select the right one to pass to add_symbol_to_list().
391 We do it by keeping a pointer to the correct list in list_in_scope.
393 FIXME: The original dwarf code just treated the file scope as the first
394 local scope, and all other local scopes as nested local scopes, and worked
395 fine. Check to see if we really need to distinguish these in buildsym.c */
397 struct pending
**list_in_scope
= &file_symbols
;
399 /* DIES which have user defined types or modified user defined types refer to
400 other DIES for the type information. Thus we need to associate the offset
401 of a DIE for a user defined type with a pointer to the type information.
403 Originally this was done using a simple but expensive algorithm, with an
404 array of unsorted structures, each containing an offset/type-pointer pair.
405 This array was scanned linearly each time a lookup was done. The result
406 was that gdb was spending over half it's startup time munging through this
407 array of pointers looking for a structure that had the right offset member.
409 The second attempt used the same array of structures, but the array was
410 sorted using qsort each time a new offset/type was recorded, and a binary
411 search was used to find the type pointer for a given DIE offset. This was
412 even slower, due to the overhead of sorting the array each time a new
413 offset/type pair was entered.
415 The third attempt uses a fixed size array of type pointers, indexed by a
416 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
417 we can divide any DIE offset by 4 to obtain a unique index into this fixed
418 size array. Since each element is a 4 byte pointer, it takes exactly as
419 much memory to hold this array as to hold the DWARF info for a given
420 compilation unit. But it gets freed as soon as we are done with it.
421 This has worked well in practice, as a reasonable tradeoff between memory
422 consumption and speed, without having to resort to much more complicated
425 static struct type
**utypes
; /* Pointer to array of user type pointers */
426 static int numutypes
; /* Max number of user type pointers */
428 /* Maintain an array of referenced fundamental types for the current
429 compilation unit being read. For DWARF version 1, we have to construct
430 the fundamental types on the fly, since no information about the
431 fundamental types is supplied. Each such fundamental type is created by
432 calling a language dependent routine to create the type, and then a
433 pointer to that type is then placed in the array at the index specified
434 by it's FT_<TYPENAME> value. The array has a fixed size set by the
435 FT_NUM_MEMBERS compile time constant, which is the number of predefined
436 fundamental types gdb knows how to construct. */
438 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
440 /* Record the language for the compilation unit which is currently being
441 processed. We know it once we have seen the TAG_compile_unit DIE,
442 and we need it while processing the DIE's for that compilation unit.
443 It is eventually saved in the symtab structure, but we don't finalize
444 the symtab struct until we have processed all the DIE's for the
445 compilation unit. We also need to get and save a pointer to the
446 language struct for this language, so we can call the language
447 dependent routines for doing things such as creating fundamental
450 static enum language cu_language
;
451 static const struct language_defn
*cu_language_defn
;
453 /* Forward declarations of static functions so we don't have to worry
454 about ordering within this file. */
457 attribute_size
PARAMS ((unsigned int));
460 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
463 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
466 handle_producer
PARAMS ((char *));
469 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
472 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
475 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
479 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
482 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
483 file_ptr
, struct objfile
*));
486 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
489 init_psymbol_list
PARAMS ((struct objfile
*, int));
492 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
495 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
498 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
501 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
503 static struct symtab
*
504 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
507 process_dies
PARAMS ((char *, char *, struct objfile
*));
510 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
514 decode_array_element_type
PARAMS ((char *));
517 decode_subscript_data_item
PARAMS ((char *, char *));
520 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
523 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
526 read_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_subroutine_type -- process TAG_subroutine_type dies
1533 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1538 Handle DIES due to C code like:
1541 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1547 The parameter DIES are currently ignored. See if gdb has a way to
1548 include this info in it's type system, and decode them if so. Is
1549 this what the type structure's "arg_types" field is for? (FIXME)
1553 read_subroutine_type (dip
, thisdie
, enddie
)
1554 struct dieinfo
*dip
;
1558 struct type
*type
; /* Type that this function returns */
1559 struct type
*ftype
; /* Function that returns above type */
1561 /* Decode the type that this subroutine returns */
1563 type
= decode_die_type (dip
);
1565 /* Check to see if we already have a partially constructed user
1566 defined type for this DIE, from a forward reference. */
1568 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1570 /* This is the first reference to one of these types. Make
1571 a new one and place it in the user defined types. */
1572 ftype
= lookup_function_type (type
);
1573 alloc_utype (dip
-> die_ref
, ftype
);
1575 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1577 /* We have an existing partially constructed type, so bash it
1578 into the correct type. */
1579 TYPE_TARGET_TYPE (ftype
) = type
;
1580 TYPE_FUNCTION_TYPE (type
) = ftype
;
1581 TYPE_LENGTH (ftype
) = 1;
1582 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1586 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1594 read_enumeration -- process dies which define an enumeration
1598 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1599 char *enddie, struct objfile *objfile)
1603 Given a pointer to a die which begins an enumeration, process all
1604 the dies that define the members of the enumeration.
1608 Note that we need to call enum_type regardless of whether or not we
1609 have a symbol, since we might have an enum without a tag name (thus
1610 no symbol for the tagname).
1614 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1615 struct dieinfo
*dip
;
1618 struct objfile
*objfile
;
1623 type
= enum_type (dip
, objfile
);
1624 sym
= new_symbol (dip
, objfile
);
1627 SYMBOL_TYPE (sym
) = type
;
1628 if (cu_language
== language_cplus
)
1630 synthesize_typedef (dip
, objfile
, type
);
1639 enum_type -- decode and return a type for an enumeration
1643 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1647 Given a pointer to a die information structure for the die which
1648 starts an enumeration, process all the dies that define the members
1649 of the enumeration and return a type pointer for the enumeration.
1651 At the same time, for each member of the enumeration, create a
1652 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1653 and give it the type of the enumeration itself.
1657 Note that the DWARF specification explicitly mandates that enum
1658 constants occur in reverse order from the source program order,
1659 for "consistency" and because this ordering is easier for many
1660 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1661 Entries). Because gdb wants to see the enum members in program
1662 source order, we have to ensure that the order gets reversed while
1663 we are processing them.
1666 static struct type
*
1667 enum_type (dip
, objfile
)
1668 struct dieinfo
*dip
;
1669 struct objfile
*objfile
;
1673 struct nextfield
*next
;
1676 struct nextfield
*list
= NULL
;
1677 struct nextfield
*new;
1682 unsigned short blocksz
;
1686 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1688 /* No forward references created an empty type, so install one now */
1689 type
= alloc_utype (dip
-> die_ref
, NULL
);
1691 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1692 /* Some compilers try to be helpful by inventing "fake" names for
1693 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1694 Thanks, but no thanks... */
1695 if (dip
-> at_name
!= NULL
1696 && *dip
-> at_name
!= '~'
1697 && *dip
-> at_name
!= '.')
1699 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1700 " ", dip
-> at_name
);
1702 if (dip
-> at_byte_size
!= 0)
1704 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1706 if ((scan
= dip
-> at_element_list
) != NULL
)
1708 if (dip
-> short_element_list
)
1710 nbytes
= attribute_size (AT_short_element_list
);
1714 nbytes
= attribute_size (AT_element_list
);
1716 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1717 listend
= scan
+ nbytes
+ blocksz
;
1719 while (scan
< listend
)
1721 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1724 list
-> field
.type
= NULL
;
1725 list
-> field
.bitsize
= 0;
1726 list
-> field
.bitpos
=
1727 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1729 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1730 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1731 &objfile
-> type_obstack
);
1732 scan
+= strlen (scan
) + 1;
1734 /* Handcraft a new symbol for this enum member. */
1735 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1736 sizeof (struct symbol
));
1737 memset (sym
, 0, sizeof (struct symbol
));
1738 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1739 &objfile
->symbol_obstack
);
1740 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
1741 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1742 SYMBOL_CLASS (sym
) = LOC_CONST
;
1743 SYMBOL_TYPE (sym
) = type
;
1744 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1745 add_symbol_to_list (sym
, list_in_scope
);
1747 /* Now create the vector of fields, and record how big it is. This is
1748 where we reverse the order, by pulling the members off the list in
1749 reverse order from how they were inserted. If we have no fields
1750 (this is apparently possible in C++) then skip building a field
1754 TYPE_NFIELDS (type
) = nfields
;
1755 TYPE_FIELDS (type
) = (struct field
*)
1756 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1757 /* Copy the saved-up fields into the field vector. */
1758 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1760 TYPE_FIELD (type
, n
++) = list
-> field
;
1771 read_func_scope -- process all dies within a function scope
1775 Process all dies within a given function scope. We are passed
1776 a die information structure pointer DIP for the die which
1777 starts the function scope, and pointers into the raw die data
1778 that define the dies within the function scope.
1780 For now, we ignore lexical block scopes within the function.
1781 The problem is that AT&T cc does not define a DWARF lexical
1782 block scope for the function itself, while gcc defines a
1783 lexical block scope for the function. We need to think about
1784 how to handle this difference, or if it is even a problem.
1789 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1790 struct dieinfo
*dip
;
1793 struct objfile
*objfile
;
1795 register struct context_stack
*new;
1797 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1798 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1800 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1801 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1803 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1805 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1806 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1808 new = push_context (0, dip
-> at_low_pc
);
1809 new -> name
= new_symbol (dip
, objfile
);
1810 list_in_scope
= &local_symbols
;
1811 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1812 new = pop_context ();
1813 /* Make a block for the local symbols within. */
1814 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1815 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1816 list_in_scope
= &file_symbols
;
1824 handle_producer -- process the AT_producer attribute
1828 Perform any operations that depend on finding a particular
1829 AT_producer attribute.
1834 handle_producer (producer
)
1838 /* If this compilation unit was compiled with g++ or gcc, then set the
1839 processing_gcc_compilation flag. */
1841 processing_gcc_compilation
=
1842 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1843 /* start-sanitize-chill */
1844 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1845 /* end-sanitize-chill */
1846 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1848 /* Select a demangling style if we can identify the producer and if
1849 the current style is auto. We leave the current style alone if it
1850 is not auto. We also leave the demangling style alone if we find a
1851 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1853 #if 1 /* Works, but is experimental. -fnf */
1854 if (AUTO_DEMANGLING
)
1856 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1858 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1860 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1862 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1864 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1866 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1877 read_file_scope -- process all dies within a file scope
1881 Process all dies within a given file scope. We are passed a
1882 pointer to the die information structure for the die which
1883 starts the file scope, and pointers into the raw die data which
1884 mark the range of dies within the file scope.
1886 When the partial symbol table is built, the file offset for the line
1887 number table for each compilation unit is saved in the partial symbol
1888 table entry for that compilation unit. As the symbols for each
1889 compilation unit are read, the line number table is read into memory
1890 and the variable lnbase is set to point to it. Thus all we have to
1891 do is use lnbase to access the line number table for the current
1896 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1897 struct dieinfo
*dip
;
1900 struct objfile
*objfile
;
1902 struct cleanup
*back_to
;
1903 struct symtab
*symtab
;
1905 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1906 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1908 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1909 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1911 set_cu_language (dip
);
1912 if (dip
-> at_producer
!= NULL
)
1914 handle_producer (dip
-> at_producer
);
1916 numutypes
= (enddie
- thisdie
) / 4;
1917 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1918 back_to
= make_cleanup (free
, utypes
);
1919 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1920 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1921 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1922 decode_line_numbers (lnbase
);
1923 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1924 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1927 symtab
-> language
= cu_language
;
1929 do_cleanups (back_to
);
1938 process_dies -- process a range of DWARF Information Entries
1942 static void process_dies (char *thisdie, char *enddie,
1943 struct objfile *objfile)
1947 Process all DIE's in a specified range. May be (and almost
1948 certainly will be) called recursively.
1952 process_dies (thisdie
, enddie
, objfile
)
1955 struct objfile
*objfile
;
1960 while (thisdie
< enddie
)
1962 basicdieinfo (&di
, thisdie
, objfile
);
1963 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1967 else if (di
.die_tag
== TAG_padding
)
1969 nextdie
= thisdie
+ di
.die_length
;
1973 completedieinfo (&di
, objfile
);
1974 if (di
.at_sibling
!= 0)
1976 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1980 nextdie
= thisdie
+ di
.die_length
;
1984 case TAG_compile_unit
:
1985 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1987 case TAG_global_subroutine
:
1988 case TAG_subroutine
:
1989 if (di
.has_at_low_pc
)
1991 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1994 case TAG_lexical_block
:
1995 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1997 case TAG_class_type
:
1998 case TAG_structure_type
:
1999 case TAG_union_type
:
2000 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
2002 case TAG_enumeration_type
:
2003 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
2005 case TAG_subroutine_type
:
2006 read_subroutine_type (&di
, thisdie
, nextdie
);
2008 case TAG_array_type
:
2009 dwarf_read_array_type (&di
);
2011 case TAG_pointer_type
:
2012 read_tag_pointer_type (&di
);
2015 new_symbol (&di
, objfile
);
2027 decode_line_numbers -- decode a line number table fragment
2031 static void decode_line_numbers (char *tblscan, char *tblend,
2032 long length, long base, long line, long pc)
2036 Translate the DWARF line number information to gdb form.
2038 The ".line" section contains one or more line number tables, one for
2039 each ".line" section from the objects that were linked.
2041 The AT_stmt_list attribute for each TAG_source_file entry in the
2042 ".debug" section contains the offset into the ".line" section for the
2043 start of the table for that file.
2045 The table itself has the following structure:
2047 <table length><base address><source statement entry>
2048 4 bytes 4 bytes 10 bytes
2050 The table length is the total size of the table, including the 4 bytes
2051 for the length information.
2053 The base address is the address of the first instruction generated
2054 for the source file.
2056 Each source statement entry has the following structure:
2058 <line number><statement position><address delta>
2059 4 bytes 2 bytes 4 bytes
2061 The line number is relative to the start of the file, starting with
2064 The statement position either -1 (0xFFFF) or the number of characters
2065 from the beginning of the line to the beginning of the statement.
2067 The address delta is the difference between the base address and
2068 the address of the first instruction for the statement.
2070 Note that we must copy the bytes from the packed table to our local
2071 variables before attempting to use them, to avoid alignment problems
2072 on some machines, particularly RISC processors.
2076 Does gdb expect the line numbers to be sorted? They are now by
2077 chance/luck, but are not required to be. (FIXME)
2079 The line with number 0 is unused, gdb apparently can discover the
2080 span of the last line some other way. How? (FIXME)
2084 decode_line_numbers (linetable
)
2089 unsigned long length
;
2094 if (linetable
!= NULL
)
2096 tblscan
= tblend
= linetable
;
2097 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2099 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2101 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2102 GET_UNSIGNED
, current_objfile
);
2103 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2105 while (tblscan
< tblend
)
2107 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2109 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2110 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2112 tblscan
+= SIZEOF_LINETBL_DELTA
;
2116 record_line (current_subfile
, line
, pc
);
2126 locval -- compute the value of a location attribute
2130 static int locval (char *loc)
2134 Given pointer to a string of bytes that define a location, compute
2135 the location and return the value.
2137 When computing values involving the current value of the frame pointer,
2138 the value zero is used, which results in a value relative to the frame
2139 pointer, rather than the absolute value. This is what GDB wants
2142 When the result is a register number, the global isreg flag is set,
2143 otherwise it is cleared. This is a kludge until we figure out a better
2144 way to handle the problem. Gdb's design does not mesh well with the
2145 DWARF notion of a location computing interpreter, which is a shame
2146 because the flexibility goes unused.
2150 Note that stack[0] is unused except as a default error return.
2151 Note that stack overflow is not yet handled.
2158 unsigned short nbytes
;
2159 unsigned short locsize
;
2160 auto long stack
[64];
2167 nbytes
= attribute_size (AT_location
);
2168 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2170 end
= loc
+ locsize
;
2175 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2178 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2180 loc
+= SIZEOF_LOC_ATOM_CODE
;
2181 switch (loc_atom_code
)
2188 /* push register (number) */
2189 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2190 GET_UNSIGNED
, current_objfile
);
2191 loc
+= loc_value_size
;
2195 /* push value of register (number) */
2196 /* Actually, we compute the value as if register has 0 */
2198 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2200 loc
+= loc_value_size
;
2203 stack
[++stacki
] = 0;
2207 stack
[++stacki
] = 0;
2209 complain (&basereg_not_handled
, DIE_ID
, DIE_NAME
, regno
);
2213 /* push address (relocated address) */
2214 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2215 GET_UNSIGNED
, current_objfile
);
2216 loc
+= loc_value_size
;
2219 /* push constant (number) FIXME: signed or unsigned! */
2220 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2221 GET_SIGNED
, current_objfile
);
2222 loc
+= loc_value_size
;
2225 /* pop, deref and push 2 bytes (as a long) */
2226 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2228 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2229 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2231 case OP_ADD
: /* pop top 2 items, add, push result */
2232 stack
[stacki
- 1] += stack
[stacki
];
2237 return (stack
[stacki
]);
2244 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2248 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2252 When expanding a partial symbol table entry to a full symbol table
2253 entry, this is the function that gets called to read in the symbols
2254 for the compilation unit.
2256 Returns a pointer to the newly constructed symtab (which is now
2257 the new first one on the objfile's symtab list).
2260 static struct symtab
*
2261 read_ofile_symtab (pst
)
2262 struct partial_symtab
*pst
;
2264 struct cleanup
*back_to
;
2265 unsigned long lnsize
;
2268 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2270 abfd
= pst
-> objfile
-> obfd
;
2271 current_objfile
= pst
-> objfile
;
2273 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2274 unit, seek to the location in the file, and read in all the DIE's. */
2277 dbsize
= DBLENGTH (pst
);
2278 dbbase
= xmalloc (dbsize
);
2279 dbroff
= DBROFF(pst
);
2280 foffset
= DBFOFF(pst
) + dbroff
;
2281 base_section_offsets
= pst
->section_offsets
;
2282 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2283 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2284 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2287 error ("can't read DWARF data");
2289 back_to
= make_cleanup (free
, dbbase
);
2291 /* If there is a line number table associated with this compilation unit
2292 then read the size of this fragment in bytes, from the fragment itself.
2293 Allocate a buffer for the fragment and read it in for future
2299 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2300 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2301 sizeof (lnsizedata
)))
2303 error ("can't read DWARF line number table size");
2305 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2306 GET_UNSIGNED
, pst
-> objfile
);
2307 lnbase
= xmalloc (lnsize
);
2308 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2309 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2312 error ("can't read DWARF line numbers");
2314 make_cleanup (free
, lnbase
);
2317 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2318 do_cleanups (back_to
);
2319 current_objfile
= NULL
;
2320 return (pst
-> objfile
-> symtabs
);
2327 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2331 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2335 Called once for each partial symbol table entry that needs to be
2336 expanded into a full symbol table entry.
2341 psymtab_to_symtab_1 (pst
)
2342 struct partial_symtab
*pst
;
2345 struct cleanup
*old_chain
;
2351 warning ("psymtab for %s already read in. Shouldn't happen.",
2356 /* Read in all partial symtabs on which this one is dependent */
2357 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2359 if (!pst
-> dependencies
[i
] -> readin
)
2361 /* Inform about additional files that need to be read in. */
2364 fputs_filtered (" ", stdout
);
2366 fputs_filtered ("and ", stdout
);
2368 printf_filtered ("%s...",
2369 pst
-> dependencies
[i
] -> filename
);
2371 fflush (stdout
); /* Flush output */
2373 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2376 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2379 old_chain
= make_cleanup (really_free_pendings
, 0);
2380 pst
-> symtab
= read_ofile_symtab (pst
);
2383 printf_filtered ("%d DIE's, sorting...", diecount
);
2387 sort_symtab_syms (pst
-> symtab
);
2388 do_cleanups (old_chain
);
2399 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2403 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2407 This is the DWARF support entry point for building a full symbol
2408 table entry from a partial symbol table entry. We are passed a
2409 pointer to the partial symbol table entry that needs to be expanded.
2414 dwarf_psymtab_to_symtab (pst
)
2415 struct partial_symtab
*pst
;
2422 warning ("psymtab for %s already read in. Shouldn't happen.",
2427 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2429 /* Print the message now, before starting serious work, to avoid
2430 disconcerting pauses. */
2433 printf_filtered ("Reading in symbols for %s...",
2438 psymtab_to_symtab_1 (pst
);
2440 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2441 we need to do an equivalent or is this something peculiar to
2443 Match with global symbols. This only needs to be done once,
2444 after all of the symtabs and dependencies have been read in.
2446 scan_file_globals (pst
-> objfile
);
2449 /* Finish up the verbose info message. */
2452 printf_filtered ("done.\n");
2464 init_psymbol_list -- initialize storage for partial symbols
2468 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2472 Initializes storage for all of the partial symbols that will be
2473 created by dwarf_build_psymtabs and subsidiaries.
2477 init_psymbol_list (objfile
, total_symbols
)
2478 struct objfile
*objfile
;
2481 /* Free any previously allocated psymbol lists. */
2483 if (objfile
-> global_psymbols
.list
)
2485 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2487 if (objfile
-> static_psymbols
.list
)
2489 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2492 /* Current best guess is that there are approximately a twentieth
2493 of the total symbols (in a debugging file) are global or static
2496 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2497 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2498 objfile
-> global_psymbols
.next
=
2499 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2500 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2501 * sizeof (struct partial_symbol
));
2502 objfile
-> static_psymbols
.next
=
2503 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2504 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2505 * sizeof (struct partial_symbol
));
2512 add_enum_psymbol -- add enumeration members to partial symbol table
2516 Given pointer to a DIE that is known to be for an enumeration,
2517 extract the symbolic names of the enumeration members and add
2518 partial symbols for them.
2522 add_enum_psymbol (dip
, objfile
)
2523 struct dieinfo
*dip
;
2524 struct objfile
*objfile
;
2528 unsigned short blocksz
;
2531 if ((scan
= dip
-> at_element_list
) != NULL
)
2533 if (dip
-> short_element_list
)
2535 nbytes
= attribute_size (AT_short_element_list
);
2539 nbytes
= attribute_size (AT_element_list
);
2541 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2543 listend
= scan
+ blocksz
;
2544 while (scan
< listend
)
2546 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2547 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2548 objfile
-> static_psymbols
, 0, cu_language
,
2550 scan
+= strlen (scan
) + 1;
2559 add_partial_symbol -- add symbol to partial symbol table
2563 Given a DIE, if it is one of the types that we want to
2564 add to a partial symbol table, finish filling in the die info
2565 and then add a partial symbol table entry for it.
2569 The caller must ensure that the DIE has a valid name attribute.
2573 add_partial_symbol (dip
, objfile
)
2574 struct dieinfo
*dip
;
2575 struct objfile
*objfile
;
2577 switch (dip
-> die_tag
)
2579 case TAG_global_subroutine
:
2580 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2582 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2583 VAR_NAMESPACE
, LOC_BLOCK
,
2584 objfile
-> global_psymbols
,
2585 dip
-> at_low_pc
, cu_language
, objfile
);
2587 case TAG_global_variable
:
2588 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2590 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2591 VAR_NAMESPACE
, LOC_STATIC
,
2592 objfile
-> global_psymbols
,
2593 0, cu_language
, objfile
);
2595 case TAG_subroutine
:
2596 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2597 VAR_NAMESPACE
, LOC_BLOCK
,
2598 objfile
-> static_psymbols
,
2599 dip
-> at_low_pc
, cu_language
, objfile
);
2601 case TAG_local_variable
:
2602 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2603 VAR_NAMESPACE
, LOC_STATIC
,
2604 objfile
-> static_psymbols
,
2605 0, cu_language
, objfile
);
2608 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2609 VAR_NAMESPACE
, LOC_TYPEDEF
,
2610 objfile
-> static_psymbols
,
2611 0, cu_language
, objfile
);
2613 case TAG_class_type
:
2614 case TAG_structure_type
:
2615 case TAG_union_type
:
2616 case TAG_enumeration_type
:
2617 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2618 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2619 objfile
-> static_psymbols
,
2620 0, cu_language
, objfile
);
2621 if (cu_language
== language_cplus
)
2623 /* For C++, these implicitly act as typedefs as well. */
2624 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2625 VAR_NAMESPACE
, LOC_TYPEDEF
,
2626 objfile
-> static_psymbols
,
2627 0, cu_language
, objfile
);
2637 scan_partial_symbols -- scan DIE's within a single compilation unit
2641 Process the DIE's within a single compilation unit, looking for
2642 interesting DIE's that contribute to the partial symbol table entry
2643 for this compilation unit.
2647 There are some DIE's that may appear both at file scope and within
2648 the scope of a function. We are only interested in the ones at file
2649 scope, and the only way to tell them apart is to keep track of the
2650 scope. For example, consider the test case:
2655 for which the relevant DWARF segment has the structure:
2658 0x23 global subrtn sibling 0x9b
2660 fund_type FT_integer
2665 0x23 local var sibling 0x97
2667 fund_type FT_integer
2668 location OP_BASEREG 0xe
2675 0x1d local var sibling 0xb8
2677 fund_type FT_integer
2678 location OP_ADDR 0x800025dc
2683 We want to include the symbol 'i' in the partial symbol table, but
2684 not the symbol 'j'. In essence, we want to skip all the dies within
2685 the scope of a TAG_global_subroutine DIE.
2687 Don't attempt to add anonymous structures or unions since they have
2688 no name. Anonymous enumerations however are processed, because we
2689 want to extract their member names (the check for a tag name is
2692 Also, for variables and subroutines, check that this is the place
2693 where the actual definition occurs, rather than just a reference
2698 scan_partial_symbols (thisdie
, enddie
, objfile
)
2701 struct objfile
*objfile
;
2707 while (thisdie
< enddie
)
2709 basicdieinfo (&di
, thisdie
, objfile
);
2710 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2716 nextdie
= thisdie
+ di
.die_length
;
2717 /* To avoid getting complete die information for every die, we
2718 only do it (below) for the cases we are interested in. */
2721 case TAG_global_subroutine
:
2722 case TAG_subroutine
:
2723 completedieinfo (&di
, objfile
);
2724 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2726 add_partial_symbol (&di
, objfile
);
2727 /* If there is a sibling attribute, adjust the nextdie
2728 pointer to skip the entire scope of the subroutine.
2729 Apply some sanity checking to make sure we don't
2730 overrun or underrun the range of remaining DIE's */
2731 if (di
.at_sibling
!= 0)
2733 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2734 if ((temp
< thisdie
) || (temp
>= enddie
))
2736 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2746 case TAG_global_variable
:
2747 case TAG_local_variable
:
2748 completedieinfo (&di
, objfile
);
2749 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2751 add_partial_symbol (&di
, objfile
);
2755 case TAG_class_type
:
2756 case TAG_structure_type
:
2757 case TAG_union_type
:
2758 completedieinfo (&di
, objfile
);
2761 add_partial_symbol (&di
, objfile
);
2764 case TAG_enumeration_type
:
2765 completedieinfo (&di
, objfile
);
2768 add_partial_symbol (&di
, objfile
);
2770 add_enum_psymbol (&di
, objfile
);
2782 scan_compilation_units -- build a psymtab entry for each compilation
2786 This is the top level dwarf parsing routine for building partial
2789 It scans from the beginning of the DWARF table looking for the first
2790 TAG_compile_unit DIE, and then follows the sibling chain to locate
2791 each additional TAG_compile_unit DIE.
2793 For each TAG_compile_unit DIE it creates a partial symtab structure,
2794 calls a subordinate routine to collect all the compilation unit's
2795 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2796 new partial symtab structure into the partial symbol table. It also
2797 records the appropriate information in the partial symbol table entry
2798 to allow the chunk of DIE's and line number table for this compilation
2799 unit to be located and re-read later, to generate a complete symbol
2800 table entry for the compilation unit.
2802 Thus it effectively partitions up a chunk of DIE's for multiple
2803 compilation units into smaller DIE chunks and line number tables,
2804 and associates them with a partial symbol table entry.
2808 If any compilation unit has no line number table associated with
2809 it for some reason (a missing at_stmt_list attribute, rather than
2810 just one with a value of zero, which is valid) then we ensure that
2811 the recorded file offset is zero so that the routine which later
2812 reads line number table fragments knows that there is no fragment
2822 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2827 struct objfile
*objfile
;
2831 struct partial_symtab
*pst
;
2834 file_ptr curlnoffset
;
2836 while (thisdie
< enddie
)
2838 basicdieinfo (&di
, thisdie
, objfile
);
2839 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2843 else if (di
.die_tag
!= TAG_compile_unit
)
2845 nextdie
= thisdie
+ di
.die_length
;
2849 completedieinfo (&di
, objfile
);
2850 set_cu_language (&di
);
2851 if (di
.at_sibling
!= 0)
2853 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2857 nextdie
= thisdie
+ di
.die_length
;
2859 curoff
= thisdie
- dbbase
;
2860 culength
= nextdie
- thisdie
;
2861 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2863 /* First allocate a new partial symbol table structure */
2865 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2866 di
.at_name
, di
.at_low_pc
,
2867 objfile
-> global_psymbols
.next
,
2868 objfile
-> static_psymbols
.next
);
2870 pst
-> texthigh
= di
.at_high_pc
;
2871 pst
-> read_symtab_private
= (char *)
2872 obstack_alloc (&objfile
-> psymbol_obstack
,
2873 sizeof (struct dwfinfo
));
2874 DBFOFF (pst
) = dbfoff
;
2875 DBROFF (pst
) = curoff
;
2876 DBLENGTH (pst
) = culength
;
2877 LNFOFF (pst
) = curlnoffset
;
2878 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2880 /* Now look for partial symbols */
2882 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2884 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2885 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2886 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2887 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2888 sort_pst_symbols (pst
);
2889 /* If there is already a psymtab or symtab for a file of this name,
2890 remove it. (If there is a symtab, more drastic things also
2891 happen.) This happens in VxWorks. */
2892 free_named_symtabs (pst
-> filename
);
2902 new_symbol -- make a symbol table entry for a new symbol
2906 static struct symbol *new_symbol (struct dieinfo *dip,
2907 struct objfile *objfile)
2911 Given a pointer to a DWARF information entry, figure out if we need
2912 to make a symbol table entry for it, and if so, create a new entry
2913 and return a pointer to it.
2916 static struct symbol
*
2917 new_symbol (dip
, objfile
)
2918 struct dieinfo
*dip
;
2919 struct objfile
*objfile
;
2921 struct symbol
*sym
= NULL
;
2923 if (dip
-> at_name
!= NULL
)
2925 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2926 sizeof (struct symbol
));
2927 memset (sym
, 0, sizeof (struct symbol
));
2928 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2929 &objfile
->symbol_obstack
);
2930 /* default assumptions */
2931 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2932 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2933 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2935 /* If this symbol is from a C++ compilation, then attempt to cache the
2936 demangled form for future reference. This is a typical time versus
2937 space tradeoff, that was decided in favor of time because it sped up
2938 C++ symbol lookups by a factor of about 20. */
2940 SYMBOL_LANGUAGE (sym
) = cu_language
;
2941 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
-> symbol_obstack
);
2942 switch (dip
-> die_tag
)
2945 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2946 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2948 case TAG_global_subroutine
:
2949 case TAG_subroutine
:
2950 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2951 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2952 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2953 if (dip
-> die_tag
== TAG_global_subroutine
)
2955 add_symbol_to_list (sym
, &global_symbols
);
2959 add_symbol_to_list (sym
, list_in_scope
);
2962 case TAG_global_variable
:
2963 if (dip
-> at_location
!= NULL
)
2965 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2966 add_symbol_to_list (sym
, &global_symbols
);
2967 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2968 SYMBOL_VALUE (sym
) += baseaddr
;
2971 case TAG_local_variable
:
2972 if (dip
-> at_location
!= NULL
)
2974 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2975 add_symbol_to_list (sym
, list_in_scope
);
2978 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2982 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2986 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2987 SYMBOL_VALUE (sym
) += baseaddr
;
2991 case TAG_formal_parameter
:
2992 if (dip
-> at_location
!= NULL
)
2994 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2996 add_symbol_to_list (sym
, list_in_scope
);
2999 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3003 SYMBOL_CLASS (sym
) = LOC_ARG
;
3006 case TAG_unspecified_parameters
:
3007 /* From varargs functions; gdb doesn't seem to have any interest in
3008 this information, so just ignore it for now. (FIXME?) */
3010 case TAG_class_type
:
3011 case TAG_structure_type
:
3012 case TAG_union_type
:
3013 case TAG_enumeration_type
:
3014 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3015 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3016 add_symbol_to_list (sym
, list_in_scope
);
3019 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3020 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3021 add_symbol_to_list (sym
, list_in_scope
);
3024 /* Not a tag we recognize. Hopefully we aren't processing trash
3025 data, but since we must specifically ignore things we don't
3026 recognize, there is nothing else we should do at this point. */
3037 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3041 static void synthesize_typedef (struct dieinfo *dip,
3042 struct objfile *objfile,
3047 Given a pointer to a DWARF information entry, synthesize a typedef
3048 for the name in the DIE, using the specified type.
3050 This is used for C++ class, structs, unions, and enumerations to
3051 set up the tag name as a type.
3056 synthesize_typedef (dip
, objfile
, type
)
3057 struct dieinfo
*dip
;
3058 struct objfile
*objfile
;
3061 struct symbol
*sym
= NULL
;
3063 if (dip
-> at_name
!= NULL
)
3065 sym
= (struct symbol
*)
3066 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3067 memset (sym
, 0, sizeof (struct symbol
));
3068 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3069 &objfile
->symbol_obstack
);
3070 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym
, cu_language
);
3071 SYMBOL_TYPE (sym
) = type
;
3072 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3073 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3074 add_symbol_to_list (sym
, list_in_scope
);
3082 decode_mod_fund_type -- decode a modified fundamental type
3086 static struct type *decode_mod_fund_type (char *typedata)
3090 Decode a block of data containing a modified fundamental
3091 type specification. TYPEDATA is a pointer to the block,
3092 which starts with a length containing the size of the rest
3093 of the block. At the end of the block is a fundmental type
3094 code value that gives the fundamental type. Everything
3095 in between are type modifiers.
3097 We simply compute the number of modifiers and call the general
3098 function decode_modified_type to do the actual work.
3101 static struct type
*
3102 decode_mod_fund_type (typedata
)
3105 struct type
*typep
= NULL
;
3106 unsigned short modcount
;
3109 /* Get the total size of the block, exclusive of the size itself */
3111 nbytes
= attribute_size (AT_mod_fund_type
);
3112 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3115 /* Deduct the size of the fundamental type bytes at the end of the block. */
3117 modcount
-= attribute_size (AT_fund_type
);
3119 /* Now do the actual decoding */
3121 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3129 decode_mod_u_d_type -- decode a modified user defined type
3133 static struct type *decode_mod_u_d_type (char *typedata)
3137 Decode a block of data containing a modified user defined
3138 type specification. TYPEDATA is a pointer to the block,
3139 which consists of a two byte length, containing the size
3140 of the rest of the block. At the end of the block is a
3141 four byte value that gives a reference to a user defined type.
3142 Everything in between are type modifiers.
3144 We simply compute the number of modifiers and call the general
3145 function decode_modified_type to do the actual work.
3148 static struct type
*
3149 decode_mod_u_d_type (typedata
)
3152 struct type
*typep
= NULL
;
3153 unsigned short modcount
;
3156 /* Get the total size of the block, exclusive of the size itself */
3158 nbytes
= attribute_size (AT_mod_u_d_type
);
3159 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3162 /* Deduct the size of the reference type bytes at the end of the block. */
3164 modcount
-= attribute_size (AT_user_def_type
);
3166 /* Now do the actual decoding */
3168 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3176 decode_modified_type -- decode modified user or fundamental type
3180 static struct type *decode_modified_type (char *modifiers,
3181 unsigned short modcount, int mtype)
3185 Decode a modified type, either a modified fundamental type or
3186 a modified user defined type. MODIFIERS is a pointer to the
3187 block of bytes that define MODCOUNT modifiers. Immediately
3188 following the last modifier is a short containing the fundamental
3189 type or a long containing the reference to the user defined
3190 type. Which one is determined by MTYPE, which is either
3191 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3192 type we are generating.
3194 We call ourself recursively to generate each modified type,`
3195 until MODCOUNT reaches zero, at which point we have consumed
3196 all the modifiers and generate either the fundamental type or
3197 user defined type. When the recursion unwinds, each modifier
3198 is applied in turn to generate the full modified type.
3202 If we find a modifier that we don't recognize, and it is not one
3203 of those reserved for application specific use, then we issue a
3204 warning and simply ignore the modifier.
3208 We currently ignore MOD_const and MOD_volatile. (FIXME)
3212 static struct type
*
3213 decode_modified_type (modifiers
, modcount
, mtype
)
3215 unsigned int modcount
;
3218 struct type
*typep
= NULL
;
3219 unsigned short fundtype
;
3228 case AT_mod_fund_type
:
3229 nbytes
= attribute_size (AT_fund_type
);
3230 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3232 typep
= decode_fund_type (fundtype
);
3234 case AT_mod_u_d_type
:
3235 nbytes
= attribute_size (AT_user_def_type
);
3236 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3238 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3240 typep
= alloc_utype (die_ref
, NULL
);
3244 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3245 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3251 modifier
= *modifiers
++;
3252 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3255 case MOD_pointer_to
:
3256 typep
= lookup_pointer_type (typep
);
3258 case MOD_reference_to
:
3259 typep
= lookup_reference_type (typep
);
3262 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3265 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3268 if (!(MOD_lo_user
<= (unsigned char) modifier
3269 && (unsigned char) modifier
<= MOD_hi_user
))
3271 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3283 decode_fund_type -- translate basic DWARF type to gdb base type
3287 Given an integer that is one of the fundamental DWARF types,
3288 translate it to one of the basic internal gdb types and return
3289 a pointer to the appropriate gdb type (a "struct type *").
3293 For robustness, if we are asked to translate a fundamental
3294 type that we are unprepared to deal with, we return int so
3295 callers can always depend upon a valid type being returned,
3296 and so gdb may at least do something reasonable by default.
3297 If the type is not in the range of those types defined as
3298 application specific types, we also issue a warning.
3301 static struct type
*
3302 decode_fund_type (fundtype
)
3303 unsigned int fundtype
;
3305 struct type
*typep
= NULL
;
3311 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3314 case FT_boolean
: /* Was FT_set in AT&T version */
3315 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3318 case FT_pointer
: /* (void *) */
3319 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3320 typep
= lookup_pointer_type (typep
);
3324 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3327 case FT_signed_char
:
3328 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3331 case FT_unsigned_char
:
3332 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3336 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3339 case FT_signed_short
:
3340 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3343 case FT_unsigned_short
:
3344 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3348 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3351 case FT_signed_integer
:
3352 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3355 case FT_unsigned_integer
:
3356 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3360 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3363 case FT_signed_long
:
3364 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3367 case FT_unsigned_long
:
3368 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3372 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3375 case FT_signed_long_long
:
3376 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3379 case FT_unsigned_long_long
:
3380 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3384 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3387 case FT_dbl_prec_float
:
3388 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3391 case FT_ext_prec_float
:
3392 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3396 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3399 case FT_dbl_prec_complex
:
3400 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3403 case FT_ext_prec_complex
:
3404 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3411 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3412 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3414 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3425 create_name -- allocate a fresh copy of a string on an obstack
3429 Given a pointer to a string and a pointer to an obstack, allocates
3430 a fresh copy of the string on the specified obstack.
3435 create_name (name
, obstackp
)
3437 struct obstack
*obstackp
;
3442 length
= strlen (name
) + 1;
3443 newname
= (char *) obstack_alloc (obstackp
, length
);
3444 strcpy (newname
, name
);
3452 basicdieinfo -- extract the minimal die info from raw die data
3456 void basicdieinfo (char *diep, struct dieinfo *dip,
3457 struct objfile *objfile)
3461 Given a pointer to raw DIE data, and a pointer to an instance of a
3462 die info structure, this function extracts the basic information
3463 from the DIE data required to continue processing this DIE, along
3464 with some bookkeeping information about the DIE.
3466 The information we absolutely must have includes the DIE tag,
3467 and the DIE length. If we need the sibling reference, then we
3468 will have to call completedieinfo() to process all the remaining
3471 Note that since there is no guarantee that the data is properly
3472 aligned in memory for the type of access required (indirection
3473 through anything other than a char pointer), and there is no
3474 guarantee that it is in the same byte order as the gdb host,
3475 we call a function which deals with both alignment and byte
3476 swapping issues. Possibly inefficient, but quite portable.
3478 We also take care of some other basic things at this point, such
3479 as ensuring that the instance of the die info structure starts
3480 out completely zero'd and that curdie is initialized for use
3481 in error reporting if we have a problem with the current die.
3485 All DIE's must have at least a valid length, thus the minimum
3486 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3487 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3488 are forced to be TAG_padding DIES.
3490 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3491 that if a padding DIE is used for alignment and the amount needed is
3492 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3493 enough to align to the next alignment boundry.
3495 We do some basic sanity checking here, such as verifying that the
3496 length of the die would not cause it to overrun the recorded end of
3497 the buffer holding the DIE info. If we find a DIE that is either
3498 too small or too large, we force it's length to zero which should
3499 cause the caller to take appropriate action.
3503 basicdieinfo (dip
, diep
, objfile
)
3504 struct dieinfo
*dip
;
3506 struct objfile
*objfile
;
3509 memset (dip
, 0, sizeof (struct dieinfo
));
3511 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3512 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3514 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3515 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3517 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3518 dip
-> die_length
= 0;
3520 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3522 dip
-> die_tag
= TAG_padding
;
3526 diep
+= SIZEOF_DIE_LENGTH
;
3527 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3536 completedieinfo -- finish reading the information for a given DIE
3540 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3544 Given a pointer to an already partially initialized die info structure,
3545 scan the raw DIE data and finish filling in the die info structure
3546 from the various attributes found.
3548 Note that since there is no guarantee that the data is properly
3549 aligned in memory for the type of access required (indirection
3550 through anything other than a char pointer), and there is no
3551 guarantee that it is in the same byte order as the gdb host,
3552 we call a function which deals with both alignment and byte
3553 swapping issues. Possibly inefficient, but quite portable.
3557 Each time we are called, we increment the diecount variable, which
3558 keeps an approximate count of the number of dies processed for
3559 each compilation unit. This information is presented to the user
3560 if the info_verbose flag is set.
3565 completedieinfo (dip
, objfile
)
3566 struct dieinfo
*dip
;
3567 struct objfile
*objfile
;
3569 char *diep
; /* Current pointer into raw DIE data */
3570 char *end
; /* Terminate DIE scan here */
3571 unsigned short attr
; /* Current attribute being scanned */
3572 unsigned short form
; /* Form of the attribute */
3573 int nbytes
; /* Size of next field to read */
3577 end
= diep
+ dip
-> die_length
;
3578 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3581 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3582 diep
+= SIZEOF_ATTRIBUTE
;
3583 if ((nbytes
= attribute_size (attr
)) == -1)
3585 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3592 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3596 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3600 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3604 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3608 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3610 dip
-> has_at_stmt_list
= 1;
3613 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3615 dip
-> at_low_pc
+= baseaddr
;
3616 dip
-> has_at_low_pc
= 1;
3619 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3621 dip
-> at_high_pc
+= baseaddr
;
3624 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3627 case AT_user_def_type
:
3628 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3629 GET_UNSIGNED
, objfile
);
3632 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3634 dip
-> has_at_byte_size
= 1;
3637 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3641 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3645 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3649 dip
-> at_location
= diep
;
3651 case AT_mod_fund_type
:
3652 dip
-> at_mod_fund_type
= diep
;
3654 case AT_subscr_data
:
3655 dip
-> at_subscr_data
= diep
;
3657 case AT_mod_u_d_type
:
3658 dip
-> at_mod_u_d_type
= diep
;
3660 case AT_element_list
:
3661 dip
-> at_element_list
= diep
;
3662 dip
-> short_element_list
= 0;
3664 case AT_short_element_list
:
3665 dip
-> at_element_list
= diep
;
3666 dip
-> short_element_list
= 1;
3668 case AT_discr_value
:
3669 dip
-> at_discr_value
= diep
;
3671 case AT_string_length
:
3672 dip
-> at_string_length
= diep
;
3675 dip
-> at_name
= diep
;
3678 /* For now, ignore any "hostname:" portion, since gdb doesn't
3679 know how to deal with it. (FIXME). */
3680 dip
-> at_comp_dir
= strrchr (diep
, ':');
3681 if (dip
-> at_comp_dir
!= NULL
)
3683 dip
-> at_comp_dir
++;
3687 dip
-> at_comp_dir
= diep
;
3691 dip
-> at_producer
= diep
;
3693 case AT_start_scope
:
3694 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3697 case AT_stride_size
:
3698 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3702 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3706 dip
-> at_prototyped
= diep
;
3709 /* Found an attribute that we are unprepared to handle. However
3710 it is specifically one of the design goals of DWARF that
3711 consumers should ignore unknown attributes. As long as the
3712 form is one that we recognize (so we know how to skip it),
3713 we can just ignore the unknown attribute. */
3716 form
= FORM_FROM_ATTR (attr
);
3730 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3733 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3736 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3739 diep
+= strlen (diep
) + 1;
3742 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3753 target_to_host -- swap in target data to host
3757 target_to_host (char *from, int nbytes, int signextend,
3758 struct objfile *objfile)
3762 Given pointer to data in target format in FROM, a byte count for
3763 the size of the data in NBYTES, a flag indicating whether or not
3764 the data is signed in SIGNEXTEND, and a pointer to the current
3765 objfile in OBJFILE, convert the data to host format and return
3766 the converted value.
3770 FIXME: If we read data that is known to be signed, and expect to
3771 use it as signed data, then we need to explicitly sign extend the
3772 result until the bfd library is able to do this for us.
3776 static unsigned long
3777 target_to_host (from
, nbytes
, signextend
, objfile
)
3780 int signextend
; /* FIXME: Unused */
3781 struct objfile
*objfile
;
3783 unsigned long rtnval
;
3788 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3791 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3794 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3797 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3800 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3811 attribute_size -- compute size of data for a DWARF attribute
3815 static int attribute_size (unsigned int attr)
3819 Given a DWARF attribute in ATTR, compute the size of the first
3820 piece of data associated with this attribute and return that
3823 Returns -1 for unrecognized attributes.
3828 attribute_size (attr
)
3831 int nbytes
; /* Size of next data for this attribute */
3832 unsigned short form
; /* Form of the attribute */
3834 form
= FORM_FROM_ATTR (attr
);
3837 case FORM_STRING
: /* A variable length field is next */
3840 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3841 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3844 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3845 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3846 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3849 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3852 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3853 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3856 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);