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. :-)
53 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
54 #include "elf/dwarf.h"
58 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
59 #define SQUAWK(stuff) dwarfwarn stuff
64 #ifndef R_FP /* FIXME */
65 #define R_FP 14 /* Kludge to get frame pointer register number */
68 typedef unsigned int DIE_REF
; /* Reference to a DIE */
71 #define GCC_PRODUCER "GNU C "
74 #ifndef GPLUS_PRODUCER
75 #define GPLUS_PRODUCER "GNU C++ "
79 #define LCC_PRODUCER "NCR C/C++ "
82 #ifndef CFRONT_PRODUCER
83 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
86 #define STREQ(a,b) (strcmp(a,b)==0)
87 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
89 /* Flags to target_to_host() that tell whether or not the data object is
90 expected to be signed. Used, for example, when fetching a signed
91 integer in the target environment which is used as a signed integer
92 in the host environment, and the two environments have different sized
93 ints. In this case, *somebody* has to sign extend the smaller sized
96 #define GET_UNSIGNED 0 /* No sign extension required */
97 #define GET_SIGNED 1 /* Sign extension required */
99 /* Defines for things which are specified in the document "DWARF Debugging
100 Information Format" published by UNIX International, Programming Languages
101 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
103 #define SIZEOF_DIE_LENGTH 4
104 #define SIZEOF_DIE_TAG 2
105 #define SIZEOF_ATTRIBUTE 2
106 #define SIZEOF_FORMAT_SPECIFIER 1
107 #define SIZEOF_FMT_FT 2
108 #define SIZEOF_LINETBL_LENGTH 4
109 #define SIZEOF_LINETBL_LINENO 4
110 #define SIZEOF_LINETBL_STMT 2
111 #define SIZEOF_LINETBL_DELTA 4
112 #define SIZEOF_LOC_ATOM_CODE 1
114 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
116 /* Macros that return the sizes of various types of data in the target
119 FIXME: Currently these are just compile time constants (as they are in
120 other parts of gdb as well). They need to be able to get the right size
121 either from the bfd or possibly from the DWARF info. It would be nice if
122 the DWARF producer inserted DIES that describe the fundamental types in
123 the target environment into the DWARF info, similar to the way dbx stabs
124 producers produce information about their fundamental types. */
126 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
127 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
129 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
130 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
131 However, the Issue 2 DWARF specification from AT&T defines it as
132 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
133 For backwards compatibility with the AT&T compiler produced executables
134 we define AT_short_element_list for this variant. */
136 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
138 /* External variables referenced. */
140 extern int info_verbose
; /* From main.c; nonzero => verbose */
141 extern char *warning_pre_print
; /* From utils.c */
143 /* The DWARF debugging information consists of two major pieces,
144 one is a block of DWARF Information Entries (DIE's) and the other
145 is a line number table. The "struct dieinfo" structure contains
146 the information for a single DIE, the one currently being processed.
148 In order to make it easier to randomly access the attribute fields
149 of the current DIE, which are specifically unordered within the DIE,
150 each DIE is scanned and an instance of the "struct dieinfo"
151 structure is initialized.
153 Initialization is done in two levels. The first, done by basicdieinfo(),
154 just initializes those fields that are vital to deciding whether or not
155 to use this DIE, how to skip past it, etc. The second, done by the
156 function completedieinfo(), fills in the rest of the information.
158 Attributes which have block forms are not interpreted at the time
159 the DIE is scanned, instead we just save pointers to the start
160 of their value fields.
162 Some fields have a flag <name>_p that is set when the value of the
163 field is valid (I.E. we found a matching attribute in the DIE). Since
164 we may want to test for the presence of some attributes in the DIE,
165 such as AT_low_pc, without restricting the values of the field,
166 we need someway to note that we found such an attribute.
173 char * die
; /* Pointer to the raw DIE data */
174 unsigned long die_length
; /* Length of the raw DIE data */
175 DIE_REF die_ref
; /* Offset of this DIE */
176 unsigned short die_tag
; /* Tag for this DIE */
177 unsigned long at_padding
;
178 unsigned long at_sibling
;
181 unsigned short at_fund_type
;
182 BLOCK
* at_mod_fund_type
;
183 unsigned long at_user_def_type
;
184 BLOCK
* at_mod_u_d_type
;
185 unsigned short at_ordering
;
186 BLOCK
* at_subscr_data
;
187 unsigned long at_byte_size
;
188 unsigned short at_bit_offset
;
189 unsigned long at_bit_size
;
190 BLOCK
* at_element_list
;
191 unsigned long at_stmt_list
;
192 unsigned long at_low_pc
;
193 unsigned long at_high_pc
;
194 unsigned long at_language
;
195 unsigned long at_member
;
196 unsigned long at_discr
;
197 BLOCK
* at_discr_value
;
198 unsigned short at_visibility
;
199 unsigned long at_import
;
200 BLOCK
* at_string_length
;
203 unsigned long at_frame_base
;
204 unsigned long at_start_scope
;
205 unsigned long at_stride_size
;
206 unsigned long at_src_info
;
207 char * at_prototyped
;
208 unsigned int has_at_low_pc
:1;
209 unsigned int has_at_stmt_list
:1;
210 unsigned int short_element_list
:1;
213 static int diecount
; /* Approximate count of dies for compilation unit */
214 static struct dieinfo
*curdie
; /* For warnings and such */
216 static char *dbbase
; /* Base pointer to dwarf info */
217 static int dbroff
; /* Relative offset from start of .debug section */
218 static char *lnbase
; /* Base pointer to line section */
219 static int isreg
; /* Kludge to identify register variables */
220 static int offreg
; /* Kludge to identify basereg references */
222 /* This value is added to each symbol value. FIXME: Generalize to
223 the section_offsets structure used by dbxread. */
224 static CORE_ADDR baseaddr
; /* Add to each symbol value */
226 /* The section offsets used in the current psymtab or symtab. FIXME,
227 only used to pass one value (baseaddr) at the moment. */
228 static struct section_offsets
*base_section_offsets
;
230 /* Each partial symbol table entry contains a pointer to private data for the
231 read_symtab() function to use when expanding a partial symbol table entry
232 to a full symbol table entry. For DWARF debugging info, this data is
233 contained in the following structure and macros are provided for easy
234 access to the members given a pointer to a partial symbol table entry.
236 dbfoff Always the absolute file offset to the start of the ".debug"
237 section for the file containing the DIE's being accessed.
239 dbroff Relative offset from the start of the ".debug" access to the
240 first DIE to be accessed. When building the partial symbol
241 table, this value will be zero since we are accessing the
242 entire ".debug" section. When expanding a partial symbol
243 table entry, this value will be the offset to the first
244 DIE for the compilation unit containing the symbol that
245 triggers the expansion.
247 dblength The size of the chunk of DIE's being examined, in bytes.
249 lnfoff The absolute file offset to the line table fragment. Ignored
250 when building partial symbol tables, but used when expanding
251 them, and contains the absolute file offset to the fragment
252 of the ".line" section containing the line numbers for the
253 current compilation unit.
257 int dbfoff
; /* Absolute file offset to start of .debug section */
258 int dbroff
; /* Relative offset from start of .debug section */
259 int dblength
; /* Size of the chunk of DIE's being examined */
260 int lnfoff
; /* Absolute file offset to line table fragment */
263 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
264 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
265 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
266 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
268 /* The generic symbol table building routines have separate lists for
269 file scope symbols and all all other scopes (local scopes). So
270 we need to select the right one to pass to add_symbol_to_list().
271 We do it by keeping a pointer to the correct list in list_in_scope.
273 FIXME: The original dwarf code just treated the file scope as the first
274 local scope, and all other local scopes as nested local scopes, and worked
275 fine. Check to see if we really need to distinguish these in buildsym.c */
277 struct pending
**list_in_scope
= &file_symbols
;
279 /* DIES which have user defined types or modified user defined types refer to
280 other DIES for the type information. Thus we need to associate the offset
281 of a DIE for a user defined type with a pointer to the type information.
283 Originally this was done using a simple but expensive algorithm, with an
284 array of unsorted structures, each containing an offset/type-pointer pair.
285 This array was scanned linearly each time a lookup was done. The result
286 was that gdb was spending over half it's startup time munging through this
287 array of pointers looking for a structure that had the right offset member.
289 The second attempt used the same array of structures, but the array was
290 sorted using qsort each time a new offset/type was recorded, and a binary
291 search was used to find the type pointer for a given DIE offset. This was
292 even slower, due to the overhead of sorting the array each time a new
293 offset/type pair was entered.
295 The third attempt uses a fixed size array of type pointers, indexed by a
296 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
297 we can divide any DIE offset by 4 to obtain a unique index into this fixed
298 size array. Since each element is a 4 byte pointer, it takes exactly as
299 much memory to hold this array as to hold the DWARF info for a given
300 compilation unit. But it gets freed as soon as we are done with it. */
302 static struct type
**utypes
; /* Pointer to array of user type pointers */
303 static int numutypes
; /* Max number of user type pointers */
305 /* Forward declarations of static functions so we don't have to worry
306 about ordering within this file. */
309 attribute_size
PARAMS ((unsigned int));
312 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
315 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
318 handle_producer
PARAMS ((char *));
321 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
324 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
327 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
334 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
337 scan_compilation_units
PARAMS ((char *, char *, char *, unsigned int,
338 unsigned int, struct objfile
*));
341 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
344 init_psymbol_list
PARAMS ((struct objfile
*, int));
347 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
350 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
353 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
356 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
358 static struct symtab
*
359 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
362 process_dies
PARAMS ((char *, char *, struct objfile
*));
365 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
369 decode_array_element_type
PARAMS ((char *));
372 decode_subscr_data
PARAMS ((char *, char *));
375 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
378 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
381 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
384 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
387 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
390 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
393 decode_line_numbers
PARAMS ((char *));
396 decode_die_type
PARAMS ((struct dieinfo
*));
399 decode_mod_fund_type
PARAMS ((char *));
402 decode_mod_u_d_type
PARAMS ((char *));
405 decode_modified_type
PARAMS ((char *, unsigned int, int));
408 decode_fund_type
PARAMS ((unsigned int));
411 create_name
PARAMS ((char *, struct obstack
*));
414 lookup_utype
PARAMS ((DIE_REF
));
417 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
419 static struct symbol
*
420 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
423 locval
PARAMS ((char *));
426 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
433 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
437 void dwarf_build_psymtabs (int desc, char *filename,
438 struct section_offsets *section_offsets,
439 int mainline, unsigned int dbfoff, unsigned int dbsize,
440 unsigned int lnoffset, unsigned int lnsize,
441 struct objfile *objfile)
445 This function is called upon to build partial symtabs from files
446 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
448 It is passed a file descriptor for an open file containing the DIES
449 and line number information, the corresponding filename for that
450 file, a base address for relocating the symbols, a flag indicating
451 whether or not this debugging information is from a "main symbol
452 table" rather than a shared library or dynamically linked file,
453 and file offset/size pairs for the DIE information and line number
463 dwarf_build_psymtabs (desc
, filename
, section_offsets
, mainline
, dbfoff
, dbsize
,
464 lnoffset
, lnsize
, objfile
)
467 struct section_offsets
*section_offsets
;
471 unsigned int lnoffset
;
473 struct objfile
*objfile
;
475 struct cleanup
*back_to
;
477 current_objfile
= objfile
;
478 dbbase
= xmalloc (dbsize
);
480 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
481 (read (desc
, dbbase
, dbsize
) != dbsize
))
484 error ("can't read DWARF data from '%s'", filename
);
486 back_to
= make_cleanup (free
, dbbase
);
488 /* If we are reinitializing, or if we have never loaded syms yet, init.
489 Since we have no idea how many DIES we are looking at, we just guess
490 some arbitrary value. */
492 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
493 objfile
-> static_psymbols
.size
== 0)
495 init_psymbol_list (objfile
, 1024);
498 /* Save the relocation factor where everybody can see it. */
500 base_section_offsets
= section_offsets
;
501 baseaddr
= ANOFFSET (section_offsets
, 0);
503 /* Follow the compilation unit sibling chain, building a partial symbol
504 table entry for each one. Save enough information about each compilation
505 unit to locate the full DWARF information later. */
507 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
508 dbfoff
, lnoffset
, objfile
);
510 do_cleanups (back_to
);
511 current_objfile
= NULL
;
519 record_minimal_symbol -- add entry to gdb's minimal symbol table
523 static void record_minimal_symbol (char *name, CORE_ADDR address,
524 enum minimal_symbol_type ms_type,
525 struct objfile *objfile)
529 Given a pointer to the name of a symbol that should be added to the
530 minimal symbol table, and the address associated with that
531 symbol, records this information for later use in building the
532 minimal symbol table.
537 record_minimal_symbol (name
, address
, ms_type
, objfile
)
540 enum minimal_symbol_type ms_type
;
541 struct objfile
*objfile
;
543 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
544 prim_record_minimal_symbol (name
, address
, ms_type
);
551 dwarfwarn -- issue a DWARF related warning
555 Issue warnings about DWARF related things that aren't serious enough
556 to warrant aborting with an error, but should not be ignored either.
557 This includes things like detectable corruption in DIE's, missing
558 DIE's, unimplemented features, etc.
560 In general, running across tags or attributes that we don't recognize
561 is not considered to be a problem and we should not issue warnings
566 We mostly follow the example of the error() routine, but without
567 returning to command level. It is arguable about whether warnings
568 should be issued at all, and if so, where they should go (stdout or
571 We assume that curdie is valid and contains at least the basic
572 information for the DIE where the problem was noticed.
583 fmt
= va_arg (ap
, char *);
585 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
586 if (curdie
-> at_name
)
588 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
590 vfprintf (stderr
, fmt
, ap
);
591 fprintf (stderr
, "\n");
600 read_lexical_block_scope -- process all dies in a lexical block
604 static void read_lexical_block_scope (struct dieinfo *dip,
605 char *thisdie, char *enddie)
609 Process all the DIES contained within a lexical block scope.
610 Start a new scope, process the dies, and then close the scope.
615 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
619 struct objfile
*objfile
;
621 register struct context_stack
*new;
623 push_context (0, dip
-> at_low_pc
);
624 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
625 new = pop_context ();
626 if (local_symbols
!= NULL
)
628 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
629 dip
-> at_high_pc
, objfile
);
631 local_symbols
= new -> locals
;
638 lookup_utype -- look up a user defined type from die reference
642 static type *lookup_utype (DIE_REF die_ref)
646 Given a DIE reference, lookup the user defined type associated with
647 that DIE, if it has been registered already. If not registered, then
648 return NULL. Alloc_utype() can be called to register an empty
649 type for this reference, which will be filled in later when the
650 actual referenced DIE is processed.
654 lookup_utype (die_ref
)
657 struct type
*type
= NULL
;
660 utypeidx
= (die_ref
- dbroff
) / 4;
661 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
663 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
667 type
= *(utypes
+ utypeidx
);
677 alloc_utype -- add a user defined type for die reference
681 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
685 Given a die reference DIE_REF, and a possible pointer to a user
686 defined type UTYPEP, register that this reference has a user
687 defined type and either use the specified type in UTYPEP or
688 make a new empty type that will be filled in later.
690 We should only be called after calling lookup_utype() to verify that
691 there is not currently a type registered for DIE_REF.
695 alloc_utype (die_ref
, utypep
)
702 utypeidx
= (die_ref
- dbroff
) / 4;
703 typep
= utypes
+ utypeidx
;
704 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
706 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
707 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
709 else if (*typep
!= NULL
)
712 SQUAWK (("internal error: dup user type allocation"));
718 utypep
= alloc_type (current_objfile
);
729 decode_die_type -- return a type for a specified die
733 static struct type *decode_die_type (struct dieinfo *dip)
737 Given a pointer to a die information structure DIP, decode the
738 type of the die and return a pointer to the decoded type. All
739 dies without specific types default to type int.
743 decode_die_type (dip
)
746 struct type
*type
= NULL
;
748 if (dip
-> at_fund_type
!= 0)
750 type
= decode_fund_type (dip
-> at_fund_type
);
752 else if (dip
-> at_mod_fund_type
!= NULL
)
754 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
756 else if (dip
-> at_user_def_type
)
758 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
760 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
763 else if (dip
-> at_mod_u_d_type
)
765 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
769 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
778 struct_type -- compute and return the type for a struct or union
782 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
783 char *enddie, struct objfile *objfile)
787 Given pointer to a die information structure for a die which
788 defines a union or structure (and MUST define one or the other),
789 and pointers to the raw die data that define the range of dies which
790 define the members, compute and return the user defined type for the
795 struct_type (dip
, thisdie
, enddie
, objfile
)
799 struct objfile
*objfile
;
803 struct nextfield
*next
;
806 struct nextfield
*list
= NULL
;
807 struct nextfield
*new;
814 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
816 /* No forward references created an empty type, so install one now */
817 type
= alloc_utype (dip
-> die_ref
, NULL
);
819 INIT_CPLUS_SPECIFIC(type
);
820 switch (dip
-> die_tag
)
822 case TAG_structure_type
:
823 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
827 TYPE_CODE (type
) = TYPE_CODE_UNION
;
831 /* Should never happen */
832 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
834 SQUAWK (("missing structure or union tag"));
837 /* Some compilers try to be helpful by inventing "fake" names for
838 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
839 Thanks, but no thanks... */
840 if (dip
-> at_name
!= NULL
841 && *dip
-> at_name
!= '~'
842 && *dip
-> at_name
!= '.')
844 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
845 tpart1
, " ", dip
-> at_name
);
847 if (dip
-> at_byte_size
!= 0)
849 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
851 thisdie
+= dip
-> die_length
;
852 while (thisdie
< enddie
)
854 basicdieinfo (&mbr
, thisdie
, objfile
);
855 completedieinfo (&mbr
, objfile
);
856 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
860 else if (mbr
.at_sibling
!= 0)
862 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
866 nextdie
= thisdie
+ mbr
.die_length
;
871 /* Get space to record the next field's data. */
872 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
877 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
878 &objfile
-> type_obstack
);
879 list
-> field
.type
= decode_die_type (&mbr
);
880 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
881 /* Handle bit fields. */
882 list
-> field
.bitsize
= mbr
.at_bit_size
;
884 /* For big endian bits, the at_bit_offset gives the additional
885 bit offset from the MSB of the containing anonymous object to
886 the MSB of the field. We don't have to do anything special
887 since we don't need to know the size of the anonymous object. */
888 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
890 /* For little endian bits, we need to have a non-zero at_bit_size,
891 so that we know we are in fact dealing with a bitfield. Compute
892 the bit offset to the MSB of the anonymous object, subtract off
893 the number of bits from the MSB of the field to the MSB of the
894 object, and then subtract off the number of bits of the field
895 itself. The result is the bit offset of the LSB of the field. */
896 if (mbr
.at_bit_size
> 0)
898 list
-> field
.bitpos
+=
899 mbr
.at_byte_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
905 process_dies (thisdie
, nextdie
, objfile
);
910 /* Now create the vector of fields, and record how big it is. We may
911 not even have any fields, if this DIE was generated due to a reference
912 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
913 set, which clues gdb in to the fact that it needs to search elsewhere
914 for the full structure definition. */
917 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
921 TYPE_NFIELDS (type
) = nfields
;
922 TYPE_FIELDS (type
) = (struct field
*)
923 obstack_alloc (&objfile
-> type_obstack
,
924 sizeof (struct field
) * nfields
);
925 /* Copy the saved-up fields into the field vector. */
926 for (n
= nfields
; list
; list
= list
-> next
)
928 TYPE_FIELD (type
, --n
) = list
-> field
;
938 read_structure_scope -- process all dies within struct or union
942 static void read_structure_scope (struct dieinfo *dip,
943 char *thisdie, char *enddie, struct objfile *objfile)
947 Called when we find the DIE that starts a structure or union
948 scope (definition) to process all dies that define the members
949 of the structure or union. DIP is a pointer to the die info
950 struct for the DIE that names the structure or union.
954 Note that we need to call struct_type regardless of whether or not
955 the DIE has an at_name attribute, since it might be an anonymous
956 structure or union. This gets the type entered into our set of
959 However, if the structure is incomplete (an opaque struct/union)
960 then suppress creating a symbol table entry for it since gdb only
961 wants to find the one with the complete definition. Note that if
962 it is complete, we just call new_symbol, which does it's own
963 checking about whether the struct/union is anonymous or not (and
964 suppresses creating a symbol table entry itself).
969 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
973 struct objfile
*objfile
;
978 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
979 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
981 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
983 SYMBOL_TYPE (sym
) = type
;
992 decode_array_element_type -- decode type of the array elements
996 static struct type *decode_array_element_type (char *scan, char *end)
1000 As the last step in decoding the array subscript information for an
1001 array DIE, we need to decode the type of the array elements. We are
1002 passed a pointer to this last part of the subscript information and
1003 must return the appropriate type. If the type attribute is not
1004 recognized, just warn about the problem and return type int.
1007 static struct type
*
1008 decode_array_element_type (scan
)
1013 unsigned short attribute
;
1014 unsigned short fundtype
;
1017 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1019 scan
+= SIZEOF_ATTRIBUTE
;
1020 if ((nbytes
= attribute_size (attribute
)) == -1)
1022 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1023 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1030 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1032 typep
= decode_fund_type (fundtype
);
1034 case AT_mod_fund_type
:
1035 typep
= decode_mod_fund_type (scan
);
1037 case AT_user_def_type
:
1038 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1040 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1042 typep
= alloc_utype (die_ref
, NULL
);
1045 case AT_mod_u_d_type
:
1046 typep
= decode_mod_u_d_type (scan
);
1049 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1050 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1061 decode_subscr_data -- decode array subscript and element type data
1065 static struct type *decode_subscr_data (char *scan, char *end)
1069 The array subscripts and the data type of the elements of an
1070 array are described by a list of data items, stored as a block
1071 of contiguous bytes. There is a data item describing each array
1072 dimension, and a final data item describing the element type.
1073 The data items are ordered the same as their appearance in the
1074 source (I.E. leftmost dimension first, next to leftmost second,
1077 We are passed a pointer to the start of the block of bytes
1078 containing the data items, and a pointer to the first byte past
1079 the data. This function decodes the data and returns a type.
1082 FIXME: This code only implements the forms currently used
1083 by the AT&T and GNU C compilers.
1085 The end pointer is supplied for error checking, maybe we should
1089 static struct type
*
1090 decode_subscr_data (scan
, end
)
1094 struct type
*typep
= NULL
;
1095 struct type
*nexttype
;
1096 unsigned int format
;
1097 unsigned short fundtype
;
1098 unsigned long lowbound
;
1099 unsigned long highbound
;
1102 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1104 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1108 typep
= decode_array_element_type (scan
);
1111 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1113 scan
+= SIZEOF_FMT_FT
;
1114 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1115 && fundtype
!= FT_unsigned_integer
)
1117 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1122 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1123 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1126 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1129 nexttype
= decode_subscr_data (scan
, end
);
1130 if (nexttype
!= NULL
)
1132 typep
= alloc_type (current_objfile
);
1133 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1134 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1135 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1136 TYPE_TARGET_TYPE (typep
) = nexttype
;
1147 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1150 SQUAWK (("unknown array subscript format %x", format
));
1160 dwarf_read_array_type -- read TAG_array_type DIE
1164 static void dwarf_read_array_type (struct dieinfo *dip)
1168 Extract all information from a TAG_array_type DIE and add to
1169 the user defined type vector.
1173 dwarf_read_array_type (dip
)
1174 struct dieinfo
*dip
;
1180 unsigned short blocksz
;
1183 if (dip
-> at_ordering
!= ORD_row_major
)
1185 /* FIXME: Can gdb even handle column major arrays? */
1186 SQUAWK (("array not row major; not handled correctly"));
1188 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1190 nbytes
= attribute_size (AT_subscr_data
);
1191 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1192 subend
= sub
+ nbytes
+ blocksz
;
1194 type
= decode_subscr_data (sub
, subend
);
1197 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1199 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1201 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1202 TYPE_TARGET_TYPE (utype
) =
1203 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1204 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1208 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1210 alloc_utype (dip
-> die_ref
, type
);
1214 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1215 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1216 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1226 read_tag_pointer_type -- read TAG_pointer_type DIE
1230 static void read_tag_pointer_type (struct dieinfo *dip)
1234 Extract all information from a TAG_pointer_type DIE and add to
1235 the user defined type vector.
1239 read_tag_pointer_type (dip
)
1240 struct dieinfo
*dip
;
1245 type
= decode_die_type (dip
);
1246 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1248 utype
= lookup_pointer_type (type
);
1249 alloc_utype (dip
-> die_ref
, utype
);
1253 TYPE_TARGET_TYPE (utype
) = type
;
1254 TYPE_POINTER_TYPE (type
) = utype
;
1256 /* We assume the machine has only one representation for pointers! */
1257 /* FIXME: This confuses host<->target data representations, and is a
1258 poor assumption besides. */
1260 TYPE_LENGTH (utype
) = sizeof (char *);
1261 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1269 read_subroutine_type -- process TAG_subroutine_type dies
1273 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1278 Handle DIES due to C code like:
1281 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1287 The parameter DIES are currently ignored. See if gdb has a way to
1288 include this info in it's type system, and decode them if so. Is
1289 this what the type structure's "arg_types" field is for? (FIXME)
1293 read_subroutine_type (dip
, thisdie
, enddie
)
1294 struct dieinfo
*dip
;
1298 struct type
*type
; /* Type that this function returns */
1299 struct type
*ftype
; /* Function that returns above type */
1301 /* Decode the type that this subroutine returns */
1303 type
= decode_die_type (dip
);
1305 /* Check to see if we already have a partially constructed user
1306 defined type for this DIE, from a forward reference. */
1308 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1310 /* This is the first reference to one of these types. Make
1311 a new one and place it in the user defined types. */
1312 ftype
= lookup_function_type (type
);
1313 alloc_utype (dip
-> die_ref
, ftype
);
1317 /* We have an existing partially constructed type, so bash it
1318 into the correct type. */
1319 TYPE_TARGET_TYPE (ftype
) = type
;
1320 TYPE_FUNCTION_TYPE (type
) = ftype
;
1321 TYPE_LENGTH (ftype
) = 1;
1322 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1330 read_enumeration -- process dies which define an enumeration
1334 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1335 char *enddie, struct objfile *objfile)
1339 Given a pointer to a die which begins an enumeration, process all
1340 the dies that define the members of the enumeration.
1344 Note that we need to call enum_type regardless of whether or not we
1345 have a symbol, since we might have an enum without a tag name (thus
1346 no symbol for the tagname).
1350 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1351 struct dieinfo
*dip
;
1354 struct objfile
*objfile
;
1359 type
= enum_type (dip
, objfile
);
1360 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
1362 SYMBOL_TYPE (sym
) = type
;
1370 enum_type -- decode and return a type for an enumeration
1374 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1378 Given a pointer to a die information structure for the die which
1379 starts an enumeration, process all the dies that define the members
1380 of the enumeration and return a type pointer for the enumeration.
1382 At the same time, for each member of the enumeration, create a
1383 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1384 and give it the type of the enumeration itself.
1388 Note that the DWARF specification explicitly mandates that enum
1389 constants occur in reverse order from the source program order,
1390 for "consistency" and because this ordering is easier for many
1391 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1392 Entries). Because gdb wants to see the enum members in program
1393 source order, we have to ensure that the order gets reversed while
1394 we are processing them.
1397 static struct type
*
1398 enum_type (dip
, objfile
)
1399 struct dieinfo
*dip
;
1400 struct objfile
*objfile
;
1404 struct nextfield
*next
;
1407 struct nextfield
*list
= NULL
;
1408 struct nextfield
*new;
1413 unsigned short blocksz
;
1417 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1419 /* No forward references created an empty type, so install one now */
1420 type
= alloc_utype (dip
-> die_ref
, NULL
);
1422 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1423 /* Some compilers try to be helpful by inventing "fake" names for
1424 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1425 Thanks, but no thanks... */
1426 if (dip
-> at_name
!= NULL
1427 && *dip
-> at_name
!= '~'
1428 && *dip
-> at_name
!= '.')
1430 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1431 " ", dip
-> at_name
);
1433 if (dip
-> at_byte_size
!= 0)
1435 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1437 if ((scan
= dip
-> at_element_list
) != NULL
)
1439 if (dip
-> short_element_list
)
1441 nbytes
= attribute_size (AT_short_element_list
);
1445 nbytes
= attribute_size (AT_element_list
);
1447 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1448 listend
= scan
+ nbytes
+ blocksz
;
1450 while (scan
< listend
)
1452 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1455 list
-> field
.type
= NULL
;
1456 list
-> field
.bitsize
= 0;
1457 list
-> field
.bitpos
=
1458 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1460 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1461 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1462 &objfile
-> type_obstack
);
1463 scan
+= strlen (scan
) + 1;
1465 /* Handcraft a new symbol for this enum member. */
1466 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1467 sizeof (struct symbol
));
1468 memset (sym
, 0, sizeof (struct symbol
));
1469 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1470 &objfile
->symbol_obstack
);
1471 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1472 SYMBOL_CLASS (sym
) = LOC_CONST
;
1473 SYMBOL_TYPE (sym
) = type
;
1474 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1475 add_symbol_to_list (sym
, list_in_scope
);
1477 /* Now create the vector of fields, and record how big it is. This is
1478 where we reverse the order, by pulling the members off the list in
1479 reverse order from how they were inserted. If we have no fields
1480 (this is apparently possible in C++) then skip building a field
1484 TYPE_NFIELDS (type
) = nfields
;
1485 TYPE_FIELDS (type
) = (struct field
*)
1486 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1487 /* Copy the saved-up fields into the field vector. */
1488 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1490 TYPE_FIELD (type
, n
++) = list
-> field
;
1501 read_func_scope -- process all dies within a function scope
1505 Process all dies within a given function scope. We are passed
1506 a die information structure pointer DIP for the die which
1507 starts the function scope, and pointers into the raw die data
1508 that define the dies within the function scope.
1510 For now, we ignore lexical block scopes within the function.
1511 The problem is that AT&T cc does not define a DWARF lexical
1512 block scope for the function itself, while gcc defines a
1513 lexical block scope for the function. We need to think about
1514 how to handle this difference, or if it is even a problem.
1519 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1520 struct dieinfo
*dip
;
1523 struct objfile
*objfile
;
1525 register struct context_stack
*new;
1527 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1528 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1530 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1531 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1533 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1535 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1536 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1538 new = push_context (0, dip
-> at_low_pc
);
1539 new -> name
= new_symbol (dip
, objfile
);
1540 list_in_scope
= &local_symbols
;
1541 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1542 new = pop_context ();
1543 /* Make a block for the local symbols within. */
1544 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1545 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1546 list_in_scope
= &file_symbols
;
1554 handle_producer -- process the AT_producer attribute
1558 Perform any operations that depend on finding a particular
1559 AT_producer attribute.
1564 handle_producer (producer
)
1568 /* If this compilation unit was compiled with g++ or gcc, then set the
1569 processing_gcc_compilation flag. */
1571 processing_gcc_compilation
=
1572 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1573 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1575 /* Select a demangling style if we can identify the producer and if
1576 the current style is auto. We leave the current style alone if it
1577 is not auto. We also leave the demangling style alone if we find a
1578 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1580 #if 1 /* Works, but is experimental. -fnf */
1581 if (current_demangling_style
== auto_demangling
)
1583 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1585 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1587 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1589 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1591 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1593 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1604 read_file_scope -- process all dies within a file scope
1608 Process all dies within a given file scope. We are passed a
1609 pointer to the die information structure for the die which
1610 starts the file scope, and pointers into the raw die data which
1611 mark the range of dies within the file scope.
1613 When the partial symbol table is built, the file offset for the line
1614 number table for each compilation unit is saved in the partial symbol
1615 table entry for that compilation unit. As the symbols for each
1616 compilation unit are read, the line number table is read into memory
1617 and the variable lnbase is set to point to it. Thus all we have to
1618 do is use lnbase to access the line number table for the current
1623 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1624 struct dieinfo
*dip
;
1627 struct objfile
*objfile
;
1629 struct cleanup
*back_to
;
1630 struct symtab
*symtab
;
1632 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1633 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1635 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1636 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1638 if (dip
-> at_producer
!= NULL
)
1640 handle_producer (dip
-> at_producer
);
1642 numutypes
= (enddie
- thisdie
) / 4;
1643 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1644 back_to
= make_cleanup (free
, utypes
);
1645 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1646 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1647 decode_line_numbers (lnbase
);
1648 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1649 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1650 /* FIXME: The following may need to be expanded for other languages */
1651 switch (dip
-> at_language
)
1655 symtab
-> language
= language_c
;
1657 case LANG_C_PLUS_PLUS
:
1658 symtab
-> language
= language_cplus
;
1663 do_cleanups (back_to
);
1672 process_dies -- process a range of DWARF Information Entries
1676 static void process_dies (char *thisdie, char *enddie,
1677 struct objfile *objfile)
1681 Process all DIE's in a specified range. May be (and almost
1682 certainly will be) called recursively.
1686 process_dies (thisdie
, enddie
, objfile
)
1689 struct objfile
*objfile
;
1694 while (thisdie
< enddie
)
1696 basicdieinfo (&di
, thisdie
, objfile
);
1697 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1701 else if (di
.die_tag
== TAG_padding
)
1703 nextdie
= thisdie
+ di
.die_length
;
1707 completedieinfo (&di
, objfile
);
1708 if (di
.at_sibling
!= 0)
1710 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1714 nextdie
= thisdie
+ di
.die_length
;
1718 case TAG_compile_unit
:
1719 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1721 case TAG_global_subroutine
:
1722 case TAG_subroutine
:
1723 if (di
.has_at_low_pc
)
1725 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1728 case TAG_lexical_block
:
1729 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1731 case TAG_structure_type
:
1732 case TAG_union_type
:
1733 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1735 case TAG_enumeration_type
:
1736 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1738 case TAG_subroutine_type
:
1739 read_subroutine_type (&di
, thisdie
, nextdie
);
1741 case TAG_array_type
:
1742 dwarf_read_array_type (&di
);
1744 case TAG_pointer_type
:
1745 read_tag_pointer_type (&di
);
1748 new_symbol (&di
, objfile
);
1760 decode_line_numbers -- decode a line number table fragment
1764 static void decode_line_numbers (char *tblscan, char *tblend,
1765 long length, long base, long line, long pc)
1769 Translate the DWARF line number information to gdb form.
1771 The ".line" section contains one or more line number tables, one for
1772 each ".line" section from the objects that were linked.
1774 The AT_stmt_list attribute for each TAG_source_file entry in the
1775 ".debug" section contains the offset into the ".line" section for the
1776 start of the table for that file.
1778 The table itself has the following structure:
1780 <table length><base address><source statement entry>
1781 4 bytes 4 bytes 10 bytes
1783 The table length is the total size of the table, including the 4 bytes
1784 for the length information.
1786 The base address is the address of the first instruction generated
1787 for the source file.
1789 Each source statement entry has the following structure:
1791 <line number><statement position><address delta>
1792 4 bytes 2 bytes 4 bytes
1794 The line number is relative to the start of the file, starting with
1797 The statement position either -1 (0xFFFF) or the number of characters
1798 from the beginning of the line to the beginning of the statement.
1800 The address delta is the difference between the base address and
1801 the address of the first instruction for the statement.
1803 Note that we must copy the bytes from the packed table to our local
1804 variables before attempting to use them, to avoid alignment problems
1805 on some machines, particularly RISC processors.
1809 Does gdb expect the line numbers to be sorted? They are now by
1810 chance/luck, but are not required to be. (FIXME)
1812 The line with number 0 is unused, gdb apparently can discover the
1813 span of the last line some other way. How? (FIXME)
1817 decode_line_numbers (linetable
)
1822 unsigned long length
;
1827 if (linetable
!= NULL
)
1829 tblscan
= tblend
= linetable
;
1830 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1832 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1834 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1835 GET_UNSIGNED
, current_objfile
);
1836 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1838 while (tblscan
< tblend
)
1840 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1842 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1843 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1845 tblscan
+= SIZEOF_LINETBL_DELTA
;
1849 record_line (current_subfile
, line
, pc
);
1859 locval -- compute the value of a location attribute
1863 static int locval (char *loc)
1867 Given pointer to a string of bytes that define a location, compute
1868 the location and return the value.
1870 When computing values involving the current value of the frame pointer,
1871 the value zero is used, which results in a value relative to the frame
1872 pointer, rather than the absolute value. This is what GDB wants
1875 When the result is a register number, the global isreg flag is set,
1876 otherwise it is cleared. This is a kludge until we figure out a better
1877 way to handle the problem. Gdb's design does not mesh well with the
1878 DWARF notion of a location computing interpreter, which is a shame
1879 because the flexibility goes unused.
1883 Note that stack[0] is unused except as a default error return.
1884 Note that stack overflow is not yet handled.
1891 unsigned short nbytes
;
1892 unsigned short locsize
;
1893 auto long stack
[64];
1900 nbytes
= attribute_size (AT_location
);
1901 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
1903 end
= loc
+ locsize
;
1908 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
1911 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
1913 loc
+= SIZEOF_LOC_ATOM_CODE
;
1914 switch (loc_atom_code
)
1921 /* push register (number) */
1922 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1923 GET_UNSIGNED
, current_objfile
);
1924 loc
+= loc_value_size
;
1928 /* push value of register (number) */
1929 /* Actually, we compute the value as if register has 0 */
1931 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
1933 loc
+= loc_value_size
;
1936 stack
[++stacki
] = 0;
1940 stack
[++stacki
] = 0;
1941 SQUAWK (("BASEREG %d not handled!", regno
));
1945 /* push address (relocated address) */
1946 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1947 GET_UNSIGNED
, current_objfile
);
1948 loc
+= loc_value_size
;
1951 /* push constant (number) FIXME: signed or unsigned! */
1952 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1953 GET_SIGNED
, current_objfile
);
1954 loc
+= loc_value_size
;
1957 /* pop, deref and push 2 bytes (as a long) */
1958 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
1960 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1961 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
1963 case OP_ADD
: /* pop top 2 items, add, push result */
1964 stack
[stacki
- 1] += stack
[stacki
];
1969 return (stack
[stacki
]);
1976 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1980 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1984 When expanding a partial symbol table entry to a full symbol table
1985 entry, this is the function that gets called to read in the symbols
1986 for the compilation unit.
1988 Returns a pointer to the newly constructed symtab (which is now
1989 the new first one on the objfile's symtab list).
1992 static struct symtab
*
1993 read_ofile_symtab (pst
)
1994 struct partial_symtab
*pst
;
1996 struct cleanup
*back_to
;
1997 unsigned long lnsize
;
2000 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2002 abfd
= pst
-> objfile
-> obfd
;
2003 current_objfile
= pst
-> objfile
;
2005 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2006 unit, seek to the location in the file, and read in all the DIE's. */
2009 dbbase
= xmalloc (DBLENGTH(pst
));
2010 dbroff
= DBROFF(pst
);
2011 foffset
= DBFOFF(pst
) + dbroff
;
2012 base_section_offsets
= pst
->section_offsets
;
2013 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2014 if (bfd_seek (abfd
, foffset
, 0) ||
2015 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2018 error ("can't read DWARF data");
2020 back_to
= make_cleanup (free
, dbbase
);
2022 /* If there is a line number table associated with this compilation unit
2023 then read the size of this fragment in bytes, from the fragment itself.
2024 Allocate a buffer for the fragment and read it in for future
2030 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2031 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2032 sizeof (lnsizedata
)))
2034 error ("can't read DWARF line number table size");
2036 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2037 GET_UNSIGNED
, pst
-> objfile
);
2038 lnbase
= xmalloc (lnsize
);
2039 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2040 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2043 error ("can't read DWARF line numbers");
2045 make_cleanup (free
, lnbase
);
2048 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
2049 do_cleanups (back_to
);
2050 current_objfile
= NULL
;
2051 return (pst
-> objfile
-> symtabs
);
2058 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2062 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2066 Called once for each partial symbol table entry that needs to be
2067 expanded into a full symbol table entry.
2072 psymtab_to_symtab_1 (pst
)
2073 struct partial_symtab
*pst
;
2076 struct cleanup
*old_chain
;
2082 warning ("psymtab for %s already read in. Shouldn't happen.",
2087 /* Read in all partial symtabs on which this one is dependent */
2088 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2090 if (!pst
-> dependencies
[i
] -> readin
)
2092 /* Inform about additional files that need to be read in. */
2095 fputs_filtered (" ", stdout
);
2097 fputs_filtered ("and ", stdout
);
2099 printf_filtered ("%s...",
2100 pst
-> dependencies
[i
] -> filename
);
2102 fflush (stdout
); /* Flush output */
2104 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2107 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2110 old_chain
= make_cleanup (really_free_pendings
, 0);
2111 pst
-> symtab
= read_ofile_symtab (pst
);
2114 printf_filtered ("%d DIE's, sorting...", diecount
);
2118 sort_symtab_syms (pst
-> symtab
);
2119 do_cleanups (old_chain
);
2130 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2134 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2138 This is the DWARF support entry point for building a full symbol
2139 table entry from a partial symbol table entry. We are passed a
2140 pointer to the partial symbol table entry that needs to be expanded.
2145 dwarf_psymtab_to_symtab (pst
)
2146 struct partial_symtab
*pst
;
2153 warning ("psymtab for %s already read in. Shouldn't happen.",
2158 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2160 /* Print the message now, before starting serious work, to avoid
2161 disconcerting pauses. */
2164 printf_filtered ("Reading in symbols for %s...",
2169 psymtab_to_symtab_1 (pst
);
2171 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2172 we need to do an equivalent or is this something peculiar to
2174 Match with global symbols. This only needs to be done once,
2175 after all of the symtabs and dependencies have been read in.
2177 scan_file_globals (pst
-> objfile
);
2180 /* Finish up the verbose info message. */
2183 printf_filtered ("done.\n");
2195 init_psymbol_list -- initialize storage for partial symbols
2199 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2203 Initializes storage for all of the partial symbols that will be
2204 created by dwarf_build_psymtabs and subsidiaries.
2208 init_psymbol_list (objfile
, total_symbols
)
2209 struct objfile
*objfile
;
2212 /* Free any previously allocated psymbol lists. */
2214 if (objfile
-> global_psymbols
.list
)
2216 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2218 if (objfile
-> static_psymbols
.list
)
2220 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2223 /* Current best guess is that there are approximately a twentieth
2224 of the total symbols (in a debugging file) are global or static
2227 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2228 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2229 objfile
-> global_psymbols
.next
=
2230 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2231 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2232 * sizeof (struct partial_symbol
));
2233 objfile
-> static_psymbols
.next
=
2234 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2235 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2236 * sizeof (struct partial_symbol
));
2243 add_enum_psymbol -- add enumeration members to partial symbol table
2247 Given pointer to a DIE that is known to be for an enumeration,
2248 extract the symbolic names of the enumeration members and add
2249 partial symbols for them.
2253 add_enum_psymbol (dip
, objfile
)
2254 struct dieinfo
*dip
;
2255 struct objfile
*objfile
;
2259 unsigned short blocksz
;
2262 if ((scan
= dip
-> at_element_list
) != NULL
)
2264 if (dip
-> short_element_list
)
2266 nbytes
= attribute_size (AT_short_element_list
);
2270 nbytes
= attribute_size (AT_element_list
);
2272 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2274 listend
= scan
+ blocksz
;
2275 while (scan
< listend
)
2277 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2278 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2279 objfile
-> static_psymbols
, 0);
2280 scan
+= strlen (scan
) + 1;
2289 add_partial_symbol -- add symbol to partial symbol table
2293 Given a DIE, if it is one of the types that we want to
2294 add to a partial symbol table, finish filling in the die info
2295 and then add a partial symbol table entry for it.
2300 add_partial_symbol (dip
, objfile
)
2301 struct dieinfo
*dip
;
2302 struct objfile
*objfile
;
2304 switch (dip
-> die_tag
)
2306 case TAG_global_subroutine
:
2307 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2309 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2310 VAR_NAMESPACE
, LOC_BLOCK
,
2311 objfile
-> global_psymbols
,
2314 case TAG_global_variable
:
2315 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2317 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2318 VAR_NAMESPACE
, LOC_STATIC
,
2319 objfile
-> global_psymbols
,
2322 case TAG_subroutine
:
2323 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2324 VAR_NAMESPACE
, LOC_BLOCK
,
2325 objfile
-> static_psymbols
,
2328 case TAG_local_variable
:
2329 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2330 VAR_NAMESPACE
, LOC_STATIC
,
2331 objfile
-> static_psymbols
,
2335 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2336 VAR_NAMESPACE
, LOC_TYPEDEF
,
2337 objfile
-> static_psymbols
,
2340 case TAG_structure_type
:
2341 case TAG_union_type
:
2342 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2343 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2344 objfile
-> static_psymbols
,
2347 case TAG_enumeration_type
:
2350 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2351 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2352 objfile
-> static_psymbols
,
2355 add_enum_psymbol (dip
, objfile
);
2364 scan_partial_symbols -- scan DIE's within a single compilation unit
2368 Process the DIE's within a single compilation unit, looking for
2369 interesting DIE's that contribute to the partial symbol table entry
2370 for this compilation unit. Since we cannot follow any sibling
2371 chains without reading the complete DIE info for every DIE,
2372 it is probably faster to just sequentially check each one to
2373 see if it is one of the types we are interested in, and if so,
2374 then extract all the attributes info and generate a partial
2379 Don't attempt to add anonymous structures or unions since they have
2380 no name. Anonymous enumerations however are processed, because we
2381 want to extract their member names (the check for a tag name is
2384 Also, for variables and subroutines, check that this is the place
2385 where the actual definition occurs, rather than just a reference
2390 scan_partial_symbols (thisdie
, enddie
, objfile
)
2393 struct objfile
*objfile
;
2398 while (thisdie
< enddie
)
2400 basicdieinfo (&di
, thisdie
, objfile
);
2401 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2407 nextdie
= thisdie
+ di
.die_length
;
2408 /* To avoid getting complete die information for every die, we
2409 only do it (below) for the cases we are interested in. */
2412 case TAG_global_subroutine
:
2413 case TAG_subroutine
:
2414 case TAG_global_variable
:
2415 case TAG_local_variable
:
2416 completedieinfo (&di
, objfile
);
2417 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2419 add_partial_symbol (&di
, objfile
);
2423 case TAG_structure_type
:
2424 case TAG_union_type
:
2425 completedieinfo (&di
, objfile
);
2428 add_partial_symbol (&di
, objfile
);
2431 case TAG_enumeration_type
:
2432 completedieinfo (&di
, objfile
);
2433 add_partial_symbol (&di
, objfile
);
2445 scan_compilation_units -- build a psymtab entry for each compilation
2449 This is the top level dwarf parsing routine for building partial
2452 It scans from the beginning of the DWARF table looking for the first
2453 TAG_compile_unit DIE, and then follows the sibling chain to locate
2454 each additional TAG_compile_unit DIE.
2456 For each TAG_compile_unit DIE it creates a partial symtab structure,
2457 calls a subordinate routine to collect all the compilation unit's
2458 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2459 new partial symtab structure into the partial symbol table. It also
2460 records the appropriate information in the partial symbol table entry
2461 to allow the chunk of DIE's and line number table for this compilation
2462 unit to be located and re-read later, to generate a complete symbol
2463 table entry for the compilation unit.
2465 Thus it effectively partitions up a chunk of DIE's for multiple
2466 compilation units into smaller DIE chunks and line number tables,
2467 and associates them with a partial symbol table entry.
2471 If any compilation unit has no line number table associated with
2472 it for some reason (a missing at_stmt_list attribute, rather than
2473 just one with a value of zero, which is valid) then we ensure that
2474 the recorded file offset is zero so that the routine which later
2475 reads line number table fragments knows that there is no fragment
2485 scan_compilation_units (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2489 unsigned int dbfoff
;
2490 unsigned int lnoffset
;
2491 struct objfile
*objfile
;
2495 struct partial_symtab
*pst
;
2500 while (thisdie
< enddie
)
2502 basicdieinfo (&di
, thisdie
, objfile
);
2503 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2507 else if (di
.die_tag
!= TAG_compile_unit
)
2509 nextdie
= thisdie
+ di
.die_length
;
2513 completedieinfo (&di
, objfile
);
2514 if (di
.at_sibling
!= 0)
2516 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2520 nextdie
= thisdie
+ di
.die_length
;
2522 curoff
= thisdie
- dbbase
;
2523 culength
= nextdie
- thisdie
;
2524 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2526 /* First allocate a new partial symbol table structure */
2528 pst
= start_psymtab_common (objfile
, base_section_offsets
, di
.at_name
,
2530 objfile
-> global_psymbols
.next
,
2531 objfile
-> static_psymbols
.next
);
2533 pst
-> texthigh
= di
.at_high_pc
;
2534 pst
-> read_symtab_private
= (char *)
2535 obstack_alloc (&objfile
-> psymbol_obstack
,
2536 sizeof (struct dwfinfo
));
2537 DBFOFF (pst
) = dbfoff
;
2538 DBROFF (pst
) = curoff
;
2539 DBLENGTH (pst
) = culength
;
2540 LNFOFF (pst
) = curlnoffset
;
2541 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2543 /* Now look for partial symbols */
2545 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2547 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2548 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2549 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2550 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2551 sort_pst_symbols (pst
);
2552 /* If there is already a psymtab or symtab for a file of this name,
2553 remove it. (If there is a symtab, more drastic things also
2554 happen.) This happens in VxWorks. */
2555 free_named_symtabs (pst
-> filename
);
2565 new_symbol -- make a symbol table entry for a new symbol
2569 static struct symbol *new_symbol (struct dieinfo *dip,
2570 struct objfile *objfile)
2574 Given a pointer to a DWARF information entry, figure out if we need
2575 to make a symbol table entry for it, and if so, create a new entry
2576 and return a pointer to it.
2579 static struct symbol
*
2580 new_symbol (dip
, objfile
)
2581 struct dieinfo
*dip
;
2582 struct objfile
*objfile
;
2584 struct symbol
*sym
= NULL
;
2586 if (dip
-> at_name
!= NULL
)
2588 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2589 sizeof (struct symbol
));
2590 memset (sym
, 0, sizeof (struct symbol
));
2591 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, &objfile
->symbol_obstack
);
2592 /* default assumptions */
2593 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2594 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2595 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2596 switch (dip
-> die_tag
)
2599 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2600 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2602 case TAG_global_subroutine
:
2603 case TAG_subroutine
:
2604 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2605 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2606 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2607 if (dip
-> die_tag
== TAG_global_subroutine
)
2609 add_symbol_to_list (sym
, &global_symbols
);
2613 add_symbol_to_list (sym
, list_in_scope
);
2616 case TAG_global_variable
:
2617 if (dip
-> at_location
!= NULL
)
2619 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2620 add_symbol_to_list (sym
, &global_symbols
);
2621 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2622 SYMBOL_VALUE (sym
) += baseaddr
;
2625 case TAG_local_variable
:
2626 if (dip
-> at_location
!= NULL
)
2628 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2629 add_symbol_to_list (sym
, list_in_scope
);
2632 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2636 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2640 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2641 SYMBOL_VALUE (sym
) += baseaddr
;
2645 case TAG_formal_parameter
:
2646 if (dip
-> at_location
!= NULL
)
2648 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2650 add_symbol_to_list (sym
, list_in_scope
);
2653 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2657 SYMBOL_CLASS (sym
) = LOC_ARG
;
2660 case TAG_unspecified_parameters
:
2661 /* From varargs functions; gdb doesn't seem to have any interest in
2662 this information, so just ignore it for now. (FIXME?) */
2664 case TAG_structure_type
:
2665 case TAG_union_type
:
2666 case TAG_enumeration_type
:
2667 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2668 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2669 add_symbol_to_list (sym
, list_in_scope
);
2672 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2673 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2674 add_symbol_to_list (sym
, list_in_scope
);
2677 /* Not a tag we recognize. Hopefully we aren't processing trash
2678 data, but since we must specifically ignore things we don't
2679 recognize, there is nothing else we should do at this point. */
2690 decode_mod_fund_type -- decode a modified fundamental type
2694 static struct type *decode_mod_fund_type (char *typedata)
2698 Decode a block of data containing a modified fundamental
2699 type specification. TYPEDATA is a pointer to the block,
2700 which starts with a length containing the size of the rest
2701 of the block. At the end of the block is a fundmental type
2702 code value that gives the fundamental type. Everything
2703 in between are type modifiers.
2705 We simply compute the number of modifiers and call the general
2706 function decode_modified_type to do the actual work.
2709 static struct type
*
2710 decode_mod_fund_type (typedata
)
2713 struct type
*typep
= NULL
;
2714 unsigned short modcount
;
2717 /* Get the total size of the block, exclusive of the size itself */
2719 nbytes
= attribute_size (AT_mod_fund_type
);
2720 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2723 /* Deduct the size of the fundamental type bytes at the end of the block. */
2725 modcount
-= attribute_size (AT_fund_type
);
2727 /* Now do the actual decoding */
2729 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2737 decode_mod_u_d_type -- decode a modified user defined type
2741 static struct type *decode_mod_u_d_type (char *typedata)
2745 Decode a block of data containing a modified user defined
2746 type specification. TYPEDATA is a pointer to the block,
2747 which consists of a two byte length, containing the size
2748 of the rest of the block. At the end of the block is a
2749 four byte value that gives a reference to a user defined type.
2750 Everything in between are type modifiers.
2752 We simply compute the number of modifiers and call the general
2753 function decode_modified_type to do the actual work.
2756 static struct type
*
2757 decode_mod_u_d_type (typedata
)
2760 struct type
*typep
= NULL
;
2761 unsigned short modcount
;
2764 /* Get the total size of the block, exclusive of the size itself */
2766 nbytes
= attribute_size (AT_mod_u_d_type
);
2767 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2770 /* Deduct the size of the reference type bytes at the end of the block. */
2772 modcount
-= attribute_size (AT_user_def_type
);
2774 /* Now do the actual decoding */
2776 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2784 decode_modified_type -- decode modified user or fundamental type
2788 static struct type *decode_modified_type (char *modifiers,
2789 unsigned short modcount, int mtype)
2793 Decode a modified type, either a modified fundamental type or
2794 a modified user defined type. MODIFIERS is a pointer to the
2795 block of bytes that define MODCOUNT modifiers. Immediately
2796 following the last modifier is a short containing the fundamental
2797 type or a long containing the reference to the user defined
2798 type. Which one is determined by MTYPE, which is either
2799 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2800 type we are generating.
2802 We call ourself recursively to generate each modified type,`
2803 until MODCOUNT reaches zero, at which point we have consumed
2804 all the modifiers and generate either the fundamental type or
2805 user defined type. When the recursion unwinds, each modifier
2806 is applied in turn to generate the full modified type.
2810 If we find a modifier that we don't recognize, and it is not one
2811 of those reserved for application specific use, then we issue a
2812 warning and simply ignore the modifier.
2816 We currently ignore MOD_const and MOD_volatile. (FIXME)
2820 static struct type
*
2821 decode_modified_type (modifiers
, modcount
, mtype
)
2823 unsigned int modcount
;
2826 struct type
*typep
= NULL
;
2827 unsigned short fundtype
;
2836 case AT_mod_fund_type
:
2837 nbytes
= attribute_size (AT_fund_type
);
2838 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2840 typep
= decode_fund_type (fundtype
);
2842 case AT_mod_u_d_type
:
2843 nbytes
= attribute_size (AT_user_def_type
);
2844 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2846 if ((typep
= lookup_utype (die_ref
)) == NULL
)
2848 typep
= alloc_utype (die_ref
, NULL
);
2852 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2853 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2859 modifier
= *modifiers
++;
2860 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2863 case MOD_pointer_to
:
2864 typep
= lookup_pointer_type (typep
);
2866 case MOD_reference_to
:
2867 typep
= lookup_reference_type (typep
);
2870 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2873 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2876 if (!(MOD_lo_user
<= (unsigned char) modifier
2877 && (unsigned char) modifier
<= MOD_hi_user
))
2879 SQUAWK (("unknown type modifier %u",
2880 (unsigned char) modifier
));
2892 decode_fund_type -- translate basic DWARF type to gdb base type
2896 Given an integer that is one of the fundamental DWARF types,
2897 translate it to one of the basic internal gdb types and return
2898 a pointer to the appropriate gdb type (a "struct type *").
2902 If we encounter a fundamental type that we are unprepared to
2903 deal with, and it is not in the range of those types defined
2904 as application specific types, then we issue a warning and
2905 treat the type as an "int".
2908 static struct type
*
2909 decode_fund_type (fundtype
)
2910 unsigned int fundtype
;
2912 struct type
*typep
= NULL
;
2918 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2921 case FT_boolean
: /* Was FT_set in AT&T version */
2922 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
2925 case FT_pointer
: /* (void *) */
2926 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2927 typep
= lookup_pointer_type (typep
);
2931 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
2934 case FT_signed_char
:
2935 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
2938 case FT_unsigned_char
:
2939 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
2943 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
2946 case FT_signed_short
:
2947 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
2950 case FT_unsigned_short
:
2951 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
2955 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2958 case FT_signed_integer
:
2959 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
2962 case FT_unsigned_integer
:
2963 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2967 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
2970 case FT_signed_long
:
2971 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
2974 case FT_unsigned_long
:
2975 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2979 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
2982 case FT_signed_long_long
:
2983 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
2986 case FT_unsigned_long_long
:
2987 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
2991 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2994 case FT_dbl_prec_float
:
2995 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
2998 case FT_ext_prec_float
:
2999 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3003 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3006 case FT_dbl_prec_complex
:
3007 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3010 case FT_ext_prec_complex
:
3011 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3016 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3018 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3019 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3029 create_name -- allocate a fresh copy of a string on an obstack
3033 Given a pointer to a string and a pointer to an obstack, allocates
3034 a fresh copy of the string on the specified obstack.
3039 create_name (name
, obstackp
)
3041 struct obstack
*obstackp
;
3046 length
= strlen (name
) + 1;
3047 newname
= (char *) obstack_alloc (obstackp
, length
);
3048 strcpy (newname
, name
);
3056 basicdieinfo -- extract the minimal die info from raw die data
3060 void basicdieinfo (char *diep, struct dieinfo *dip,
3061 struct objfile *objfile)
3065 Given a pointer to raw DIE data, and a pointer to an instance of a
3066 die info structure, this function extracts the basic information
3067 from the DIE data required to continue processing this DIE, along
3068 with some bookkeeping information about the DIE.
3070 The information we absolutely must have includes the DIE tag,
3071 and the DIE length. If we need the sibling reference, then we
3072 will have to call completedieinfo() to process all the remaining
3075 Note that since there is no guarantee that the data is properly
3076 aligned in memory for the type of access required (indirection
3077 through anything other than a char pointer), and there is no
3078 guarantee that it is in the same byte order as the gdb host,
3079 we call a function which deals with both alignment and byte
3080 swapping issues. Possibly inefficient, but quite portable.
3082 We also take care of some other basic things at this point, such
3083 as ensuring that the instance of the die info structure starts
3084 out completely zero'd and that curdie is initialized for use
3085 in error reporting if we have a problem with the current die.
3089 All DIE's must have at least a valid length, thus the minimum
3090 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3091 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3092 are forced to be TAG_padding DIES.
3094 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3095 that if a padding DIE is used for alignment and the amount needed is
3096 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3097 enough to align to the next alignment boundry.
3101 basicdieinfo (dip
, diep
, objfile
)
3102 struct dieinfo
*dip
;
3104 struct objfile
*objfile
;
3107 memset (dip
, 0, sizeof (struct dieinfo
));
3109 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3110 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3112 if (dip
-> die_length
< SIZEOF_DIE_LENGTH
)
3114 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3116 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3118 dip
-> die_tag
= TAG_padding
;
3122 diep
+= SIZEOF_DIE_LENGTH
;
3123 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3132 completedieinfo -- finish reading the information for a given DIE
3136 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3140 Given a pointer to an already partially initialized die info structure,
3141 scan the raw DIE data and finish filling in the die info structure
3142 from the various attributes found.
3144 Note that since there is no guarantee that the data is properly
3145 aligned in memory for the type of access required (indirection
3146 through anything other than a char pointer), and there is no
3147 guarantee that it is in the same byte order as the gdb host,
3148 we call a function which deals with both alignment and byte
3149 swapping issues. Possibly inefficient, but quite portable.
3153 Each time we are called, we increment the diecount variable, which
3154 keeps an approximate count of the number of dies processed for
3155 each compilation unit. This information is presented to the user
3156 if the info_verbose flag is set.
3161 completedieinfo (dip
, objfile
)
3162 struct dieinfo
*dip
;
3163 struct objfile
*objfile
;
3165 char *diep
; /* Current pointer into raw DIE data */
3166 char *end
; /* Terminate DIE scan here */
3167 unsigned short attr
; /* Current attribute being scanned */
3168 unsigned short form
; /* Form of the attribute */
3169 int nbytes
; /* Size of next field to read */
3173 end
= diep
+ dip
-> die_length
;
3174 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3177 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3178 diep
+= SIZEOF_ATTRIBUTE
;
3179 if ((nbytes
= attribute_size (attr
)) == -1)
3181 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3188 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3192 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3196 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3200 dip
-> at_visibility
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3204 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3208 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3210 dip
-> has_at_stmt_list
= 1;
3213 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3215 dip
-> at_low_pc
+= baseaddr
;
3216 dip
-> has_at_low_pc
= 1;
3219 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3221 dip
-> at_high_pc
+= baseaddr
;
3224 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3227 case AT_user_def_type
:
3228 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3229 GET_UNSIGNED
, objfile
);
3232 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3236 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3240 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3244 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3248 dip
-> at_import
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3252 dip
-> at_location
= diep
;
3254 case AT_mod_fund_type
:
3255 dip
-> at_mod_fund_type
= diep
;
3257 case AT_subscr_data
:
3258 dip
-> at_subscr_data
= diep
;
3260 case AT_mod_u_d_type
:
3261 dip
-> at_mod_u_d_type
= diep
;
3263 case AT_element_list
:
3264 dip
-> at_element_list
= diep
;
3265 dip
-> short_element_list
= 0;
3267 case AT_short_element_list
:
3268 dip
-> at_element_list
= diep
;
3269 dip
-> short_element_list
= 1;
3271 case AT_discr_value
:
3272 dip
-> at_discr_value
= diep
;
3274 case AT_string_length
:
3275 dip
-> at_string_length
= diep
;
3278 dip
-> at_name
= diep
;
3281 /* For now, ignore any "hostname:" portion, since gdb doesn't
3282 know how to deal with it. (FIXME). */
3283 dip
-> at_comp_dir
= strrchr (diep
, ':');
3284 if (dip
-> at_comp_dir
!= NULL
)
3286 dip
-> at_comp_dir
++;
3290 dip
-> at_comp_dir
= diep
;
3294 dip
-> at_producer
= diep
;
3297 dip
-> at_frame_base
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3300 case AT_start_scope
:
3301 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3304 case AT_stride_size
:
3305 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3309 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3313 dip
-> at_prototyped
= diep
;
3316 /* Found an attribute that we are unprepared to handle. However
3317 it is specifically one of the design goals of DWARF that
3318 consumers should ignore unknown attributes. As long as the
3319 form is one that we recognize (so we know how to skip it),
3320 we can just ignore the unknown attribute. */
3323 form
= FORM_FROM_ATTR (attr
);
3337 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3340 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3343 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3346 diep
+= strlen (diep
) + 1;
3349 SQUAWK (("unknown attribute form (0x%x)", form
));
3350 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3361 target_to_host -- swap in target data to host
3365 target_to_host (char *from, int nbytes, int signextend,
3366 struct objfile *objfile)
3370 Given pointer to data in target format in FROM, a byte count for
3371 the size of the data in NBYTES, a flag indicating whether or not
3372 the data is signed in SIGNEXTEND, and a pointer to the current
3373 objfile in OBJFILE, convert the data to host format and return
3374 the converted value.
3378 FIXME: If we read data that is known to be signed, and expect to
3379 use it as signed data, then we need to explicitly sign extend the
3380 result until the bfd library is able to do this for us.
3384 static unsigned long
3385 target_to_host (from
, nbytes
, signextend
, objfile
)
3388 int signextend
; /* FIXME: Unused */
3389 struct objfile
*objfile
;
3391 unsigned long rtnval
;
3396 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3399 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3402 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3405 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3408 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3419 attribute_size -- compute size of data for a DWARF attribute
3423 static int attribute_size (unsigned int attr)
3427 Given a DWARF attribute in ATTR, compute the size of the first
3428 piece of data associated with this attribute and return that
3431 Returns -1 for unrecognized attributes.
3436 attribute_size (attr
)
3439 int nbytes
; /* Size of next data for this attribute */
3440 unsigned short form
; /* Form of the attribute */
3442 form
= FORM_FROM_ATTR (attr
);
3445 case FORM_STRING
: /* A variable length field is next */
3448 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3449 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3452 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3453 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3454 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3457 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3460 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3461 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3464 SQUAWK (("unknown attribute form (0x%x)", form
));