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_LANGUAGE (sym
) = cu_language
;
1741 SYMBOL_DEMANGLED_NAME (sym
) = NULL
;
1742 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1743 SYMBOL_CLASS (sym
) = LOC_CONST
;
1744 SYMBOL_TYPE (sym
) = type
;
1745 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1746 add_symbol_to_list (sym
, list_in_scope
);
1748 /* Now create the vector of fields, and record how big it is. This is
1749 where we reverse the order, by pulling the members off the list in
1750 reverse order from how they were inserted. If we have no fields
1751 (this is apparently possible in C++) then skip building a field
1755 TYPE_NFIELDS (type
) = nfields
;
1756 TYPE_FIELDS (type
) = (struct field
*)
1757 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1758 /* Copy the saved-up fields into the field vector. */
1759 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1761 TYPE_FIELD (type
, n
++) = list
-> field
;
1772 read_func_scope -- process all dies within a function scope
1776 Process all dies within a given function scope. We are passed
1777 a die information structure pointer DIP for the die which
1778 starts the function scope, and pointers into the raw die data
1779 that define the dies within the function scope.
1781 For now, we ignore lexical block scopes within the function.
1782 The problem is that AT&T cc does not define a DWARF lexical
1783 block scope for the function itself, while gcc defines a
1784 lexical block scope for the function. We need to think about
1785 how to handle this difference, or if it is even a problem.
1790 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1791 struct dieinfo
*dip
;
1794 struct objfile
*objfile
;
1796 register struct context_stack
*new;
1798 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1799 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1801 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1802 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1804 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1806 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1807 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1809 new = push_context (0, dip
-> at_low_pc
);
1810 new -> name
= new_symbol (dip
, objfile
);
1811 list_in_scope
= &local_symbols
;
1812 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1813 new = pop_context ();
1814 /* Make a block for the local symbols within. */
1815 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1816 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1817 list_in_scope
= &file_symbols
;
1825 handle_producer -- process the AT_producer attribute
1829 Perform any operations that depend on finding a particular
1830 AT_producer attribute.
1835 handle_producer (producer
)
1839 /* If this compilation unit was compiled with g++ or gcc, then set the
1840 processing_gcc_compilation flag. */
1842 processing_gcc_compilation
=
1843 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1844 /* start-sanitize-chill */
1845 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1846 /* end-sanitize-chill */
1847 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1849 /* Select a demangling style if we can identify the producer and if
1850 the current style is auto. We leave the current style alone if it
1851 is not auto. We also leave the demangling style alone if we find a
1852 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1854 #if 1 /* Works, but is experimental. -fnf */
1855 if (AUTO_DEMANGLING
)
1857 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1859 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1861 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1863 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1865 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1867 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1878 read_file_scope -- process all dies within a file scope
1882 Process all dies within a given file scope. We are passed a
1883 pointer to the die information structure for the die which
1884 starts the file scope, and pointers into the raw die data which
1885 mark the range of dies within the file scope.
1887 When the partial symbol table is built, the file offset for the line
1888 number table for each compilation unit is saved in the partial symbol
1889 table entry for that compilation unit. As the symbols for each
1890 compilation unit are read, the line number table is read into memory
1891 and the variable lnbase is set to point to it. Thus all we have to
1892 do is use lnbase to access the line number table for the current
1897 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1898 struct dieinfo
*dip
;
1901 struct objfile
*objfile
;
1903 struct cleanup
*back_to
;
1904 struct symtab
*symtab
;
1906 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1907 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1909 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1910 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1912 set_cu_language (dip
);
1913 if (dip
-> at_producer
!= NULL
)
1915 handle_producer (dip
-> at_producer
);
1917 numutypes
= (enddie
- thisdie
) / 4;
1918 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1919 back_to
= make_cleanup (free
, utypes
);
1920 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1921 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1922 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1923 decode_line_numbers (lnbase
);
1924 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1925 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1928 symtab
-> language
= cu_language
;
1930 do_cleanups (back_to
);
1939 process_dies -- process a range of DWARF Information Entries
1943 static void process_dies (char *thisdie, char *enddie,
1944 struct objfile *objfile)
1948 Process all DIE's in a specified range. May be (and almost
1949 certainly will be) called recursively.
1953 process_dies (thisdie
, enddie
, objfile
)
1956 struct objfile
*objfile
;
1961 while (thisdie
< enddie
)
1963 basicdieinfo (&di
, thisdie
, objfile
);
1964 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1968 else if (di
.die_tag
== TAG_padding
)
1970 nextdie
= thisdie
+ di
.die_length
;
1974 completedieinfo (&di
, objfile
);
1975 if (di
.at_sibling
!= 0)
1977 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1981 nextdie
= thisdie
+ di
.die_length
;
1985 case TAG_compile_unit
:
1986 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1988 case TAG_global_subroutine
:
1989 case TAG_subroutine
:
1990 if (di
.has_at_low_pc
)
1992 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1995 case TAG_lexical_block
:
1996 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1998 case TAG_class_type
:
1999 case TAG_structure_type
:
2000 case TAG_union_type
:
2001 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
2003 case TAG_enumeration_type
:
2004 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
2006 case TAG_subroutine_type
:
2007 read_subroutine_type (&di
, thisdie
, nextdie
);
2009 case TAG_array_type
:
2010 dwarf_read_array_type (&di
);
2012 case TAG_pointer_type
:
2013 read_tag_pointer_type (&di
);
2016 new_symbol (&di
, objfile
);
2028 decode_line_numbers -- decode a line number table fragment
2032 static void decode_line_numbers (char *tblscan, char *tblend,
2033 long length, long base, long line, long pc)
2037 Translate the DWARF line number information to gdb form.
2039 The ".line" section contains one or more line number tables, one for
2040 each ".line" section from the objects that were linked.
2042 The AT_stmt_list attribute for each TAG_source_file entry in the
2043 ".debug" section contains the offset into the ".line" section for the
2044 start of the table for that file.
2046 The table itself has the following structure:
2048 <table length><base address><source statement entry>
2049 4 bytes 4 bytes 10 bytes
2051 The table length is the total size of the table, including the 4 bytes
2052 for the length information.
2054 The base address is the address of the first instruction generated
2055 for the source file.
2057 Each source statement entry has the following structure:
2059 <line number><statement position><address delta>
2060 4 bytes 2 bytes 4 bytes
2062 The line number is relative to the start of the file, starting with
2065 The statement position either -1 (0xFFFF) or the number of characters
2066 from the beginning of the line to the beginning of the statement.
2068 The address delta is the difference between the base address and
2069 the address of the first instruction for the statement.
2071 Note that we must copy the bytes from the packed table to our local
2072 variables before attempting to use them, to avoid alignment problems
2073 on some machines, particularly RISC processors.
2077 Does gdb expect the line numbers to be sorted? They are now by
2078 chance/luck, but are not required to be. (FIXME)
2080 The line with number 0 is unused, gdb apparently can discover the
2081 span of the last line some other way. How? (FIXME)
2085 decode_line_numbers (linetable
)
2090 unsigned long length
;
2095 if (linetable
!= NULL
)
2097 tblscan
= tblend
= linetable
;
2098 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2100 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2102 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2103 GET_UNSIGNED
, current_objfile
);
2104 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2106 while (tblscan
< tblend
)
2108 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2110 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2111 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2113 tblscan
+= SIZEOF_LINETBL_DELTA
;
2117 record_line (current_subfile
, line
, pc
);
2127 locval -- compute the value of a location attribute
2131 static int locval (char *loc)
2135 Given pointer to a string of bytes that define a location, compute
2136 the location and return the value.
2138 When computing values involving the current value of the frame pointer,
2139 the value zero is used, which results in a value relative to the frame
2140 pointer, rather than the absolute value. This is what GDB wants
2143 When the result is a register number, the global isreg flag is set,
2144 otherwise it is cleared. This is a kludge until we figure out a better
2145 way to handle the problem. Gdb's design does not mesh well with the
2146 DWARF notion of a location computing interpreter, which is a shame
2147 because the flexibility goes unused.
2151 Note that stack[0] is unused except as a default error return.
2152 Note that stack overflow is not yet handled.
2159 unsigned short nbytes
;
2160 unsigned short locsize
;
2161 auto long stack
[64];
2168 nbytes
= attribute_size (AT_location
);
2169 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2171 end
= loc
+ locsize
;
2176 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2179 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2181 loc
+= SIZEOF_LOC_ATOM_CODE
;
2182 switch (loc_atom_code
)
2189 /* push register (number) */
2190 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2191 GET_UNSIGNED
, current_objfile
);
2192 loc
+= loc_value_size
;
2196 /* push value of register (number) */
2197 /* Actually, we compute the value as if register has 0 */
2199 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2201 loc
+= loc_value_size
;
2204 stack
[++stacki
] = 0;
2208 stack
[++stacki
] = 0;
2210 complain (&basereg_not_handled
, DIE_ID
, DIE_NAME
, regno
);
2214 /* push address (relocated address) */
2215 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2216 GET_UNSIGNED
, current_objfile
);
2217 loc
+= loc_value_size
;
2220 /* push constant (number) FIXME: signed or unsigned! */
2221 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2222 GET_SIGNED
, current_objfile
);
2223 loc
+= loc_value_size
;
2226 /* pop, deref and push 2 bytes (as a long) */
2227 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2229 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2230 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2232 case OP_ADD
: /* pop top 2 items, add, push result */
2233 stack
[stacki
- 1] += stack
[stacki
];
2238 return (stack
[stacki
]);
2245 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2249 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2253 When expanding a partial symbol table entry to a full symbol table
2254 entry, this is the function that gets called to read in the symbols
2255 for the compilation unit.
2257 Returns a pointer to the newly constructed symtab (which is now
2258 the new first one on the objfile's symtab list).
2261 static struct symtab
*
2262 read_ofile_symtab (pst
)
2263 struct partial_symtab
*pst
;
2265 struct cleanup
*back_to
;
2266 unsigned long lnsize
;
2269 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2271 abfd
= pst
-> objfile
-> obfd
;
2272 current_objfile
= pst
-> objfile
;
2274 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2275 unit, seek to the location in the file, and read in all the DIE's. */
2278 dbsize
= DBLENGTH (pst
);
2279 dbbase
= xmalloc (dbsize
);
2280 dbroff
= DBROFF(pst
);
2281 foffset
= DBFOFF(pst
) + dbroff
;
2282 base_section_offsets
= pst
->section_offsets
;
2283 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2284 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2285 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2288 error ("can't read DWARF data");
2290 back_to
= make_cleanup (free
, dbbase
);
2292 /* If there is a line number table associated with this compilation unit
2293 then read the size of this fragment in bytes, from the fragment itself.
2294 Allocate a buffer for the fragment and read it in for future
2300 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2301 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2302 sizeof (lnsizedata
)))
2304 error ("can't read DWARF line number table size");
2306 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2307 GET_UNSIGNED
, pst
-> objfile
);
2308 lnbase
= xmalloc (lnsize
);
2309 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2310 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2313 error ("can't read DWARF line numbers");
2315 make_cleanup (free
, lnbase
);
2318 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2319 do_cleanups (back_to
);
2320 current_objfile
= NULL
;
2321 return (pst
-> objfile
-> symtabs
);
2328 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2332 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2336 Called once for each partial symbol table entry that needs to be
2337 expanded into a full symbol table entry.
2342 psymtab_to_symtab_1 (pst
)
2343 struct partial_symtab
*pst
;
2346 struct cleanup
*old_chain
;
2352 warning ("psymtab for %s already read in. Shouldn't happen.",
2357 /* Read in all partial symtabs on which this one is dependent */
2358 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2360 if (!pst
-> dependencies
[i
] -> readin
)
2362 /* Inform about additional files that need to be read in. */
2365 fputs_filtered (" ", stdout
);
2367 fputs_filtered ("and ", stdout
);
2369 printf_filtered ("%s...",
2370 pst
-> dependencies
[i
] -> filename
);
2372 fflush (stdout
); /* Flush output */
2374 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2377 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2380 old_chain
= make_cleanup (really_free_pendings
, 0);
2381 pst
-> symtab
= read_ofile_symtab (pst
);
2384 printf_filtered ("%d DIE's, sorting...", diecount
);
2388 sort_symtab_syms (pst
-> symtab
);
2389 do_cleanups (old_chain
);
2400 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2404 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2408 This is the DWARF support entry point for building a full symbol
2409 table entry from a partial symbol table entry. We are passed a
2410 pointer to the partial symbol table entry that needs to be expanded.
2415 dwarf_psymtab_to_symtab (pst
)
2416 struct partial_symtab
*pst
;
2423 warning ("psymtab for %s already read in. Shouldn't happen.",
2428 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2430 /* Print the message now, before starting serious work, to avoid
2431 disconcerting pauses. */
2434 printf_filtered ("Reading in symbols for %s...",
2439 psymtab_to_symtab_1 (pst
);
2441 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2442 we need to do an equivalent or is this something peculiar to
2444 Match with global symbols. This only needs to be done once,
2445 after all of the symtabs and dependencies have been read in.
2447 scan_file_globals (pst
-> objfile
);
2450 /* Finish up the verbose info message. */
2453 printf_filtered ("done.\n");
2465 init_psymbol_list -- initialize storage for partial symbols
2469 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2473 Initializes storage for all of the partial symbols that will be
2474 created by dwarf_build_psymtabs and subsidiaries.
2478 init_psymbol_list (objfile
, total_symbols
)
2479 struct objfile
*objfile
;
2482 /* Free any previously allocated psymbol lists. */
2484 if (objfile
-> global_psymbols
.list
)
2486 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2488 if (objfile
-> static_psymbols
.list
)
2490 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2493 /* Current best guess is that there are approximately a twentieth
2494 of the total symbols (in a debugging file) are global or static
2497 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2498 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2499 objfile
-> global_psymbols
.next
=
2500 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2501 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2502 * sizeof (struct partial_symbol
));
2503 objfile
-> static_psymbols
.next
=
2504 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2505 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2506 * sizeof (struct partial_symbol
));
2513 add_enum_psymbol -- add enumeration members to partial symbol table
2517 Given pointer to a DIE that is known to be for an enumeration,
2518 extract the symbolic names of the enumeration members and add
2519 partial symbols for them.
2523 add_enum_psymbol (dip
, objfile
)
2524 struct dieinfo
*dip
;
2525 struct objfile
*objfile
;
2529 unsigned short blocksz
;
2532 if ((scan
= dip
-> at_element_list
) != NULL
)
2534 if (dip
-> short_element_list
)
2536 nbytes
= attribute_size (AT_short_element_list
);
2540 nbytes
= attribute_size (AT_element_list
);
2542 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2544 listend
= scan
+ blocksz
;
2545 while (scan
< listend
)
2547 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2548 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2549 objfile
-> static_psymbols
, 0, cu_language
,
2551 scan
+= strlen (scan
) + 1;
2560 add_partial_symbol -- add symbol to partial symbol table
2564 Given a DIE, if it is one of the types that we want to
2565 add to a partial symbol table, finish filling in the die info
2566 and then add a partial symbol table entry for it.
2570 The caller must ensure that the DIE has a valid name attribute.
2574 add_partial_symbol (dip
, objfile
)
2575 struct dieinfo
*dip
;
2576 struct objfile
*objfile
;
2578 switch (dip
-> die_tag
)
2580 case TAG_global_subroutine
:
2581 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2583 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2584 VAR_NAMESPACE
, LOC_BLOCK
,
2585 objfile
-> global_psymbols
,
2586 dip
-> at_low_pc
, cu_language
, objfile
);
2588 case TAG_global_variable
:
2589 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2591 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2592 VAR_NAMESPACE
, LOC_STATIC
,
2593 objfile
-> global_psymbols
,
2594 0, cu_language
, objfile
);
2596 case TAG_subroutine
:
2597 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2598 VAR_NAMESPACE
, LOC_BLOCK
,
2599 objfile
-> static_psymbols
,
2600 dip
-> at_low_pc
, cu_language
, objfile
);
2602 case TAG_local_variable
:
2603 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2604 VAR_NAMESPACE
, LOC_STATIC
,
2605 objfile
-> static_psymbols
,
2606 0, cu_language
, objfile
);
2609 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2610 VAR_NAMESPACE
, LOC_TYPEDEF
,
2611 objfile
-> static_psymbols
,
2612 0, cu_language
, objfile
);
2614 case TAG_class_type
:
2615 case TAG_structure_type
:
2616 case TAG_union_type
:
2617 case TAG_enumeration_type
:
2618 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2619 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2620 objfile
-> static_psymbols
,
2621 0, cu_language
, objfile
);
2622 if (cu_language
== language_cplus
)
2624 /* For C++, these implicitly act as typedefs as well. */
2625 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2626 VAR_NAMESPACE
, LOC_TYPEDEF
,
2627 objfile
-> static_psymbols
,
2628 0, cu_language
, objfile
);
2638 scan_partial_symbols -- scan DIE's within a single compilation unit
2642 Process the DIE's within a single compilation unit, looking for
2643 interesting DIE's that contribute to the partial symbol table entry
2644 for this compilation unit.
2648 There are some DIE's that may appear both at file scope and within
2649 the scope of a function. We are only interested in the ones at file
2650 scope, and the only way to tell them apart is to keep track of the
2651 scope. For example, consider the test case:
2656 for which the relevant DWARF segment has the structure:
2659 0x23 global subrtn sibling 0x9b
2661 fund_type FT_integer
2666 0x23 local var sibling 0x97
2668 fund_type FT_integer
2669 location OP_BASEREG 0xe
2676 0x1d local var sibling 0xb8
2678 fund_type FT_integer
2679 location OP_ADDR 0x800025dc
2684 We want to include the symbol 'i' in the partial symbol table, but
2685 not the symbol 'j'. In essence, we want to skip all the dies within
2686 the scope of a TAG_global_subroutine DIE.
2688 Don't attempt to add anonymous structures or unions since they have
2689 no name. Anonymous enumerations however are processed, because we
2690 want to extract their member names (the check for a tag name is
2693 Also, for variables and subroutines, check that this is the place
2694 where the actual definition occurs, rather than just a reference
2699 scan_partial_symbols (thisdie
, enddie
, objfile
)
2702 struct objfile
*objfile
;
2708 while (thisdie
< enddie
)
2710 basicdieinfo (&di
, thisdie
, objfile
);
2711 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2717 nextdie
= thisdie
+ di
.die_length
;
2718 /* To avoid getting complete die information for every die, we
2719 only do it (below) for the cases we are interested in. */
2722 case TAG_global_subroutine
:
2723 case TAG_subroutine
:
2724 completedieinfo (&di
, objfile
);
2725 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2727 add_partial_symbol (&di
, objfile
);
2728 /* If there is a sibling attribute, adjust the nextdie
2729 pointer to skip the entire scope of the subroutine.
2730 Apply some sanity checking to make sure we don't
2731 overrun or underrun the range of remaining DIE's */
2732 if (di
.at_sibling
!= 0)
2734 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2735 if ((temp
< thisdie
) || (temp
>= enddie
))
2737 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2747 case TAG_global_variable
:
2748 case TAG_local_variable
:
2749 completedieinfo (&di
, objfile
);
2750 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2752 add_partial_symbol (&di
, objfile
);
2756 case TAG_class_type
:
2757 case TAG_structure_type
:
2758 case TAG_union_type
:
2759 completedieinfo (&di
, objfile
);
2762 add_partial_symbol (&di
, objfile
);
2765 case TAG_enumeration_type
:
2766 completedieinfo (&di
, objfile
);
2769 add_partial_symbol (&di
, objfile
);
2771 add_enum_psymbol (&di
, objfile
);
2783 scan_compilation_units -- build a psymtab entry for each compilation
2787 This is the top level dwarf parsing routine for building partial
2790 It scans from the beginning of the DWARF table looking for the first
2791 TAG_compile_unit DIE, and then follows the sibling chain to locate
2792 each additional TAG_compile_unit DIE.
2794 For each TAG_compile_unit DIE it creates a partial symtab structure,
2795 calls a subordinate routine to collect all the compilation unit's
2796 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2797 new partial symtab structure into the partial symbol table. It also
2798 records the appropriate information in the partial symbol table entry
2799 to allow the chunk of DIE's and line number table for this compilation
2800 unit to be located and re-read later, to generate a complete symbol
2801 table entry for the compilation unit.
2803 Thus it effectively partitions up a chunk of DIE's for multiple
2804 compilation units into smaller DIE chunks and line number tables,
2805 and associates them with a partial symbol table entry.
2809 If any compilation unit has no line number table associated with
2810 it for some reason (a missing at_stmt_list attribute, rather than
2811 just one with a value of zero, which is valid) then we ensure that
2812 the recorded file offset is zero so that the routine which later
2813 reads line number table fragments knows that there is no fragment
2823 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2828 struct objfile
*objfile
;
2832 struct partial_symtab
*pst
;
2835 file_ptr curlnoffset
;
2837 while (thisdie
< enddie
)
2839 basicdieinfo (&di
, thisdie
, objfile
);
2840 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2844 else if (di
.die_tag
!= TAG_compile_unit
)
2846 nextdie
= thisdie
+ di
.die_length
;
2850 completedieinfo (&di
, objfile
);
2851 set_cu_language (&di
);
2852 if (di
.at_sibling
!= 0)
2854 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2858 nextdie
= thisdie
+ di
.die_length
;
2860 curoff
= thisdie
- dbbase
;
2861 culength
= nextdie
- thisdie
;
2862 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2864 /* First allocate a new partial symbol table structure */
2866 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2867 di
.at_name
, di
.at_low_pc
,
2868 objfile
-> global_psymbols
.next
,
2869 objfile
-> static_psymbols
.next
);
2871 pst
-> texthigh
= di
.at_high_pc
;
2872 pst
-> read_symtab_private
= (char *)
2873 obstack_alloc (&objfile
-> psymbol_obstack
,
2874 sizeof (struct dwfinfo
));
2875 DBFOFF (pst
) = dbfoff
;
2876 DBROFF (pst
) = curoff
;
2877 DBLENGTH (pst
) = culength
;
2878 LNFOFF (pst
) = curlnoffset
;
2879 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2881 /* Now look for partial symbols */
2883 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2885 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2886 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2887 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2888 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2889 sort_pst_symbols (pst
);
2890 /* If there is already a psymtab or symtab for a file of this name,
2891 remove it. (If there is a symtab, more drastic things also
2892 happen.) This happens in VxWorks. */
2893 free_named_symtabs (pst
-> filename
);
2903 new_symbol -- make a symbol table entry for a new symbol
2907 static struct symbol *new_symbol (struct dieinfo *dip,
2908 struct objfile *objfile)
2912 Given a pointer to a DWARF information entry, figure out if we need
2913 to make a symbol table entry for it, and if so, create a new entry
2914 and return a pointer to it.
2917 static struct symbol
*
2918 new_symbol (dip
, objfile
)
2919 struct dieinfo
*dip
;
2920 struct objfile
*objfile
;
2922 struct symbol
*sym
= NULL
;
2924 if (dip
-> at_name
!= NULL
)
2926 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2927 sizeof (struct symbol
));
2928 memset (sym
, 0, sizeof (struct symbol
));
2929 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2930 &objfile
->symbol_obstack
);
2931 /* default assumptions */
2932 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2933 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2934 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2936 /* If this symbol is from a C++ compilation, then attempt to cache the
2937 demangled form for future reference. This is a typical time versus
2938 space tradeoff, that was decided in favor of time because it sped up
2939 C++ symbol lookups by a factor of about 20. */
2941 SYMBOL_LANGUAGE (sym
) = cu_language
;
2942 if (SYMBOL_LANGUAGE (sym
) == language_cplus
)
2945 cplus_demangle (SYMBOL_NAME (sym
), DMGL_PARAMS
| DMGL_ANSI
);
2946 if (demangled
!= NULL
)
2948 SYMBOL_DEMANGLED_NAME (sym
) =
2949 obsavestring (demangled
, strlen (demangled
),
2950 &objfile
-> symbol_obstack
);
2955 switch (dip
-> die_tag
)
2958 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2959 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2961 case TAG_global_subroutine
:
2962 case TAG_subroutine
:
2963 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2964 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2965 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2966 if (dip
-> die_tag
== TAG_global_subroutine
)
2968 add_symbol_to_list (sym
, &global_symbols
);
2972 add_symbol_to_list (sym
, list_in_scope
);
2975 case TAG_global_variable
:
2976 if (dip
-> at_location
!= NULL
)
2978 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2979 add_symbol_to_list (sym
, &global_symbols
);
2980 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2981 SYMBOL_VALUE (sym
) += baseaddr
;
2984 case TAG_local_variable
:
2985 if (dip
-> at_location
!= NULL
)
2987 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2988 add_symbol_to_list (sym
, list_in_scope
);
2991 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2995 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2999 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3000 SYMBOL_VALUE (sym
) += baseaddr
;
3004 case TAG_formal_parameter
:
3005 if (dip
-> at_location
!= NULL
)
3007 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3009 add_symbol_to_list (sym
, list_in_scope
);
3012 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3016 SYMBOL_CLASS (sym
) = LOC_ARG
;
3019 case TAG_unspecified_parameters
:
3020 /* From varargs functions; gdb doesn't seem to have any interest in
3021 this information, so just ignore it for now. (FIXME?) */
3023 case TAG_class_type
:
3024 case TAG_structure_type
:
3025 case TAG_union_type
:
3026 case TAG_enumeration_type
:
3027 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3028 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3029 add_symbol_to_list (sym
, list_in_scope
);
3032 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3033 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3034 add_symbol_to_list (sym
, list_in_scope
);
3037 /* Not a tag we recognize. Hopefully we aren't processing trash
3038 data, but since we must specifically ignore things we don't
3039 recognize, there is nothing else we should do at this point. */
3050 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3054 static void synthesize_typedef (struct dieinfo *dip,
3055 struct objfile *objfile,
3060 Given a pointer to a DWARF information entry, synthesize a typedef
3061 for the name in the DIE, using the specified type.
3063 This is used for C++ class, structs, unions, and enumerations to
3064 set up the tag name as a type.
3069 synthesize_typedef (dip
, objfile
, type
)
3070 struct dieinfo
*dip
;
3071 struct objfile
*objfile
;
3074 struct symbol
*sym
= NULL
;
3076 if (dip
-> at_name
!= NULL
)
3078 sym
= (struct symbol
*)
3079 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3080 memset (sym
, 0, sizeof (struct symbol
));
3081 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3082 &objfile
->symbol_obstack
);
3083 SYMBOL_LANGUAGE (sym
) = cu_language
;
3084 SYMBOL_DEMANGLED_NAME (sym
) = NULL
;
3085 SYMBOL_TYPE (sym
) = type
;
3086 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3087 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3088 add_symbol_to_list (sym
, list_in_scope
);
3096 decode_mod_fund_type -- decode a modified fundamental type
3100 static struct type *decode_mod_fund_type (char *typedata)
3104 Decode a block of data containing a modified fundamental
3105 type specification. TYPEDATA is a pointer to the block,
3106 which starts with a length containing the size of the rest
3107 of the block. At the end of the block is a fundmental type
3108 code value that gives the fundamental type. Everything
3109 in between are type modifiers.
3111 We simply compute the number of modifiers and call the general
3112 function decode_modified_type to do the actual work.
3115 static struct type
*
3116 decode_mod_fund_type (typedata
)
3119 struct type
*typep
= NULL
;
3120 unsigned short modcount
;
3123 /* Get the total size of the block, exclusive of the size itself */
3125 nbytes
= attribute_size (AT_mod_fund_type
);
3126 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3129 /* Deduct the size of the fundamental type bytes at the end of the block. */
3131 modcount
-= attribute_size (AT_fund_type
);
3133 /* Now do the actual decoding */
3135 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3143 decode_mod_u_d_type -- decode a modified user defined type
3147 static struct type *decode_mod_u_d_type (char *typedata)
3151 Decode a block of data containing a modified user defined
3152 type specification. TYPEDATA is a pointer to the block,
3153 which consists of a two byte length, containing the size
3154 of the rest of the block. At the end of the block is a
3155 four byte value that gives a reference to a user defined type.
3156 Everything in between are type modifiers.
3158 We simply compute the number of modifiers and call the general
3159 function decode_modified_type to do the actual work.
3162 static struct type
*
3163 decode_mod_u_d_type (typedata
)
3166 struct type
*typep
= NULL
;
3167 unsigned short modcount
;
3170 /* Get the total size of the block, exclusive of the size itself */
3172 nbytes
= attribute_size (AT_mod_u_d_type
);
3173 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3176 /* Deduct the size of the reference type bytes at the end of the block. */
3178 modcount
-= attribute_size (AT_user_def_type
);
3180 /* Now do the actual decoding */
3182 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3190 decode_modified_type -- decode modified user or fundamental type
3194 static struct type *decode_modified_type (char *modifiers,
3195 unsigned short modcount, int mtype)
3199 Decode a modified type, either a modified fundamental type or
3200 a modified user defined type. MODIFIERS is a pointer to the
3201 block of bytes that define MODCOUNT modifiers. Immediately
3202 following the last modifier is a short containing the fundamental
3203 type or a long containing the reference to the user defined
3204 type. Which one is determined by MTYPE, which is either
3205 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3206 type we are generating.
3208 We call ourself recursively to generate each modified type,`
3209 until MODCOUNT reaches zero, at which point we have consumed
3210 all the modifiers and generate either the fundamental type or
3211 user defined type. When the recursion unwinds, each modifier
3212 is applied in turn to generate the full modified type.
3216 If we find a modifier that we don't recognize, and it is not one
3217 of those reserved for application specific use, then we issue a
3218 warning and simply ignore the modifier.
3222 We currently ignore MOD_const and MOD_volatile. (FIXME)
3226 static struct type
*
3227 decode_modified_type (modifiers
, modcount
, mtype
)
3229 unsigned int modcount
;
3232 struct type
*typep
= NULL
;
3233 unsigned short fundtype
;
3242 case AT_mod_fund_type
:
3243 nbytes
= attribute_size (AT_fund_type
);
3244 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3246 typep
= decode_fund_type (fundtype
);
3248 case AT_mod_u_d_type
:
3249 nbytes
= attribute_size (AT_user_def_type
);
3250 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3252 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3254 typep
= alloc_utype (die_ref
, NULL
);
3258 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3259 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3265 modifier
= *modifiers
++;
3266 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3269 case MOD_pointer_to
:
3270 typep
= lookup_pointer_type (typep
);
3272 case MOD_reference_to
:
3273 typep
= lookup_reference_type (typep
);
3276 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3279 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3282 if (!(MOD_lo_user
<= (unsigned char) modifier
3283 && (unsigned char) modifier
<= MOD_hi_user
))
3285 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3297 decode_fund_type -- translate basic DWARF type to gdb base type
3301 Given an integer that is one of the fundamental DWARF types,
3302 translate it to one of the basic internal gdb types and return
3303 a pointer to the appropriate gdb type (a "struct type *").
3307 For robustness, if we are asked to translate a fundamental
3308 type that we are unprepared to deal with, we return int so
3309 callers can always depend upon a valid type being returned,
3310 and so gdb may at least do something reasonable by default.
3311 If the type is not in the range of those types defined as
3312 application specific types, we also issue a warning.
3315 static struct type
*
3316 decode_fund_type (fundtype
)
3317 unsigned int fundtype
;
3319 struct type
*typep
= NULL
;
3325 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3328 case FT_boolean
: /* Was FT_set in AT&T version */
3329 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3332 case FT_pointer
: /* (void *) */
3333 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3334 typep
= lookup_pointer_type (typep
);
3338 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3341 case FT_signed_char
:
3342 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3345 case FT_unsigned_char
:
3346 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3350 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3353 case FT_signed_short
:
3354 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3357 case FT_unsigned_short
:
3358 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3362 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3365 case FT_signed_integer
:
3366 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3369 case FT_unsigned_integer
:
3370 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3374 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3377 case FT_signed_long
:
3378 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3381 case FT_unsigned_long
:
3382 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3386 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3389 case FT_signed_long_long
:
3390 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3393 case FT_unsigned_long_long
:
3394 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3398 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3401 case FT_dbl_prec_float
:
3402 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3405 case FT_ext_prec_float
:
3406 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3410 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3413 case FT_dbl_prec_complex
:
3414 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3417 case FT_ext_prec_complex
:
3418 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3425 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3426 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3428 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3439 create_name -- allocate a fresh copy of a string on an obstack
3443 Given a pointer to a string and a pointer to an obstack, allocates
3444 a fresh copy of the string on the specified obstack.
3449 create_name (name
, obstackp
)
3451 struct obstack
*obstackp
;
3456 length
= strlen (name
) + 1;
3457 newname
= (char *) obstack_alloc (obstackp
, length
);
3458 strcpy (newname
, name
);
3466 basicdieinfo -- extract the minimal die info from raw die data
3470 void basicdieinfo (char *diep, struct dieinfo *dip,
3471 struct objfile *objfile)
3475 Given a pointer to raw DIE data, and a pointer to an instance of a
3476 die info structure, this function extracts the basic information
3477 from the DIE data required to continue processing this DIE, along
3478 with some bookkeeping information about the DIE.
3480 The information we absolutely must have includes the DIE tag,
3481 and the DIE length. If we need the sibling reference, then we
3482 will have to call completedieinfo() to process all the remaining
3485 Note that since there is no guarantee that the data is properly
3486 aligned in memory for the type of access required (indirection
3487 through anything other than a char pointer), and there is no
3488 guarantee that it is in the same byte order as the gdb host,
3489 we call a function which deals with both alignment and byte
3490 swapping issues. Possibly inefficient, but quite portable.
3492 We also take care of some other basic things at this point, such
3493 as ensuring that the instance of the die info structure starts
3494 out completely zero'd and that curdie is initialized for use
3495 in error reporting if we have a problem with the current die.
3499 All DIE's must have at least a valid length, thus the minimum
3500 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3501 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3502 are forced to be TAG_padding DIES.
3504 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3505 that if a padding DIE is used for alignment and the amount needed is
3506 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3507 enough to align to the next alignment boundry.
3509 We do some basic sanity checking here, such as verifying that the
3510 length of the die would not cause it to overrun the recorded end of
3511 the buffer holding the DIE info. If we find a DIE that is either
3512 too small or too large, we force it's length to zero which should
3513 cause the caller to take appropriate action.
3517 basicdieinfo (dip
, diep
, objfile
)
3518 struct dieinfo
*dip
;
3520 struct objfile
*objfile
;
3523 memset (dip
, 0, sizeof (struct dieinfo
));
3525 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3526 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3528 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3529 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3531 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3532 dip
-> die_length
= 0;
3534 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3536 dip
-> die_tag
= TAG_padding
;
3540 diep
+= SIZEOF_DIE_LENGTH
;
3541 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3550 completedieinfo -- finish reading the information for a given DIE
3554 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3558 Given a pointer to an already partially initialized die info structure,
3559 scan the raw DIE data and finish filling in the die info structure
3560 from the various attributes found.
3562 Note that since there is no guarantee that the data is properly
3563 aligned in memory for the type of access required (indirection
3564 through anything other than a char pointer), and there is no
3565 guarantee that it is in the same byte order as the gdb host,
3566 we call a function which deals with both alignment and byte
3567 swapping issues. Possibly inefficient, but quite portable.
3571 Each time we are called, we increment the diecount variable, which
3572 keeps an approximate count of the number of dies processed for
3573 each compilation unit. This information is presented to the user
3574 if the info_verbose flag is set.
3579 completedieinfo (dip
, objfile
)
3580 struct dieinfo
*dip
;
3581 struct objfile
*objfile
;
3583 char *diep
; /* Current pointer into raw DIE data */
3584 char *end
; /* Terminate DIE scan here */
3585 unsigned short attr
; /* Current attribute being scanned */
3586 unsigned short form
; /* Form of the attribute */
3587 int nbytes
; /* Size of next field to read */
3591 end
= diep
+ dip
-> die_length
;
3592 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3595 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3596 diep
+= SIZEOF_ATTRIBUTE
;
3597 if ((nbytes
= attribute_size (attr
)) == -1)
3599 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3606 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3610 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3614 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3618 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3622 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3624 dip
-> has_at_stmt_list
= 1;
3627 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3629 dip
-> at_low_pc
+= baseaddr
;
3630 dip
-> has_at_low_pc
= 1;
3633 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3635 dip
-> at_high_pc
+= baseaddr
;
3638 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3641 case AT_user_def_type
:
3642 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3643 GET_UNSIGNED
, objfile
);
3646 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3648 dip
-> has_at_byte_size
= 1;
3651 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3655 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3659 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3663 dip
-> at_location
= diep
;
3665 case AT_mod_fund_type
:
3666 dip
-> at_mod_fund_type
= diep
;
3668 case AT_subscr_data
:
3669 dip
-> at_subscr_data
= diep
;
3671 case AT_mod_u_d_type
:
3672 dip
-> at_mod_u_d_type
= diep
;
3674 case AT_element_list
:
3675 dip
-> at_element_list
= diep
;
3676 dip
-> short_element_list
= 0;
3678 case AT_short_element_list
:
3679 dip
-> at_element_list
= diep
;
3680 dip
-> short_element_list
= 1;
3682 case AT_discr_value
:
3683 dip
-> at_discr_value
= diep
;
3685 case AT_string_length
:
3686 dip
-> at_string_length
= diep
;
3689 dip
-> at_name
= diep
;
3692 /* For now, ignore any "hostname:" portion, since gdb doesn't
3693 know how to deal with it. (FIXME). */
3694 dip
-> at_comp_dir
= strrchr (diep
, ':');
3695 if (dip
-> at_comp_dir
!= NULL
)
3697 dip
-> at_comp_dir
++;
3701 dip
-> at_comp_dir
= diep
;
3705 dip
-> at_producer
= diep
;
3707 case AT_start_scope
:
3708 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3711 case AT_stride_size
:
3712 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3716 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3720 dip
-> at_prototyped
= diep
;
3723 /* Found an attribute that we are unprepared to handle. However
3724 it is specifically one of the design goals of DWARF that
3725 consumers should ignore unknown attributes. As long as the
3726 form is one that we recognize (so we know how to skip it),
3727 we can just ignore the unknown attribute. */
3730 form
= FORM_FROM_ATTR (attr
);
3744 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3747 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3750 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3753 diep
+= strlen (diep
) + 1;
3756 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3767 target_to_host -- swap in target data to host
3771 target_to_host (char *from, int nbytes, int signextend,
3772 struct objfile *objfile)
3776 Given pointer to data in target format in FROM, a byte count for
3777 the size of the data in NBYTES, a flag indicating whether or not
3778 the data is signed in SIGNEXTEND, and a pointer to the current
3779 objfile in OBJFILE, convert the data to host format and return
3780 the converted value.
3784 FIXME: If we read data that is known to be signed, and expect to
3785 use it as signed data, then we need to explicitly sign extend the
3786 result until the bfd library is able to do this for us.
3790 static unsigned long
3791 target_to_host (from
, nbytes
, signextend
, objfile
)
3794 int signextend
; /* FIXME: Unused */
3795 struct objfile
*objfile
;
3797 unsigned long rtnval
;
3802 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3805 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3808 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3811 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3814 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3825 attribute_size -- compute size of data for a DWARF attribute
3829 static int attribute_size (unsigned int attr)
3833 Given a DWARF attribute in ATTR, compute the size of the first
3834 piece of data associated with this attribute and return that
3837 Returns -1 for unrecognized attributes.
3842 attribute_size (attr
)
3845 int nbytes
; /* Size of next data for this attribute */
3846 unsigned short form
; /* Form of the attribute */
3848 form
= FORM_FROM_ATTR (attr
);
3851 case FORM_STRING
: /* A variable length field is next */
3854 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3855 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3858 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3859 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3860 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3863 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3866 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3867 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3870 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);