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 #define STREQ(a,b) (strcmp(a,b)==0)
211 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
213 /* Flags to target_to_host() that tell whether or not the data object is
214 expected to be signed. Used, for example, when fetching a signed
215 integer in the target environment which is used as a signed integer
216 in the host environment, and the two environments have different sized
217 ints. In this case, *somebody* has to sign extend the smaller sized
220 #define GET_UNSIGNED 0 /* No sign extension required */
221 #define GET_SIGNED 1 /* Sign extension required */
223 /* Defines for things which are specified in the document "DWARF Debugging
224 Information Format" published by UNIX International, Programming Languages
225 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
227 #define SIZEOF_DIE_LENGTH 4
228 #define SIZEOF_DIE_TAG 2
229 #define SIZEOF_ATTRIBUTE 2
230 #define SIZEOF_FORMAT_SPECIFIER 1
231 #define SIZEOF_FMT_FT 2
232 #define SIZEOF_LINETBL_LENGTH 4
233 #define SIZEOF_LINETBL_LINENO 4
234 #define SIZEOF_LINETBL_STMT 2
235 #define SIZEOF_LINETBL_DELTA 4
236 #define SIZEOF_LOC_ATOM_CODE 1
238 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
240 /* Macros that return the sizes of various types of data in the target
243 FIXME: Currently these are just compile time constants (as they are in
244 other parts of gdb as well). They need to be able to get the right size
245 either from the bfd or possibly from the DWARF info. It would be nice if
246 the DWARF producer inserted DIES that describe the fundamental types in
247 the target environment into the DWARF info, similar to the way dbx stabs
248 producers produce information about their fundamental types. */
250 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
251 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
253 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
254 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
255 However, the Issue 2 DWARF specification from AT&T defines it as
256 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
257 For backwards compatibility with the AT&T compiler produced executables
258 we define AT_short_element_list for this variant. */
260 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
262 /* External variables referenced. */
264 extern int info_verbose
; /* From main.c; nonzero => verbose */
265 extern char *warning_pre_print
; /* From utils.c */
267 /* The DWARF debugging information consists of two major pieces,
268 one is a block of DWARF Information Entries (DIE's) and the other
269 is a line number table. The "struct dieinfo" structure contains
270 the information for a single DIE, the one currently being processed.
272 In order to make it easier to randomly access the attribute fields
273 of the current DIE, which are specifically unordered within the DIE,
274 each DIE is scanned and an instance of the "struct dieinfo"
275 structure is initialized.
277 Initialization is done in two levels. The first, done by basicdieinfo(),
278 just initializes those fields that are vital to deciding whether or not
279 to use this DIE, how to skip past it, etc. The second, done by the
280 function completedieinfo(), fills in the rest of the information.
282 Attributes which have block forms are not interpreted at the time
283 the DIE is scanned, instead we just save pointers to the start
284 of their value fields.
286 Some fields have a flag <name>_p that is set when the value of the
287 field is valid (I.E. we found a matching attribute in the DIE). Since
288 we may want to test for the presence of some attributes in the DIE,
289 such as AT_low_pc, without restricting the values of the field,
290 we need someway to note that we found such an attribute.
297 char * die
; /* Pointer to the raw DIE data */
298 unsigned long die_length
; /* Length of the raw DIE data */
299 DIE_REF die_ref
; /* Offset of this DIE */
300 unsigned short die_tag
; /* Tag for this DIE */
301 unsigned long at_padding
;
302 unsigned long at_sibling
;
305 unsigned short at_fund_type
;
306 BLOCK
* at_mod_fund_type
;
307 unsigned long at_user_def_type
;
308 BLOCK
* at_mod_u_d_type
;
309 unsigned short at_ordering
;
310 BLOCK
* at_subscr_data
;
311 unsigned long at_byte_size
;
312 unsigned short at_bit_offset
;
313 unsigned long at_bit_size
;
314 BLOCK
* at_element_list
;
315 unsigned long at_stmt_list
;
316 unsigned long at_low_pc
;
317 unsigned long at_high_pc
;
318 unsigned long at_language
;
319 unsigned long at_member
;
320 unsigned long at_discr
;
321 BLOCK
* at_discr_value
;
322 BLOCK
* at_string_length
;
325 unsigned long at_start_scope
;
326 unsigned long at_stride_size
;
327 unsigned long at_src_info
;
328 char * at_prototyped
;
329 unsigned int has_at_low_pc
:1;
330 unsigned int has_at_stmt_list
:1;
331 unsigned int has_at_byte_size
:1;
332 unsigned int short_element_list
:1;
335 static int diecount
; /* Approximate count of dies for compilation unit */
336 static struct dieinfo
*curdie
; /* For warnings and such */
338 static char *dbbase
; /* Base pointer to dwarf info */
339 static int dbsize
; /* Size of dwarf info in bytes */
340 static int dbroff
; /* Relative offset from start of .debug section */
341 static char *lnbase
; /* Base pointer to line section */
342 static int isreg
; /* Kludge to identify register variables */
343 static int offreg
; /* Kludge to identify basereg references */
345 /* This value is added to each symbol value. FIXME: Generalize to
346 the section_offsets structure used by dbxread. */
347 static CORE_ADDR baseaddr
; /* Add to each symbol value */
349 /* The section offsets used in the current psymtab or symtab. FIXME,
350 only used to pass one value (baseaddr) at the moment. */
351 static struct section_offsets
*base_section_offsets
;
353 /* Each partial symbol table entry contains a pointer to private data for the
354 read_symtab() function to use when expanding a partial symbol table entry
355 to a full symbol table entry. For DWARF debugging info, this data is
356 contained in the following structure and macros are provided for easy
357 access to the members given a pointer to a partial symbol table entry.
359 dbfoff Always the absolute file offset to the start of the ".debug"
360 section for the file containing the DIE's being accessed.
362 dbroff Relative offset from the start of the ".debug" access to the
363 first DIE to be accessed. When building the partial symbol
364 table, this value will be zero since we are accessing the
365 entire ".debug" section. When expanding a partial symbol
366 table entry, this value will be the offset to the first
367 DIE for the compilation unit containing the symbol that
368 triggers the expansion.
370 dblength The size of the chunk of DIE's being examined, in bytes.
372 lnfoff The absolute file offset to the line table fragment. Ignored
373 when building partial symbol tables, but used when expanding
374 them, and contains the absolute file offset to the fragment
375 of the ".line" section containing the line numbers for the
376 current compilation unit.
380 file_ptr dbfoff
; /* Absolute file offset to start of .debug section */
381 int dbroff
; /* Relative offset from start of .debug section */
382 int dblength
; /* Size of the chunk of DIE's being examined */
383 file_ptr lnfoff
; /* Absolute file offset to line table fragment */
386 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
387 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
388 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
389 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
391 /* The generic symbol table building routines have separate lists for
392 file scope symbols and all all other scopes (local scopes). So
393 we need to select the right one to pass to add_symbol_to_list().
394 We do it by keeping a pointer to the correct list in list_in_scope.
396 FIXME: The original dwarf code just treated the file scope as the first
397 local scope, and all other local scopes as nested local scopes, and worked
398 fine. Check to see if we really need to distinguish these in buildsym.c */
400 struct pending
**list_in_scope
= &file_symbols
;
402 /* DIES which have user defined types or modified user defined types refer to
403 other DIES for the type information. Thus we need to associate the offset
404 of a DIE for a user defined type with a pointer to the type information.
406 Originally this was done using a simple but expensive algorithm, with an
407 array of unsorted structures, each containing an offset/type-pointer pair.
408 This array was scanned linearly each time a lookup was done. The result
409 was that gdb was spending over half it's startup time munging through this
410 array of pointers looking for a structure that had the right offset member.
412 The second attempt used the same array of structures, but the array was
413 sorted using qsort each time a new offset/type was recorded, and a binary
414 search was used to find the type pointer for a given DIE offset. This was
415 even slower, due to the overhead of sorting the array each time a new
416 offset/type pair was entered.
418 The third attempt uses a fixed size array of type pointers, indexed by a
419 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
420 we can divide any DIE offset by 4 to obtain a unique index into this fixed
421 size array. Since each element is a 4 byte pointer, it takes exactly as
422 much memory to hold this array as to hold the DWARF info for a given
423 compilation unit. But it gets freed as soon as we are done with it.
424 This has worked well in practice, as a reasonable tradeoff between memory
425 consumption and speed, without having to resort to much more complicated
428 static struct type
**utypes
; /* Pointer to array of user type pointers */
429 static int numutypes
; /* Max number of user type pointers */
431 /* Maintain an array of referenced fundamental types for the current
432 compilation unit being read. For DWARF version 1, we have to construct
433 the fundamental types on the fly, since no information about the
434 fundamental types is supplied. Each such fundamental type is created by
435 calling a language dependent routine to create the type, and then a
436 pointer to that type is then placed in the array at the index specified
437 by it's FT_<TYPENAME> value. The array has a fixed size set by the
438 FT_NUM_MEMBERS compile time constant, which is the number of predefined
439 fundamental types gdb knows how to construct. */
441 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
443 /* Record the language for the compilation unit which is currently being
444 processed. We know it once we have seen the TAG_compile_unit DIE,
445 and we need it while processing the DIE's for that compilation unit.
446 It is eventually saved in the symtab structure, but we don't finalize
447 the symtab struct until we have processed all the DIE's for the
448 compilation unit. We also need to get and save a pointer to the
449 language struct for this language, so we can call the language
450 dependent routines for doing things such as creating fundamental
453 static enum language cu_language
;
454 static const struct language_defn
*cu_language_defn
;
456 /* Forward declarations of static functions so we don't have to worry
457 about ordering within this file. */
460 attribute_size
PARAMS ((unsigned int));
463 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
466 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
469 handle_producer
PARAMS ((char *));
472 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
475 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
478 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
482 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
485 scan_compilation_units
PARAMS ((char *, char *, file_ptr
,
486 file_ptr
, struct objfile
*));
489 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
492 init_psymbol_list
PARAMS ((struct objfile
*, int));
495 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
498 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
501 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
504 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
506 static struct symtab
*
507 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
510 process_dies
PARAMS ((char *, char *, struct objfile
*));
513 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
517 decode_array_element_type
PARAMS ((char *));
520 decode_subscript_data_item
PARAMS ((char *, char *));
523 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
526 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
529 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
532 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
535 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
538 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
541 decode_line_numbers
PARAMS ((char *));
544 decode_die_type
PARAMS ((struct dieinfo
*));
547 decode_mod_fund_type
PARAMS ((char *));
550 decode_mod_u_d_type
PARAMS ((char *));
553 decode_modified_type
PARAMS ((char *, unsigned int, int));
556 decode_fund_type
PARAMS ((unsigned int));
559 create_name
PARAMS ((char *, struct obstack
*));
562 lookup_utype
PARAMS ((DIE_REF
));
565 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
567 static struct symbol
*
568 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
571 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
575 locval
PARAMS ((char *));
578 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
582 set_cu_language
PARAMS ((struct dieinfo
*));
585 dwarf_fundamental_type
PARAMS ((struct objfile
*, int));
592 dwarf_fundamental_type -- lookup or create a fundamental type
597 dwarf_fundamental_type (struct objfile *objfile, int typeid)
601 DWARF version 1 doesn't supply any fundamental type information,
602 so gdb has to construct such types. It has a fixed number of
603 fundamental types that it knows how to construct, which is the
604 union of all types that it knows how to construct for all languages
605 that it knows about. These are enumerated in gdbtypes.h.
607 As an example, assume we find a DIE that references a DWARF
608 fundamental type of FT_integer. We first look in the ftypes
609 array to see if we already have such a type, indexed by the
610 gdb internal value of FT_INTEGER. If so, we simply return a
611 pointer to that type. If not, then we ask an appropriate
612 language dependent routine to create a type FT_INTEGER, using
613 defaults reasonable for the current target machine, and install
614 that type in ftypes for future reference.
618 Pointer to a fundamental type.
623 dwarf_fundamental_type (objfile
, typeid)
624 struct objfile
*objfile
;
627 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
629 error ("internal error - invalid fundamental type id %d", typeid);
632 /* Look for this particular type in the fundamental type vector. If one is
633 not found, create and install one appropriate for the current language
634 and the current target machine. */
636 if (ftypes
[typeid] == NULL
)
638 ftypes
[typeid] = cu_language_defn
-> la_fund_type(objfile
, typeid);
641 return (ftypes
[typeid]);
648 set_cu_language -- set local copy of language for compilation unit
653 set_cu_language (struct dieinfo *dip)
657 Decode the language attribute for a compilation unit DIE and
658 remember what the language was. We use this at various times
659 when processing DIE's for a given compilation unit.
668 set_cu_language (dip
)
671 switch (dip
-> at_language
)
675 cu_language
= language_c
;
677 case LANG_C_PLUS_PLUS
:
678 cu_language
= language_cplus
;
680 /* start-sanitize-chill */
682 cu_language
= language_chill
;
684 /* end-sanitize-chill */
686 cu_language
= language_m2
;
695 cu_language
= language_unknown
;
698 cu_language_defn
= language_def (cu_language
);
705 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
709 void dwarf_build_psymtabs (struct objfile *objfile,
710 struct section_offsets *section_offsets,
711 int mainline, file_ptr dbfoff, unsigned int dbfsize,
712 file_ptr lnoffset, unsigned int lnsize)
716 This function is called upon to build partial symtabs from files
717 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
719 It is passed a bfd* containing the DIES
720 and line number information, the corresponding filename for that
721 file, a base address for relocating the symbols, a flag indicating
722 whether or not this debugging information is from a "main symbol
723 table" rather than a shared library or dynamically linked file,
724 and file offset/size pairs for the DIE information and line number
734 dwarf_build_psymtabs (objfile
, section_offsets
, mainline
, dbfoff
, dbfsize
,
736 struct objfile
*objfile
;
737 struct section_offsets
*section_offsets
;
740 unsigned int dbfsize
;
744 bfd
*abfd
= objfile
->obfd
;
745 struct cleanup
*back_to
;
747 current_objfile
= objfile
;
749 dbbase
= xmalloc (dbsize
);
751 if ((bfd_seek (abfd
, dbfoff
, L_SET
) != 0) ||
752 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
755 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd
));
757 back_to
= make_cleanup (free
, dbbase
);
759 /* If we are reinitializing, or if we have never loaded syms yet, init.
760 Since we have no idea how many DIES we are looking at, we just guess
761 some arbitrary value. */
763 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
764 objfile
-> static_psymbols
.size
== 0)
766 init_psymbol_list (objfile
, 1024);
769 /* Save the relocation factor where everybody can see it. */
771 base_section_offsets
= section_offsets
;
772 baseaddr
= ANOFFSET (section_offsets
, 0);
774 /* Follow the compilation unit sibling chain, building a partial symbol
775 table entry for each one. Save enough information about each compilation
776 unit to locate the full DWARF information later. */
778 scan_compilation_units (dbbase
, dbbase
+ dbsize
, dbfoff
, lnoffset
, objfile
);
780 do_cleanups (back_to
);
781 current_objfile
= NULL
;
789 record_minimal_symbol -- add entry to gdb's minimal symbol table
793 static void record_minimal_symbol (char *name, CORE_ADDR address,
794 enum minimal_symbol_type ms_type,
795 struct objfile *objfile)
799 Given a pointer to the name of a symbol that should be added to the
800 minimal symbol table, and the address associated with that
801 symbol, records this information for later use in building the
802 minimal symbol table.
807 record_minimal_symbol (name
, address
, ms_type
, objfile
)
810 enum minimal_symbol_type ms_type
;
811 struct objfile
*objfile
;
813 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
814 prim_record_minimal_symbol (name
, address
, ms_type
);
821 read_lexical_block_scope -- process all dies in a lexical block
825 static void read_lexical_block_scope (struct dieinfo *dip,
826 char *thisdie, char *enddie)
830 Process all the DIES contained within a lexical block scope.
831 Start a new scope, process the dies, and then close the scope.
836 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
840 struct objfile
*objfile
;
842 register struct context_stack
*new;
844 push_context (0, dip
-> at_low_pc
);
845 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
846 new = pop_context ();
847 if (local_symbols
!= NULL
)
849 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
850 dip
-> at_high_pc
, objfile
);
852 local_symbols
= new -> locals
;
859 lookup_utype -- look up a user defined type from die reference
863 static type *lookup_utype (DIE_REF die_ref)
867 Given a DIE reference, lookup the user defined type associated with
868 that DIE, if it has been registered already. If not registered, then
869 return NULL. Alloc_utype() can be called to register an empty
870 type for this reference, which will be filled in later when the
871 actual referenced DIE is processed.
875 lookup_utype (die_ref
)
878 struct type
*type
= NULL
;
881 utypeidx
= (die_ref
- dbroff
) / 4;
882 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
884 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
888 type
= *(utypes
+ utypeidx
);
898 alloc_utype -- add a user defined type for die reference
902 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
906 Given a die reference DIE_REF, and a possible pointer to a user
907 defined type UTYPEP, register that this reference has a user
908 defined type and either use the specified type in UTYPEP or
909 make a new empty type that will be filled in later.
911 We should only be called after calling lookup_utype() to verify that
912 there is not currently a type registered for DIE_REF.
916 alloc_utype (die_ref
, utypep
)
923 utypeidx
= (die_ref
- dbroff
) / 4;
924 typep
= utypes
+ utypeidx
;
925 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
927 utypep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
928 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
);
930 else if (*typep
!= NULL
)
933 complain (&dup_user_type_allocation
, DIE_ID
, DIE_NAME
);
939 utypep
= alloc_type (current_objfile
);
950 decode_die_type -- return a type for a specified die
954 static struct type *decode_die_type (struct dieinfo *dip)
958 Given a pointer to a die information structure DIP, decode the
959 type of the die and return a pointer to the decoded type. All
960 dies without specific types default to type int.
964 decode_die_type (dip
)
967 struct type
*type
= NULL
;
969 if (dip
-> at_fund_type
!= 0)
971 type
= decode_fund_type (dip
-> at_fund_type
);
973 else if (dip
-> at_mod_fund_type
!= NULL
)
975 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
977 else if (dip
-> at_user_def_type
)
979 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
981 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
984 else if (dip
-> at_mod_u_d_type
)
986 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
990 type
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
999 struct_type -- compute and return the type for a struct or union
1003 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
1004 char *enddie, struct objfile *objfile)
1008 Given pointer to a die information structure for a die which
1009 defines a union or structure (and MUST define one or the other),
1010 and pointers to the raw die data that define the range of dies which
1011 define the members, compute and return the user defined type for the
1015 static struct type
*
1016 struct_type (dip
, thisdie
, enddie
, objfile
)
1017 struct dieinfo
*dip
;
1020 struct objfile
*objfile
;
1024 struct nextfield
*next
;
1027 struct nextfield
*list
= NULL
;
1028 struct nextfield
*new;
1036 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1038 /* No forward references created an empty type, so install one now */
1039 type
= alloc_utype (dip
-> die_ref
, NULL
);
1041 INIT_CPLUS_SPECIFIC(type
);
1042 switch (dip
-> die_tag
)
1044 case TAG_class_type
:
1045 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
1048 case TAG_structure_type
:
1049 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1052 case TAG_union_type
:
1053 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1057 /* Should never happen */
1058 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
1060 complain (&missing_tag
, DIE_ID
, DIE_NAME
);
1063 /* Some compilers try to be helpful by inventing "fake" names for
1064 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1065 Thanks, but no thanks... */
1066 if (dip
-> at_name
!= NULL
1067 && *dip
-> at_name
!= '~'
1068 && *dip
-> at_name
!= '.')
1070 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
1071 tpart1
, " ", dip
-> at_name
);
1073 /* Use whatever size is known. Zero is a valid size. We might however
1074 wish to check has_at_byte_size to make sure that some byte size was
1075 given explicitly, but DWARF doesn't specify that explicit sizes of
1076 zero have to present, so complaining about missing sizes should
1077 probably not be the default. */
1078 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1079 thisdie
+= dip
-> die_length
;
1080 while (thisdie
< enddie
)
1082 basicdieinfo (&mbr
, thisdie
, objfile
);
1083 completedieinfo (&mbr
, objfile
);
1084 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
1088 else if (mbr
.at_sibling
!= 0)
1090 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
1094 nextdie
= thisdie
+ mbr
.die_length
;
1096 switch (mbr
.die_tag
)
1099 /* Get space to record the next field's data. */
1100 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1103 /* Save the data. */
1104 list
-> field
.name
=
1105 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
1106 &objfile
-> type_obstack
);
1107 list
-> field
.type
= decode_die_type (&mbr
);
1108 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
1109 /* Handle bit fields. */
1110 list
-> field
.bitsize
= mbr
.at_bit_size
;
1112 /* For big endian bits, the at_bit_offset gives the additional
1113 bit offset from the MSB of the containing anonymous object to
1114 the MSB of the field. We don't have to do anything special
1115 since we don't need to know the size of the anonymous object. */
1116 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
1118 /* For little endian bits, we need to have a non-zero at_bit_size,
1119 so that we know we are in fact dealing with a bitfield. Compute
1120 the bit offset to the MSB of the anonymous object, subtract off
1121 the number of bits from the MSB of the field to the MSB of the
1122 object, and then subtract off the number of bits of the field
1123 itself. The result is the bit offset of the LSB of the field. */
1124 if (mbr
.at_bit_size
> 0)
1126 if (mbr
.has_at_byte_size
)
1128 /* The size of the anonymous object containing the bit field
1129 is explicit, so use the indicated size (in bytes). */
1130 anonymous_size
= mbr
.at_byte_size
;
1134 /* The size of the anonymous object containing the bit field
1135 matches the size of an object of the bit field's type.
1136 DWARF allows at_byte_size to be left out in such cases,
1137 as a debug information size optimization. */
1138 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
1140 list
-> field
.bitpos
+=
1141 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
1147 process_dies (thisdie
, nextdie
, objfile
);
1152 /* Now create the vector of fields, and record how big it is. We may
1153 not even have any fields, if this DIE was generated due to a reference
1154 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1155 set, which clues gdb in to the fact that it needs to search elsewhere
1156 for the full structure definition. */
1159 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1163 TYPE_NFIELDS (type
) = nfields
;
1164 TYPE_FIELDS (type
) = (struct field
*)
1165 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1166 /* Copy the saved-up fields into the field vector. */
1167 for (n
= nfields
; list
; list
= list
-> next
)
1169 TYPE_FIELD (type
, --n
) = list
-> field
;
1179 read_structure_scope -- process all dies within struct or union
1183 static void read_structure_scope (struct dieinfo *dip,
1184 char *thisdie, char *enddie, struct objfile *objfile)
1188 Called when we find the DIE that starts a structure or union
1189 scope (definition) to process all dies that define the members
1190 of the structure or union. DIP is a pointer to the die info
1191 struct for the DIE that names the structure or union.
1195 Note that we need to call struct_type regardless of whether or not
1196 the DIE has an at_name attribute, since it might be an anonymous
1197 structure or union. This gets the type entered into our set of
1200 However, if the structure is incomplete (an opaque struct/union)
1201 then suppress creating a symbol table entry for it since gdb only
1202 wants to find the one with the complete definition. Note that if
1203 it is complete, we just call new_symbol, which does it's own
1204 checking about whether the struct/union is anonymous or not (and
1205 suppresses creating a symbol table entry itself).
1210 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1211 struct dieinfo
*dip
;
1214 struct objfile
*objfile
;
1219 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1220 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1222 sym
= new_symbol (dip
, objfile
);
1225 SYMBOL_TYPE (sym
) = type
;
1226 if (cu_language
== language_cplus
)
1228 synthesize_typedef (dip
, objfile
, type
);
1238 decode_array_element_type -- decode type of the array elements
1242 static struct type *decode_array_element_type (char *scan, char *end)
1246 As the last step in decoding the array subscript information for an
1247 array DIE, we need to decode the type of the array elements. We are
1248 passed a pointer to this last part of the subscript information and
1249 must return the appropriate type. If the type attribute is not
1250 recognized, just warn about the problem and return type int.
1253 static struct type
*
1254 decode_array_element_type (scan
)
1259 unsigned short attribute
;
1260 unsigned short fundtype
;
1263 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1265 scan
+= SIZEOF_ATTRIBUTE
;
1266 if ((nbytes
= attribute_size (attribute
)) == -1)
1268 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1269 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1276 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1278 typep
= decode_fund_type (fundtype
);
1280 case AT_mod_fund_type
:
1281 typep
= decode_mod_fund_type (scan
);
1283 case AT_user_def_type
:
1284 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1286 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1288 typep
= alloc_utype (die_ref
, NULL
);
1291 case AT_mod_u_d_type
:
1292 typep
= decode_mod_u_d_type (scan
);
1295 complain (&bad_array_element_type
, DIE_ID
, DIE_NAME
, attribute
);
1296 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1307 decode_subscript_data_item -- decode array subscript item
1311 static struct type *
1312 decode_subscript_data_item (char *scan, char *end)
1316 The array subscripts and the data type of the elements of an
1317 array are described by a list of data items, stored as a block
1318 of contiguous bytes. There is a data item describing each array
1319 dimension, and a final data item describing the element type.
1320 The data items are ordered the same as their appearance in the
1321 source (I.E. leftmost dimension first, next to leftmost second,
1324 The data items describing each array dimension consist of four
1325 parts: (1) a format specifier, (2) type type of the subscript
1326 index, (3) a description of the low bound of the array dimension,
1327 and (4) a description of the high bound of the array dimension.
1329 The last data item is the description of the type of each of
1332 We are passed a pointer to the start of the block of bytes
1333 containing the remaining data items, and a pointer to the first
1334 byte past the data. This function recursively decodes the
1335 remaining data items and returns a type.
1337 If we somehow fail to decode some data, we complain about it
1338 and return a type "array of int".
1341 FIXME: This code only implements the forms currently used
1342 by the AT&T and GNU C compilers.
1344 The end pointer is supplied for error checking, maybe we should
1348 static struct type
*
1349 decode_subscript_data_item (scan
, end
)
1353 struct type
*typep
= NULL
; /* Array type we are building */
1354 struct type
*nexttype
; /* Type of each element (may be array) */
1355 struct type
*indextype
; /* Type of this index */
1356 unsigned int format
;
1357 unsigned short fundtype
;
1358 unsigned long lowbound
;
1359 unsigned long highbound
;
1362 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1364 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1368 typep
= decode_array_element_type (scan
);
1371 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1373 indextype
= decode_fund_type (fundtype
);
1374 scan
+= SIZEOF_FMT_FT
;
1375 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1376 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1378 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, current_objfile
);
1380 nexttype
= decode_subscript_data_item (scan
, end
);
1381 if (nexttype
== NULL
)
1383 /* Munged subscript data or other problem, fake it. */
1384 complain (&subscript_data_items
, DIE_ID
, DIE_NAME
);
1385 nexttype
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1387 typep
= create_array_type ((struct type
*) NULL
, nexttype
, indextype
,
1388 lowbound
, highbound
);
1397 complain (&unhandled_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1398 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1399 typep
= create_array_type ((struct type
*) NULL
, typep
, typep
, 0, 1);
1402 complain (&unknown_array_subscript_format
, DIE_ID
, DIE_NAME
, format
);
1403 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
1404 typep
= create_array_type ((struct type
*) NULL
, typep
, typep
, 0, 1);
1414 dwarf_read_array_type -- read TAG_array_type DIE
1418 static void dwarf_read_array_type (struct dieinfo *dip)
1422 Extract all information from a TAG_array_type DIE and add to
1423 the user defined type vector.
1427 dwarf_read_array_type (dip
)
1428 struct dieinfo
*dip
;
1434 unsigned short blocksz
;
1437 if (dip
-> at_ordering
!= ORD_row_major
)
1439 /* FIXME: Can gdb even handle column major arrays? */
1440 complain (¬_row_major
, DIE_ID
, DIE_NAME
);
1442 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1444 nbytes
= attribute_size (AT_subscr_data
);
1445 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1446 subend
= sub
+ nbytes
+ blocksz
;
1448 type
= decode_subscript_data_item (sub
, subend
);
1449 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1451 /* Install user defined type that has not been referenced yet. */
1452 alloc_utype (dip
-> die_ref
, type
);
1454 else if (TYPE_CODE (utype
) == TYPE_CODE_UNDEF
)
1456 /* Ick! A forward ref has already generated a blank type in our
1457 slot, and this type probably already has things pointing to it
1458 (which is what caused it to be created in the first place).
1459 If it's just a place holder we can plop our fully defined type
1460 on top of it. We can't recover the space allocated for our
1461 new type since it might be on an obstack, but we could reuse
1462 it if we kept a list of them, but it might not be worth it
1468 /* Double ick! Not only is a type already in our slot, but
1469 someone has decorated it. Complain and leave it alone. */
1470 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1479 read_tag_pointer_type -- read TAG_pointer_type DIE
1483 static void read_tag_pointer_type (struct dieinfo *dip)
1487 Extract all information from a TAG_pointer_type DIE and add to
1488 the user defined type vector.
1492 read_tag_pointer_type (dip
)
1493 struct dieinfo
*dip
;
1498 type
= decode_die_type (dip
);
1499 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1501 utype
= lookup_pointer_type (type
);
1502 alloc_utype (dip
-> die_ref
, utype
);
1506 TYPE_TARGET_TYPE (utype
) = type
;
1507 TYPE_POINTER_TYPE (type
) = utype
;
1509 /* We assume the machine has only one representation for pointers! */
1510 /* FIXME: This confuses host<->target data representations, and is a
1511 poor assumption besides. */
1513 TYPE_LENGTH (utype
) = sizeof (char *);
1514 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1522 read_subroutine_type -- process TAG_subroutine_type dies
1526 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1531 Handle DIES due to C code like:
1534 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1540 The parameter DIES are currently ignored. See if gdb has a way to
1541 include this info in it's type system, and decode them if so. Is
1542 this what the type structure's "arg_types" field is for? (FIXME)
1546 read_subroutine_type (dip
, thisdie
, enddie
)
1547 struct dieinfo
*dip
;
1551 struct type
*type
; /* Type that this function returns */
1552 struct type
*ftype
; /* Function that returns above type */
1554 /* Decode the type that this subroutine returns */
1556 type
= decode_die_type (dip
);
1558 /* Check to see if we already have a partially constructed user
1559 defined type for this DIE, from a forward reference. */
1561 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1563 /* This is the first reference to one of these types. Make
1564 a new one and place it in the user defined types. */
1565 ftype
= lookup_function_type (type
);
1566 alloc_utype (dip
-> die_ref
, ftype
);
1568 else if (TYPE_CODE (ftype
) == TYPE_CODE_UNDEF
)
1570 /* We have an existing partially constructed type, so bash it
1571 into the correct type. */
1572 TYPE_TARGET_TYPE (ftype
) = type
;
1573 TYPE_FUNCTION_TYPE (type
) = ftype
;
1574 TYPE_LENGTH (ftype
) = 1;
1575 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1579 complain (&dup_user_type_definition
, DIE_ID
, DIE_NAME
);
1587 read_enumeration -- process dies which define an enumeration
1591 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1592 char *enddie, struct objfile *objfile)
1596 Given a pointer to a die which begins an enumeration, process all
1597 the dies that define the members of the enumeration.
1601 Note that we need to call enum_type regardless of whether or not we
1602 have a symbol, since we might have an enum without a tag name (thus
1603 no symbol for the tagname).
1607 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1608 struct dieinfo
*dip
;
1611 struct objfile
*objfile
;
1616 type
= enum_type (dip
, objfile
);
1617 sym
= new_symbol (dip
, objfile
);
1620 SYMBOL_TYPE (sym
) = type
;
1621 if (cu_language
== language_cplus
)
1623 synthesize_typedef (dip
, objfile
, type
);
1632 enum_type -- decode and return a type for an enumeration
1636 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1640 Given a pointer to a die information structure for the die which
1641 starts an enumeration, process all the dies that define the members
1642 of the enumeration and return a type pointer for the enumeration.
1644 At the same time, for each member of the enumeration, create a
1645 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1646 and give it the type of the enumeration itself.
1650 Note that the DWARF specification explicitly mandates that enum
1651 constants occur in reverse order from the source program order,
1652 for "consistency" and because this ordering is easier for many
1653 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1654 Entries). Because gdb wants to see the enum members in program
1655 source order, we have to ensure that the order gets reversed while
1656 we are processing them.
1659 static struct type
*
1660 enum_type (dip
, objfile
)
1661 struct dieinfo
*dip
;
1662 struct objfile
*objfile
;
1666 struct nextfield
*next
;
1669 struct nextfield
*list
= NULL
;
1670 struct nextfield
*new;
1675 unsigned short blocksz
;
1679 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1681 /* No forward references created an empty type, so install one now */
1682 type
= alloc_utype (dip
-> die_ref
, NULL
);
1684 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1685 /* Some compilers try to be helpful by inventing "fake" names for
1686 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1687 Thanks, but no thanks... */
1688 if (dip
-> at_name
!= NULL
1689 && *dip
-> at_name
!= '~'
1690 && *dip
-> at_name
!= '.')
1692 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1693 " ", dip
-> at_name
);
1695 if (dip
-> at_byte_size
!= 0)
1697 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1699 if ((scan
= dip
-> at_element_list
) != NULL
)
1701 if (dip
-> short_element_list
)
1703 nbytes
= attribute_size (AT_short_element_list
);
1707 nbytes
= attribute_size (AT_element_list
);
1709 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1710 listend
= scan
+ nbytes
+ blocksz
;
1712 while (scan
< listend
)
1714 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1717 list
-> field
.type
= NULL
;
1718 list
-> field
.bitsize
= 0;
1719 list
-> field
.bitpos
=
1720 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1722 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1723 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1724 &objfile
-> type_obstack
);
1725 scan
+= strlen (scan
) + 1;
1727 /* Handcraft a new symbol for this enum member. */
1728 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1729 sizeof (struct symbol
));
1730 memset (sym
, 0, sizeof (struct symbol
));
1731 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1732 &objfile
->symbol_obstack
);
1733 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1734 SYMBOL_CLASS (sym
) = LOC_CONST
;
1735 SYMBOL_TYPE (sym
) = type
;
1736 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1737 add_symbol_to_list (sym
, list_in_scope
);
1739 /* Now create the vector of fields, and record how big it is. This is
1740 where we reverse the order, by pulling the members off the list in
1741 reverse order from how they were inserted. If we have no fields
1742 (this is apparently possible in C++) then skip building a field
1746 TYPE_NFIELDS (type
) = nfields
;
1747 TYPE_FIELDS (type
) = (struct field
*)
1748 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1749 /* Copy the saved-up fields into the field vector. */
1750 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1752 TYPE_FIELD (type
, n
++) = list
-> field
;
1763 read_func_scope -- process all dies within a function scope
1767 Process all dies within a given function scope. We are passed
1768 a die information structure pointer DIP for the die which
1769 starts the function scope, and pointers into the raw die data
1770 that define the dies within the function scope.
1772 For now, we ignore lexical block scopes within the function.
1773 The problem is that AT&T cc does not define a DWARF lexical
1774 block scope for the function itself, while gcc defines a
1775 lexical block scope for the function. We need to think about
1776 how to handle this difference, or if it is even a problem.
1781 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1782 struct dieinfo
*dip
;
1785 struct objfile
*objfile
;
1787 register struct context_stack
*new;
1789 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1790 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1792 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1793 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1795 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1797 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1798 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1800 new = push_context (0, dip
-> at_low_pc
);
1801 new -> name
= new_symbol (dip
, objfile
);
1802 list_in_scope
= &local_symbols
;
1803 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1804 new = pop_context ();
1805 /* Make a block for the local symbols within. */
1806 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1807 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1808 list_in_scope
= &file_symbols
;
1816 handle_producer -- process the AT_producer attribute
1820 Perform any operations that depend on finding a particular
1821 AT_producer attribute.
1826 handle_producer (producer
)
1830 /* If this compilation unit was compiled with g++ or gcc, then set the
1831 processing_gcc_compilation flag. */
1833 processing_gcc_compilation
=
1834 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1835 /* start-sanitize-chill */
1836 || STREQN (producer
, CHILL_PRODUCER
, strlen (CHILL_PRODUCER
))
1837 /* end-sanitize-chill */
1838 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1840 /* Select a demangling style if we can identify the producer and if
1841 the current style is auto. We leave the current style alone if it
1842 is not auto. We also leave the demangling style alone if we find a
1843 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1845 #if 1 /* Works, but is experimental. -fnf */
1846 if (AUTO_DEMANGLING
)
1848 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1850 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1852 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1854 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1856 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1858 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1869 read_file_scope -- process all dies within a file scope
1873 Process all dies within a given file scope. We are passed a
1874 pointer to the die information structure for the die which
1875 starts the file scope, and pointers into the raw die data which
1876 mark the range of dies within the file scope.
1878 When the partial symbol table is built, the file offset for the line
1879 number table for each compilation unit is saved in the partial symbol
1880 table entry for that compilation unit. As the symbols for each
1881 compilation unit are read, the line number table is read into memory
1882 and the variable lnbase is set to point to it. Thus all we have to
1883 do is use lnbase to access the line number table for the current
1888 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1889 struct dieinfo
*dip
;
1892 struct objfile
*objfile
;
1894 struct cleanup
*back_to
;
1895 struct symtab
*symtab
;
1897 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1898 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1900 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1901 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1903 set_cu_language (dip
);
1904 if (dip
-> at_producer
!= NULL
)
1906 handle_producer (dip
-> at_producer
);
1908 numutypes
= (enddie
- thisdie
) / 4;
1909 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1910 back_to
= make_cleanup (free
, utypes
);
1911 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1912 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1913 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1914 decode_line_numbers (lnbase
);
1915 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1916 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1919 symtab
-> language
= cu_language
;
1921 do_cleanups (back_to
);
1930 process_dies -- process a range of DWARF Information Entries
1934 static void process_dies (char *thisdie, char *enddie,
1935 struct objfile *objfile)
1939 Process all DIE's in a specified range. May be (and almost
1940 certainly will be) called recursively.
1944 process_dies (thisdie
, enddie
, objfile
)
1947 struct objfile
*objfile
;
1952 while (thisdie
< enddie
)
1954 basicdieinfo (&di
, thisdie
, objfile
);
1955 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1959 else if (di
.die_tag
== TAG_padding
)
1961 nextdie
= thisdie
+ di
.die_length
;
1965 completedieinfo (&di
, objfile
);
1966 if (di
.at_sibling
!= 0)
1968 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1972 nextdie
= thisdie
+ di
.die_length
;
1976 case TAG_compile_unit
:
1977 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1979 case TAG_global_subroutine
:
1980 case TAG_subroutine
:
1981 if (di
.has_at_low_pc
)
1983 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1986 case TAG_lexical_block
:
1987 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1989 case TAG_class_type
:
1990 case TAG_structure_type
:
1991 case TAG_union_type
:
1992 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1994 case TAG_enumeration_type
:
1995 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1997 case TAG_subroutine_type
:
1998 read_subroutine_type (&di
, thisdie
, nextdie
);
2000 case TAG_array_type
:
2001 dwarf_read_array_type (&di
);
2003 case TAG_pointer_type
:
2004 read_tag_pointer_type (&di
);
2007 new_symbol (&di
, objfile
);
2019 decode_line_numbers -- decode a line number table fragment
2023 static void decode_line_numbers (char *tblscan, char *tblend,
2024 long length, long base, long line, long pc)
2028 Translate the DWARF line number information to gdb form.
2030 The ".line" section contains one or more line number tables, one for
2031 each ".line" section from the objects that were linked.
2033 The AT_stmt_list attribute for each TAG_source_file entry in the
2034 ".debug" section contains the offset into the ".line" section for the
2035 start of the table for that file.
2037 The table itself has the following structure:
2039 <table length><base address><source statement entry>
2040 4 bytes 4 bytes 10 bytes
2042 The table length is the total size of the table, including the 4 bytes
2043 for the length information.
2045 The base address is the address of the first instruction generated
2046 for the source file.
2048 Each source statement entry has the following structure:
2050 <line number><statement position><address delta>
2051 4 bytes 2 bytes 4 bytes
2053 The line number is relative to the start of the file, starting with
2056 The statement position either -1 (0xFFFF) or the number of characters
2057 from the beginning of the line to the beginning of the statement.
2059 The address delta is the difference between the base address and
2060 the address of the first instruction for the statement.
2062 Note that we must copy the bytes from the packed table to our local
2063 variables before attempting to use them, to avoid alignment problems
2064 on some machines, particularly RISC processors.
2068 Does gdb expect the line numbers to be sorted? They are now by
2069 chance/luck, but are not required to be. (FIXME)
2071 The line with number 0 is unused, gdb apparently can discover the
2072 span of the last line some other way. How? (FIXME)
2076 decode_line_numbers (linetable
)
2081 unsigned long length
;
2086 if (linetable
!= NULL
)
2088 tblscan
= tblend
= linetable
;
2089 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
2091 tblscan
+= SIZEOF_LINETBL_LENGTH
;
2093 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
2094 GET_UNSIGNED
, current_objfile
);
2095 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
2097 while (tblscan
< tblend
)
2099 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
2101 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
2102 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
2104 tblscan
+= SIZEOF_LINETBL_DELTA
;
2108 record_line (current_subfile
, line
, pc
);
2118 locval -- compute the value of a location attribute
2122 static int locval (char *loc)
2126 Given pointer to a string of bytes that define a location, compute
2127 the location and return the value.
2129 When computing values involving the current value of the frame pointer,
2130 the value zero is used, which results in a value relative to the frame
2131 pointer, rather than the absolute value. This is what GDB wants
2134 When the result is a register number, the global isreg flag is set,
2135 otherwise it is cleared. This is a kludge until we figure out a better
2136 way to handle the problem. Gdb's design does not mesh well with the
2137 DWARF notion of a location computing interpreter, which is a shame
2138 because the flexibility goes unused.
2142 Note that stack[0] is unused except as a default error return.
2143 Note that stack overflow is not yet handled.
2150 unsigned short nbytes
;
2151 unsigned short locsize
;
2152 auto long stack
[64];
2159 nbytes
= attribute_size (AT_location
);
2160 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
2162 end
= loc
+ locsize
;
2167 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
2170 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
2172 loc
+= SIZEOF_LOC_ATOM_CODE
;
2173 switch (loc_atom_code
)
2180 /* push register (number) */
2181 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2182 GET_UNSIGNED
, current_objfile
);
2183 loc
+= loc_value_size
;
2187 /* push value of register (number) */
2188 /* Actually, we compute the value as if register has 0 */
2190 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2192 loc
+= loc_value_size
;
2195 stack
[++stacki
] = 0;
2199 stack
[++stacki
] = 0;
2201 complain (&basereg_not_handled
, DIE_ID
, DIE_NAME
, regno
);
2205 /* push address (relocated address) */
2206 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2207 GET_UNSIGNED
, current_objfile
);
2208 loc
+= loc_value_size
;
2211 /* push constant (number) FIXME: signed or unsigned! */
2212 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2213 GET_SIGNED
, current_objfile
);
2214 loc
+= loc_value_size
;
2217 /* pop, deref and push 2 bytes (as a long) */
2218 complain (&op_deref2
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2220 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2221 complain (&op_deref4
, DIE_ID
, DIE_NAME
, stack
[stacki
]);
2223 case OP_ADD
: /* pop top 2 items, add, push result */
2224 stack
[stacki
- 1] += stack
[stacki
];
2229 return (stack
[stacki
]);
2236 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2240 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2244 When expanding a partial symbol table entry to a full symbol table
2245 entry, this is the function that gets called to read in the symbols
2246 for the compilation unit.
2248 Returns a pointer to the newly constructed symtab (which is now
2249 the new first one on the objfile's symtab list).
2252 static struct symtab
*
2253 read_ofile_symtab (pst
)
2254 struct partial_symtab
*pst
;
2256 struct cleanup
*back_to
;
2257 unsigned long lnsize
;
2260 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2262 abfd
= pst
-> objfile
-> obfd
;
2263 current_objfile
= pst
-> objfile
;
2265 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2266 unit, seek to the location in the file, and read in all the DIE's. */
2269 dbsize
= DBLENGTH (pst
);
2270 dbbase
= xmalloc (dbsize
);
2271 dbroff
= DBROFF(pst
);
2272 foffset
= DBFOFF(pst
) + dbroff
;
2273 base_section_offsets
= pst
->section_offsets
;
2274 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2275 if (bfd_seek (abfd
, foffset
, L_SET
) ||
2276 (bfd_read (dbbase
, dbsize
, 1, abfd
) != dbsize
))
2279 error ("can't read DWARF data");
2281 back_to
= make_cleanup (free
, dbbase
);
2283 /* If there is a line number table associated with this compilation unit
2284 then read the size of this fragment in bytes, from the fragment itself.
2285 Allocate a buffer for the fragment and read it in for future
2291 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2292 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2293 sizeof (lnsizedata
)))
2295 error ("can't read DWARF line number table size");
2297 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2298 GET_UNSIGNED
, pst
-> objfile
);
2299 lnbase
= xmalloc (lnsize
);
2300 if (bfd_seek (abfd
, LNFOFF (pst
), L_SET
) ||
2301 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2304 error ("can't read DWARF line numbers");
2306 make_cleanup (free
, lnbase
);
2309 process_dies (dbbase
, dbbase
+ dbsize
, pst
-> objfile
);
2310 do_cleanups (back_to
);
2311 current_objfile
= NULL
;
2312 return (pst
-> objfile
-> symtabs
);
2319 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2323 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2327 Called once for each partial symbol table entry that needs to be
2328 expanded into a full symbol table entry.
2333 psymtab_to_symtab_1 (pst
)
2334 struct partial_symtab
*pst
;
2337 struct cleanup
*old_chain
;
2343 warning ("psymtab for %s already read in. Shouldn't happen.",
2348 /* Read in all partial symtabs on which this one is dependent */
2349 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2351 if (!pst
-> dependencies
[i
] -> readin
)
2353 /* Inform about additional files that need to be read in. */
2356 fputs_filtered (" ", stdout
);
2358 fputs_filtered ("and ", stdout
);
2360 printf_filtered ("%s...",
2361 pst
-> dependencies
[i
] -> filename
);
2363 fflush (stdout
); /* Flush output */
2365 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2368 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2371 old_chain
= make_cleanup (really_free_pendings
, 0);
2372 pst
-> symtab
= read_ofile_symtab (pst
);
2375 printf_filtered ("%d DIE's, sorting...", diecount
);
2379 sort_symtab_syms (pst
-> symtab
);
2380 do_cleanups (old_chain
);
2391 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2395 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2399 This is the DWARF support entry point for building a full symbol
2400 table entry from a partial symbol table entry. We are passed a
2401 pointer to the partial symbol table entry that needs to be expanded.
2406 dwarf_psymtab_to_symtab (pst
)
2407 struct partial_symtab
*pst
;
2414 warning ("psymtab for %s already read in. Shouldn't happen.",
2419 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2421 /* Print the message now, before starting serious work, to avoid
2422 disconcerting pauses. */
2425 printf_filtered ("Reading in symbols for %s...",
2430 psymtab_to_symtab_1 (pst
);
2432 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2433 we need to do an equivalent or is this something peculiar to
2435 Match with global symbols. This only needs to be done once,
2436 after all of the symtabs and dependencies have been read in.
2438 scan_file_globals (pst
-> objfile
);
2441 /* Finish up the verbose info message. */
2444 printf_filtered ("done.\n");
2456 init_psymbol_list -- initialize storage for partial symbols
2460 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2464 Initializes storage for all of the partial symbols that will be
2465 created by dwarf_build_psymtabs and subsidiaries.
2469 init_psymbol_list (objfile
, total_symbols
)
2470 struct objfile
*objfile
;
2473 /* Free any previously allocated psymbol lists. */
2475 if (objfile
-> global_psymbols
.list
)
2477 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2479 if (objfile
-> static_psymbols
.list
)
2481 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2484 /* Current best guess is that there are approximately a twentieth
2485 of the total symbols (in a debugging file) are global or static
2488 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2489 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2490 objfile
-> global_psymbols
.next
=
2491 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2492 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2493 * sizeof (struct partial_symbol
));
2494 objfile
-> static_psymbols
.next
=
2495 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2496 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2497 * sizeof (struct partial_symbol
));
2504 add_enum_psymbol -- add enumeration members to partial symbol table
2508 Given pointer to a DIE that is known to be for an enumeration,
2509 extract the symbolic names of the enumeration members and add
2510 partial symbols for them.
2514 add_enum_psymbol (dip
, objfile
)
2515 struct dieinfo
*dip
;
2516 struct objfile
*objfile
;
2520 unsigned short blocksz
;
2523 if ((scan
= dip
-> at_element_list
) != NULL
)
2525 if (dip
-> short_element_list
)
2527 nbytes
= attribute_size (AT_short_element_list
);
2531 nbytes
= attribute_size (AT_element_list
);
2533 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2535 listend
= scan
+ blocksz
;
2536 while (scan
< listend
)
2538 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2539 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2540 objfile
-> static_psymbols
, 0);
2541 scan
+= strlen (scan
) + 1;
2550 add_partial_symbol -- add symbol to partial symbol table
2554 Given a DIE, if it is one of the types that we want to
2555 add to a partial symbol table, finish filling in the die info
2556 and then add a partial symbol table entry for it.
2560 The caller must ensure that the DIE has a valid name attribute.
2564 add_partial_symbol (dip
, objfile
)
2565 struct dieinfo
*dip
;
2566 struct objfile
*objfile
;
2568 switch (dip
-> die_tag
)
2570 case TAG_global_subroutine
:
2571 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2573 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2574 VAR_NAMESPACE
, LOC_BLOCK
,
2575 objfile
-> global_psymbols
,
2578 case TAG_global_variable
:
2579 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2581 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2582 VAR_NAMESPACE
, LOC_STATIC
,
2583 objfile
-> global_psymbols
,
2586 case TAG_subroutine
:
2587 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2588 VAR_NAMESPACE
, LOC_BLOCK
,
2589 objfile
-> static_psymbols
,
2592 case TAG_local_variable
:
2593 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2594 VAR_NAMESPACE
, LOC_STATIC
,
2595 objfile
-> static_psymbols
,
2599 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2600 VAR_NAMESPACE
, LOC_TYPEDEF
,
2601 objfile
-> static_psymbols
,
2604 case TAG_class_type
:
2605 case TAG_structure_type
:
2606 case TAG_union_type
:
2607 case TAG_enumeration_type
:
2608 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2609 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2610 objfile
-> static_psymbols
,
2612 if (cu_language
== language_cplus
)
2614 /* For C++, these implicitly act as typedefs as well. */
2615 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2616 VAR_NAMESPACE
, LOC_TYPEDEF
,
2617 objfile
-> static_psymbols
,
2628 scan_partial_symbols -- scan DIE's within a single compilation unit
2632 Process the DIE's within a single compilation unit, looking for
2633 interesting DIE's that contribute to the partial symbol table entry
2634 for this compilation unit.
2638 There are some DIE's that may appear both at file scope and within
2639 the scope of a function. We are only interested in the ones at file
2640 scope, and the only way to tell them apart is to keep track of the
2641 scope. For example, consider the test case:
2646 for which the relevant DWARF segment has the structure:
2649 0x23 global subrtn sibling 0x9b
2651 fund_type FT_integer
2656 0x23 local var sibling 0x97
2658 fund_type FT_integer
2659 location OP_BASEREG 0xe
2666 0x1d local var sibling 0xb8
2668 fund_type FT_integer
2669 location OP_ADDR 0x800025dc
2674 We want to include the symbol 'i' in the partial symbol table, but
2675 not the symbol 'j'. In essence, we want to skip all the dies within
2676 the scope of a TAG_global_subroutine DIE.
2678 Don't attempt to add anonymous structures or unions since they have
2679 no name. Anonymous enumerations however are processed, because we
2680 want to extract their member names (the check for a tag name is
2683 Also, for variables and subroutines, check that this is the place
2684 where the actual definition occurs, rather than just a reference
2689 scan_partial_symbols (thisdie
, enddie
, objfile
)
2692 struct objfile
*objfile
;
2698 while (thisdie
< enddie
)
2700 basicdieinfo (&di
, thisdie
, objfile
);
2701 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2707 nextdie
= thisdie
+ di
.die_length
;
2708 /* To avoid getting complete die information for every die, we
2709 only do it (below) for the cases we are interested in. */
2712 case TAG_global_subroutine
:
2713 case TAG_subroutine
:
2714 completedieinfo (&di
, objfile
);
2715 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2717 add_partial_symbol (&di
, objfile
);
2718 /* If there is a sibling attribute, adjust the nextdie
2719 pointer to skip the entire scope of the subroutine.
2720 Apply some sanity checking to make sure we don't
2721 overrun or underrun the range of remaining DIE's */
2722 if (di
.at_sibling
!= 0)
2724 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2725 if ((temp
< thisdie
) || (temp
>= enddie
))
2727 complain (&bad_die_ref
, DIE_ID
, DIE_NAME
,
2737 case TAG_global_variable
:
2738 case TAG_local_variable
:
2739 completedieinfo (&di
, objfile
);
2740 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2742 add_partial_symbol (&di
, objfile
);
2746 case TAG_class_type
:
2747 case TAG_structure_type
:
2748 case TAG_union_type
:
2749 completedieinfo (&di
, objfile
);
2752 add_partial_symbol (&di
, objfile
);
2755 case TAG_enumeration_type
:
2756 completedieinfo (&di
, objfile
);
2759 add_partial_symbol (&di
, objfile
);
2761 add_enum_psymbol (&di
, objfile
);
2773 scan_compilation_units -- build a psymtab entry for each compilation
2777 This is the top level dwarf parsing routine for building partial
2780 It scans from the beginning of the DWARF table looking for the first
2781 TAG_compile_unit DIE, and then follows the sibling chain to locate
2782 each additional TAG_compile_unit DIE.
2784 For each TAG_compile_unit DIE it creates a partial symtab structure,
2785 calls a subordinate routine to collect all the compilation unit's
2786 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2787 new partial symtab structure into the partial symbol table. It also
2788 records the appropriate information in the partial symbol table entry
2789 to allow the chunk of DIE's and line number table for this compilation
2790 unit to be located and re-read later, to generate a complete symbol
2791 table entry for the compilation unit.
2793 Thus it effectively partitions up a chunk of DIE's for multiple
2794 compilation units into smaller DIE chunks and line number tables,
2795 and associates them with a partial symbol table entry.
2799 If any compilation unit has no line number table associated with
2800 it for some reason (a missing at_stmt_list attribute, rather than
2801 just one with a value of zero, which is valid) then we ensure that
2802 the recorded file offset is zero so that the routine which later
2803 reads line number table fragments knows that there is no fragment
2813 scan_compilation_units (thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2818 struct objfile
*objfile
;
2822 struct partial_symtab
*pst
;
2825 file_ptr curlnoffset
;
2827 while (thisdie
< enddie
)
2829 basicdieinfo (&di
, thisdie
, objfile
);
2830 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2834 else if (di
.die_tag
!= TAG_compile_unit
)
2836 nextdie
= thisdie
+ di
.die_length
;
2840 completedieinfo (&di
, objfile
);
2841 set_cu_language (&di
);
2842 if (di
.at_sibling
!= 0)
2844 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2848 nextdie
= thisdie
+ di
.die_length
;
2850 curoff
= thisdie
- dbbase
;
2851 culength
= nextdie
- thisdie
;
2852 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2854 /* First allocate a new partial symbol table structure */
2856 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2857 di
.at_name
, di
.at_low_pc
,
2858 objfile
-> global_psymbols
.next
,
2859 objfile
-> static_psymbols
.next
);
2861 pst
-> texthigh
= di
.at_high_pc
;
2862 pst
-> read_symtab_private
= (char *)
2863 obstack_alloc (&objfile
-> psymbol_obstack
,
2864 sizeof (struct dwfinfo
));
2865 DBFOFF (pst
) = dbfoff
;
2866 DBROFF (pst
) = curoff
;
2867 DBLENGTH (pst
) = culength
;
2868 LNFOFF (pst
) = curlnoffset
;
2869 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2871 /* Now look for partial symbols */
2873 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2875 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2876 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2877 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2878 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2879 sort_pst_symbols (pst
);
2880 /* If there is already a psymtab or symtab for a file of this name,
2881 remove it. (If there is a symtab, more drastic things also
2882 happen.) This happens in VxWorks. */
2883 free_named_symtabs (pst
-> filename
);
2893 new_symbol -- make a symbol table entry for a new symbol
2897 static struct symbol *new_symbol (struct dieinfo *dip,
2898 struct objfile *objfile)
2902 Given a pointer to a DWARF information entry, figure out if we need
2903 to make a symbol table entry for it, and if so, create a new entry
2904 and return a pointer to it.
2907 static struct symbol
*
2908 new_symbol (dip
, objfile
)
2909 struct dieinfo
*dip
;
2910 struct objfile
*objfile
;
2912 struct symbol
*sym
= NULL
;
2914 if (dip
-> at_name
!= NULL
)
2916 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2917 sizeof (struct symbol
));
2918 memset (sym
, 0, sizeof (struct symbol
));
2919 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2920 &objfile
->symbol_obstack
);
2921 /* default assumptions */
2922 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2923 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2924 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2925 switch (dip
-> die_tag
)
2928 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2929 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2931 case TAG_global_subroutine
:
2932 case TAG_subroutine
:
2933 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2934 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2935 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2936 if (dip
-> die_tag
== TAG_global_subroutine
)
2938 add_symbol_to_list (sym
, &global_symbols
);
2942 add_symbol_to_list (sym
, list_in_scope
);
2945 case TAG_global_variable
:
2946 if (dip
-> at_location
!= NULL
)
2948 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2949 add_symbol_to_list (sym
, &global_symbols
);
2950 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2951 SYMBOL_VALUE (sym
) += baseaddr
;
2954 case TAG_local_variable
:
2955 if (dip
-> at_location
!= NULL
)
2957 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2958 add_symbol_to_list (sym
, list_in_scope
);
2961 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2965 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2969 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2970 SYMBOL_VALUE (sym
) += baseaddr
;
2974 case TAG_formal_parameter
:
2975 if (dip
-> at_location
!= NULL
)
2977 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2979 add_symbol_to_list (sym
, list_in_scope
);
2982 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2986 SYMBOL_CLASS (sym
) = LOC_ARG
;
2989 case TAG_unspecified_parameters
:
2990 /* From varargs functions; gdb doesn't seem to have any interest in
2991 this information, so just ignore it for now. (FIXME?) */
2993 case TAG_class_type
:
2994 case TAG_structure_type
:
2995 case TAG_union_type
:
2996 case TAG_enumeration_type
:
2997 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2998 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2999 add_symbol_to_list (sym
, list_in_scope
);
3002 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3003 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3004 add_symbol_to_list (sym
, list_in_scope
);
3007 /* Not a tag we recognize. Hopefully we aren't processing trash
3008 data, but since we must specifically ignore things we don't
3009 recognize, there is nothing else we should do at this point. */
3020 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3024 static void synthesize_typedef (struct dieinfo *dip,
3025 struct objfile *objfile,
3030 Given a pointer to a DWARF information entry, synthesize a typedef
3031 for the name in the DIE, using the specified type.
3033 This is used for C++ class, structs, unions, and enumerations to
3034 set up the tag name as a type.
3039 synthesize_typedef (dip
, objfile
, type
)
3040 struct dieinfo
*dip
;
3041 struct objfile
*objfile
;
3044 struct symbol
*sym
= NULL
;
3046 if (dip
-> at_name
!= NULL
)
3048 sym
= (struct symbol
*)
3049 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3050 memset (sym
, 0, sizeof (struct symbol
));
3051 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
3052 &objfile
->symbol_obstack
);
3053 SYMBOL_TYPE (sym
) = type
;
3054 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3055 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3056 add_symbol_to_list (sym
, list_in_scope
);
3064 decode_mod_fund_type -- decode a modified fundamental type
3068 static struct type *decode_mod_fund_type (char *typedata)
3072 Decode a block of data containing a modified fundamental
3073 type specification. TYPEDATA is a pointer to the block,
3074 which starts with a length containing the size of the rest
3075 of the block. At the end of the block is a fundmental type
3076 code value that gives the fundamental type. Everything
3077 in between are type modifiers.
3079 We simply compute the number of modifiers and call the general
3080 function decode_modified_type to do the actual work.
3083 static struct type
*
3084 decode_mod_fund_type (typedata
)
3087 struct type
*typep
= NULL
;
3088 unsigned short modcount
;
3091 /* Get the total size of the block, exclusive of the size itself */
3093 nbytes
= attribute_size (AT_mod_fund_type
);
3094 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3097 /* Deduct the size of the fundamental type bytes at the end of the block. */
3099 modcount
-= attribute_size (AT_fund_type
);
3101 /* Now do the actual decoding */
3103 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
3111 decode_mod_u_d_type -- decode a modified user defined type
3115 static struct type *decode_mod_u_d_type (char *typedata)
3119 Decode a block of data containing a modified user defined
3120 type specification. TYPEDATA is a pointer to the block,
3121 which consists of a two byte length, containing the size
3122 of the rest of the block. At the end of the block is a
3123 four byte value that gives a reference to a user defined type.
3124 Everything in between are type modifiers.
3126 We simply compute the number of modifiers and call the general
3127 function decode_modified_type to do the actual work.
3130 static struct type
*
3131 decode_mod_u_d_type (typedata
)
3134 struct type
*typep
= NULL
;
3135 unsigned short modcount
;
3138 /* Get the total size of the block, exclusive of the size itself */
3140 nbytes
= attribute_size (AT_mod_u_d_type
);
3141 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
3144 /* Deduct the size of the reference type bytes at the end of the block. */
3146 modcount
-= attribute_size (AT_user_def_type
);
3148 /* Now do the actual decoding */
3150 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
3158 decode_modified_type -- decode modified user or fundamental type
3162 static struct type *decode_modified_type (char *modifiers,
3163 unsigned short modcount, int mtype)
3167 Decode a modified type, either a modified fundamental type or
3168 a modified user defined type. MODIFIERS is a pointer to the
3169 block of bytes that define MODCOUNT modifiers. Immediately
3170 following the last modifier is a short containing the fundamental
3171 type or a long containing the reference to the user defined
3172 type. Which one is determined by MTYPE, which is either
3173 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3174 type we are generating.
3176 We call ourself recursively to generate each modified type,`
3177 until MODCOUNT reaches zero, at which point we have consumed
3178 all the modifiers and generate either the fundamental type or
3179 user defined type. When the recursion unwinds, each modifier
3180 is applied in turn to generate the full modified type.
3184 If we find a modifier that we don't recognize, and it is not one
3185 of those reserved for application specific use, then we issue a
3186 warning and simply ignore the modifier.
3190 We currently ignore MOD_const and MOD_volatile. (FIXME)
3194 static struct type
*
3195 decode_modified_type (modifiers
, modcount
, mtype
)
3197 unsigned int modcount
;
3200 struct type
*typep
= NULL
;
3201 unsigned short fundtype
;
3210 case AT_mod_fund_type
:
3211 nbytes
= attribute_size (AT_fund_type
);
3212 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3214 typep
= decode_fund_type (fundtype
);
3216 case AT_mod_u_d_type
:
3217 nbytes
= attribute_size (AT_user_def_type
);
3218 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3220 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3222 typep
= alloc_utype (die_ref
, NULL
);
3226 complain (&botched_modified_type
, DIE_ID
, DIE_NAME
, mtype
);
3227 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3233 modifier
= *modifiers
++;
3234 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3237 case MOD_pointer_to
:
3238 typep
= lookup_pointer_type (typep
);
3240 case MOD_reference_to
:
3241 typep
= lookup_reference_type (typep
);
3244 complain (&const_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3247 complain (&volatile_ignored
, DIE_ID
, DIE_NAME
); /* FIXME */
3250 if (!(MOD_lo_user
<= (unsigned char) modifier
3251 && (unsigned char) modifier
<= MOD_hi_user
))
3253 complain (&unknown_type_modifier
, DIE_ID
, DIE_NAME
, modifier
);
3265 decode_fund_type -- translate basic DWARF type to gdb base type
3269 Given an integer that is one of the fundamental DWARF types,
3270 translate it to one of the basic internal gdb types and return
3271 a pointer to the appropriate gdb type (a "struct type *").
3275 For robustness, if we are asked to translate a fundamental
3276 type that we are unprepared to deal with, we return int so
3277 callers can always depend upon a valid type being returned,
3278 and so gdb may at least do something reasonable by default.
3279 If the type is not in the range of those types defined as
3280 application specific types, we also issue a warning.
3283 static struct type
*
3284 decode_fund_type (fundtype
)
3285 unsigned int fundtype
;
3287 struct type
*typep
= NULL
;
3293 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3296 case FT_boolean
: /* Was FT_set in AT&T version */
3297 typep
= dwarf_fundamental_type (current_objfile
, FT_BOOLEAN
);
3300 case FT_pointer
: /* (void *) */
3301 typep
= dwarf_fundamental_type (current_objfile
, FT_VOID
);
3302 typep
= lookup_pointer_type (typep
);
3306 typep
= dwarf_fundamental_type (current_objfile
, FT_CHAR
);
3309 case FT_signed_char
:
3310 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3313 case FT_unsigned_char
:
3314 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3318 typep
= dwarf_fundamental_type (current_objfile
, FT_SHORT
);
3321 case FT_signed_short
:
3322 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3325 case FT_unsigned_short
:
3326 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3330 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3333 case FT_signed_integer
:
3334 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3337 case FT_unsigned_integer
:
3338 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3342 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG
);
3345 case FT_signed_long
:
3346 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3349 case FT_unsigned_long
:
3350 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3354 typep
= dwarf_fundamental_type (current_objfile
, FT_LONG_LONG
);
3357 case FT_signed_long_long
:
3358 typep
= dwarf_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3361 case FT_unsigned_long_long
:
3362 typep
= dwarf_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3366 typep
= dwarf_fundamental_type (current_objfile
, FT_FLOAT
);
3369 case FT_dbl_prec_float
:
3370 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3373 case FT_ext_prec_float
:
3374 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3378 typep
= dwarf_fundamental_type (current_objfile
, FT_COMPLEX
);
3381 case FT_dbl_prec_complex
:
3382 typep
= dwarf_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3385 case FT_ext_prec_complex
:
3386 typep
= dwarf_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3393 typep
= dwarf_fundamental_type (current_objfile
, FT_INTEGER
);
3394 if (!(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3396 complain (&unexpected_fund_type
, DIE_ID
, DIE_NAME
, fundtype
);
3407 create_name -- allocate a fresh copy of a string on an obstack
3411 Given a pointer to a string and a pointer to an obstack, allocates
3412 a fresh copy of the string on the specified obstack.
3417 create_name (name
, obstackp
)
3419 struct obstack
*obstackp
;
3424 length
= strlen (name
) + 1;
3425 newname
= (char *) obstack_alloc (obstackp
, length
);
3426 strcpy (newname
, name
);
3434 basicdieinfo -- extract the minimal die info from raw die data
3438 void basicdieinfo (char *diep, struct dieinfo *dip,
3439 struct objfile *objfile)
3443 Given a pointer to raw DIE data, and a pointer to an instance of a
3444 die info structure, this function extracts the basic information
3445 from the DIE data required to continue processing this DIE, along
3446 with some bookkeeping information about the DIE.
3448 The information we absolutely must have includes the DIE tag,
3449 and the DIE length. If we need the sibling reference, then we
3450 will have to call completedieinfo() to process all the remaining
3453 Note that since there is no guarantee that the data is properly
3454 aligned in memory for the type of access required (indirection
3455 through anything other than a char pointer), and there is no
3456 guarantee that it is in the same byte order as the gdb host,
3457 we call a function which deals with both alignment and byte
3458 swapping issues. Possibly inefficient, but quite portable.
3460 We also take care of some other basic things at this point, such
3461 as ensuring that the instance of the die info structure starts
3462 out completely zero'd and that curdie is initialized for use
3463 in error reporting if we have a problem with the current die.
3467 All DIE's must have at least a valid length, thus the minimum
3468 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3469 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3470 are forced to be TAG_padding DIES.
3472 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3473 that if a padding DIE is used for alignment and the amount needed is
3474 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3475 enough to align to the next alignment boundry.
3477 We do some basic sanity checking here, such as verifying that the
3478 length of the die would not cause it to overrun the recorded end of
3479 the buffer holding the DIE info. If we find a DIE that is either
3480 too small or too large, we force it's length to zero which should
3481 cause the caller to take appropriate action.
3485 basicdieinfo (dip
, diep
, objfile
)
3486 struct dieinfo
*dip
;
3488 struct objfile
*objfile
;
3491 memset (dip
, 0, sizeof (struct dieinfo
));
3493 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3494 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3496 if ((dip
-> die_length
< SIZEOF_DIE_LENGTH
) ||
3497 ((diep
+ dip
-> die_length
) > (dbbase
+ dbsize
)))
3499 complain (&malformed_die
, DIE_ID
, DIE_NAME
, dip
-> die_length
);
3500 dip
-> die_length
= 0;
3502 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3504 dip
-> die_tag
= TAG_padding
;
3508 diep
+= SIZEOF_DIE_LENGTH
;
3509 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3518 completedieinfo -- finish reading the information for a given DIE
3522 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3526 Given a pointer to an already partially initialized die info structure,
3527 scan the raw DIE data and finish filling in the die info structure
3528 from the various attributes found.
3530 Note that since there is no guarantee that the data is properly
3531 aligned in memory for the type of access required (indirection
3532 through anything other than a char pointer), and there is no
3533 guarantee that it is in the same byte order as the gdb host,
3534 we call a function which deals with both alignment and byte
3535 swapping issues. Possibly inefficient, but quite portable.
3539 Each time we are called, we increment the diecount variable, which
3540 keeps an approximate count of the number of dies processed for
3541 each compilation unit. This information is presented to the user
3542 if the info_verbose flag is set.
3547 completedieinfo (dip
, objfile
)
3548 struct dieinfo
*dip
;
3549 struct objfile
*objfile
;
3551 char *diep
; /* Current pointer into raw DIE data */
3552 char *end
; /* Terminate DIE scan here */
3553 unsigned short attr
; /* Current attribute being scanned */
3554 unsigned short form
; /* Form of the attribute */
3555 int nbytes
; /* Size of next field to read */
3559 end
= diep
+ dip
-> die_length
;
3560 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3563 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3564 diep
+= SIZEOF_ATTRIBUTE
;
3565 if ((nbytes
= attribute_size (attr
)) == -1)
3567 complain (&unknown_attribute_length
, DIE_ID
, DIE_NAME
);
3574 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3578 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3582 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3586 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3590 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3592 dip
-> has_at_stmt_list
= 1;
3595 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3597 dip
-> at_low_pc
+= baseaddr
;
3598 dip
-> has_at_low_pc
= 1;
3601 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3603 dip
-> at_high_pc
+= baseaddr
;
3606 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3609 case AT_user_def_type
:
3610 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3611 GET_UNSIGNED
, objfile
);
3614 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3616 dip
-> has_at_byte_size
= 1;
3619 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3623 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3627 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3631 dip
-> at_location
= diep
;
3633 case AT_mod_fund_type
:
3634 dip
-> at_mod_fund_type
= diep
;
3636 case AT_subscr_data
:
3637 dip
-> at_subscr_data
= diep
;
3639 case AT_mod_u_d_type
:
3640 dip
-> at_mod_u_d_type
= diep
;
3642 case AT_element_list
:
3643 dip
-> at_element_list
= diep
;
3644 dip
-> short_element_list
= 0;
3646 case AT_short_element_list
:
3647 dip
-> at_element_list
= diep
;
3648 dip
-> short_element_list
= 1;
3650 case AT_discr_value
:
3651 dip
-> at_discr_value
= diep
;
3653 case AT_string_length
:
3654 dip
-> at_string_length
= diep
;
3657 dip
-> at_name
= diep
;
3660 /* For now, ignore any "hostname:" portion, since gdb doesn't
3661 know how to deal with it. (FIXME). */
3662 dip
-> at_comp_dir
= strrchr (diep
, ':');
3663 if (dip
-> at_comp_dir
!= NULL
)
3665 dip
-> at_comp_dir
++;
3669 dip
-> at_comp_dir
= diep
;
3673 dip
-> at_producer
= diep
;
3675 case AT_start_scope
:
3676 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3679 case AT_stride_size
:
3680 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3684 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3688 dip
-> at_prototyped
= diep
;
3691 /* Found an attribute that we are unprepared to handle. However
3692 it is specifically one of the design goals of DWARF that
3693 consumers should ignore unknown attributes. As long as the
3694 form is one that we recognize (so we know how to skip it),
3695 we can just ignore the unknown attribute. */
3698 form
= FORM_FROM_ATTR (attr
);
3712 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3715 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3718 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3721 diep
+= strlen (diep
) + 1;
3724 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);
3735 target_to_host -- swap in target data to host
3739 target_to_host (char *from, int nbytes, int signextend,
3740 struct objfile *objfile)
3744 Given pointer to data in target format in FROM, a byte count for
3745 the size of the data in NBYTES, a flag indicating whether or not
3746 the data is signed in SIGNEXTEND, and a pointer to the current
3747 objfile in OBJFILE, convert the data to host format and return
3748 the converted value.
3752 FIXME: If we read data that is known to be signed, and expect to
3753 use it as signed data, then we need to explicitly sign extend the
3754 result until the bfd library is able to do this for us.
3758 static unsigned long
3759 target_to_host (from
, nbytes
, signextend
, objfile
)
3762 int signextend
; /* FIXME: Unused */
3763 struct objfile
*objfile
;
3765 unsigned long rtnval
;
3770 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3773 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3776 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3779 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3782 complain (&no_bfd_get_N
, DIE_ID
, DIE_NAME
, nbytes
);
3793 attribute_size -- compute size of data for a DWARF attribute
3797 static int attribute_size (unsigned int attr)
3801 Given a DWARF attribute in ATTR, compute the size of the first
3802 piece of data associated with this attribute and return that
3805 Returns -1 for unrecognized attributes.
3810 attribute_size (attr
)
3813 int nbytes
; /* Size of next data for this attribute */
3814 unsigned short form
; /* Form of the attribute */
3816 form
= FORM_FROM_ATTR (attr
);
3819 case FORM_STRING
: /* A variable length field is next */
3822 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3823 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3826 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3827 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3828 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3831 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3834 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3835 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3838 complain (&unknown_attribute_form
, DIE_ID
, DIE_NAME
, form
);