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"
57 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
58 #define SQUAWK(stuff) dwarfwarn stuff
63 #ifndef R_FP /* FIXME */
64 #define R_FP 14 /* Kludge to get frame pointer register number */
67 typedef unsigned int DIE_REF
; /* Reference to a DIE */
70 #define GCC_PRODUCER "GNU C "
73 #define STREQ(a,b) (strcmp(a,b)==0)
74 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
76 /* Flags to target_to_host() that tell whether or not the data object is
77 expected to be signed. Used, for example, when fetching a signed
78 integer in the target environment which is used as a signed integer
79 in the host environment, and the two environments have different sized
80 ints. In this case, *somebody* has to sign extend the smaller sized
83 #define GET_UNSIGNED 0 /* No sign extension required */
84 #define GET_SIGNED 1 /* Sign extension required */
86 /* Defines for things which are specified in the document "DWARF Debugging
87 Information Format" published by UNIX International, Programming Languages
88 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
90 #define SIZEOF_DIE_LENGTH 4
91 #define SIZEOF_DIE_TAG 2
92 #define SIZEOF_ATTRIBUTE 2
93 #define SIZEOF_FORMAT_SPECIFIER 1
94 #define SIZEOF_FMT_FT 2
95 #define SIZEOF_LINETBL_LENGTH 4
96 #define SIZEOF_LINETBL_LINENO 4
97 #define SIZEOF_LINETBL_STMT 2
98 #define SIZEOF_LINETBL_DELTA 4
99 #define SIZEOF_LOC_ATOM_CODE 1
101 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
103 /* Macros that return the sizes of various types of data in the target
106 FIXME: Currently these are just compile time constants (as they are in
107 other parts of gdb as well). They need to be able to get the right size
108 either from the bfd or possibly from the DWARF info. It would be nice if
109 the DWARF producer inserted DIES that describe the fundamental types in
110 the target environment into the DWARF info, similar to the way dbx stabs
111 producers produce information about their fundamental types. */
113 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
114 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
116 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
117 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
118 However, the Issue 2 DWARF specification from AT&T defines it as
119 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
120 For backwards compatibility with the AT&T compiler produced executables
121 we define AT_short_element_list for this variant. */
123 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
125 /* External variables referenced. */
127 extern int info_verbose
; /* From main.c; nonzero => verbose */
128 extern char *warning_pre_print
; /* From utils.c */
130 /* The DWARF debugging information consists of two major pieces,
131 one is a block of DWARF Information Entries (DIE's) and the other
132 is a line number table. The "struct dieinfo" structure contains
133 the information for a single DIE, the one currently being processed.
135 In order to make it easier to randomly access the attribute fields
136 of the current DIE, which are specifically unordered within the DIE,
137 each DIE is scanned and an instance of the "struct dieinfo"
138 structure is initialized.
140 Initialization is done in two levels. The first, done by basicdieinfo(),
141 just initializes those fields that are vital to deciding whether or not
142 to use this DIE, how to skip past it, etc. The second, done by the
143 function completedieinfo(), fills in the rest of the information.
145 Attributes which have block forms are not interpreted at the time
146 the DIE is scanned, instead we just save pointers to the start
147 of their value fields.
149 Some fields have a flag <name>_p that is set when the value of the
150 field is valid (I.E. we found a matching attribute in the DIE). Since
151 we may want to test for the presence of some attributes in the DIE,
152 such as AT_low_pc, without restricting the values of the field,
153 we need someway to note that we found such an attribute.
160 char * die
; /* Pointer to the raw DIE data */
161 unsigned long die_length
; /* Length of the raw DIE data */
162 DIE_REF die_ref
; /* Offset of this DIE */
163 unsigned short die_tag
; /* Tag for this DIE */
164 unsigned long at_padding
;
165 unsigned long at_sibling
;
168 unsigned short at_fund_type
;
169 BLOCK
* at_mod_fund_type
;
170 unsigned long at_user_def_type
;
171 BLOCK
* at_mod_u_d_type
;
172 unsigned short at_ordering
;
173 BLOCK
* at_subscr_data
;
174 unsigned long at_byte_size
;
175 unsigned short at_bit_offset
;
176 unsigned long at_bit_size
;
177 BLOCK
* at_element_list
;
178 unsigned long at_stmt_list
;
179 unsigned long at_low_pc
;
180 unsigned long at_high_pc
;
181 unsigned long at_language
;
182 unsigned long at_member
;
183 unsigned long at_discr
;
184 BLOCK
* at_discr_value
;
185 unsigned short at_visibility
;
186 unsigned long at_import
;
187 BLOCK
* at_string_length
;
190 unsigned long at_frame_base
;
191 unsigned long at_start_scope
;
192 unsigned long at_stride_size
;
193 unsigned long at_src_info
;
194 char * at_prototyped
;
195 unsigned int has_at_low_pc
:1;
196 unsigned int has_at_stmt_list
:1;
197 unsigned int short_element_list
:1;
200 static int diecount
; /* Approximate count of dies for compilation unit */
201 static struct dieinfo
*curdie
; /* For warnings and such */
203 static char *dbbase
; /* Base pointer to dwarf info */
204 static int dbroff
; /* Relative offset from start of .debug section */
205 static char *lnbase
; /* Base pointer to line section */
206 static int isreg
; /* Kludge to identify register variables */
207 static int offreg
; /* Kludge to identify basereg references */
209 static CORE_ADDR baseaddr
; /* Add to each symbol value */
211 /* Each partial symbol table entry contains a pointer to private data for the
212 read_symtab() function to use when expanding a partial symbol table entry
213 to a full symbol table entry. For DWARF debugging info, this data is
214 contained in the following structure and macros are provided for easy
215 access to the members given a pointer to a partial symbol table entry.
217 dbfoff Always the absolute file offset to the start of the ".debug"
218 section for the file containing the DIE's being accessed.
220 dbroff Relative offset from the start of the ".debug" access to the
221 first DIE to be accessed. When building the partial symbol
222 table, this value will be zero since we are accessing the
223 entire ".debug" section. When expanding a partial symbol
224 table entry, this value will be the offset to the first
225 DIE for the compilation unit containing the symbol that
226 triggers the expansion.
228 dblength The size of the chunk of DIE's being examined, in bytes.
230 lnfoff The absolute file offset to the line table fragment. Ignored
231 when building partial symbol tables, but used when expanding
232 them, and contains the absolute file offset to the fragment
233 of the ".line" section containing the line numbers for the
234 current compilation unit.
238 int dbfoff
; /* Absolute file offset to start of .debug section */
239 int dbroff
; /* Relative offset from start of .debug section */
240 int dblength
; /* Size of the chunk of DIE's being examined */
241 int lnfoff
; /* Absolute file offset to line table fragment */
244 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
245 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
246 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
247 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
249 /* The generic symbol table building routines have separate lists for
250 file scope symbols and all all other scopes (local scopes). So
251 we need to select the right one to pass to add_symbol_to_list().
252 We do it by keeping a pointer to the correct list in list_in_scope.
254 FIXME: The original dwarf code just treated the file scope as the first
255 local scope, and all other local scopes as nested local scopes, and worked
256 fine. Check to see if we really need to distinguish these in buildsym.c */
258 struct pending
**list_in_scope
= &file_symbols
;
260 /* DIES which have user defined types or modified user defined types refer to
261 other DIES for the type information. Thus we need to associate the offset
262 of a DIE for a user defined type with a pointer to the type information.
264 Originally this was done using a simple but expensive algorithm, with an
265 array of unsorted structures, each containing an offset/type-pointer pair.
266 This array was scanned linearly each time a lookup was done. The result
267 was that gdb was spending over half it's startup time munging through this
268 array of pointers looking for a structure that had the right offset member.
270 The second attempt used the same array of structures, but the array was
271 sorted using qsort each time a new offset/type was recorded, and a binary
272 search was used to find the type pointer for a given DIE offset. This was
273 even slower, due to the overhead of sorting the array each time a new
274 offset/type pair was entered.
276 The third attempt uses a fixed size array of type pointers, indexed by a
277 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
278 we can divide any DIE offset by 4 to obtain a unique index into this fixed
279 size array. Since each element is a 4 byte pointer, it takes exactly as
280 much memory to hold this array as to hold the DWARF info for a given
281 compilation unit. But it gets freed as soon as we are done with it. */
283 static struct type
**utypes
; /* Pointer to array of user type pointers */
284 static int numutypes
; /* Max number of user type pointers */
286 /* Forward declarations of static functions so we don't have to worry
287 about ordering within this file. */
290 attribute_size
PARAMS ((unsigned int));
293 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
296 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
299 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
302 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
305 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
312 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
315 scan_compilation_units
PARAMS ((char *, char *, char *, unsigned int,
316 unsigned int, struct objfile
*));
319 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
322 init_psymbol_list
PARAMS ((struct objfile
*, int));
325 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
328 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
331 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
334 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
336 static struct symtab
*
337 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
340 process_dies
PARAMS ((char *, char *, struct objfile
*));
343 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
347 decode_array_element_type
PARAMS ((char *));
350 decode_subscr_data
PARAMS ((char *, char *));
353 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
356 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
359 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
362 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
365 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
368 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
371 decode_line_numbers
PARAMS ((char *));
374 decode_die_type
PARAMS ((struct dieinfo
*));
377 decode_mod_fund_type
PARAMS ((char *));
380 decode_mod_u_d_type
PARAMS ((char *));
383 decode_modified_type
PARAMS ((char *, unsigned int, int));
386 decode_fund_type
PARAMS ((unsigned int));
389 create_name
PARAMS ((char *, struct obstack
*));
392 lookup_utype
PARAMS ((DIE_REF
));
395 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
397 static struct symbol
*
398 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
401 locval
PARAMS ((char *));
404 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
411 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
415 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
416 int mainline, unsigned int dbfoff, unsigned int dbsize,
417 unsigned int lnoffset, unsigned int lnsize,
418 struct objfile *objfile)
422 This function is called upon to build partial symtabs from files
423 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
425 It is passed a file descriptor for an open file containing the DIES
426 and line number information, the corresponding filename for that
427 file, a base address for relocating the symbols, a flag indicating
428 whether or not this debugging information is from a "main symbol
429 table" rather than a shared library or dynamically linked file,
430 and file offset/size pairs for the DIE information and line number
440 dwarf_build_psymtabs (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
,
441 lnoffset
, lnsize
, objfile
)
448 unsigned int lnoffset
;
450 struct objfile
*objfile
;
452 struct cleanup
*back_to
;
454 current_objfile
= objfile
;
455 dbbase
= xmalloc (dbsize
);
457 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
458 (read (desc
, dbbase
, dbsize
) != dbsize
))
461 error ("can't read DWARF data from '%s'", filename
);
463 back_to
= make_cleanup (free
, dbbase
);
465 /* If we are reinitializing, or if we have never loaded syms yet, init.
466 Since we have no idea how many DIES we are looking at, we just guess
467 some arbitrary value. */
469 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
470 objfile
-> static_psymbols
.size
== 0)
472 init_psymbol_list (objfile
, 1024);
475 /* Save the relocation factor where everybody can see it. */
479 /* Follow the compilation unit sibling chain, building a partial symbol
480 table entry for each one. Save enough information about each compilation
481 unit to locate the full DWARF information later. */
483 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
484 dbfoff
, lnoffset
, objfile
);
486 do_cleanups (back_to
);
487 current_objfile
= NULL
;
495 record_minimal_symbol -- add entry to gdb's minimal symbol table
499 static void record_minimal_symbol (char *name, CORE_ADDR address,
500 enum minimal_symbol_type ms_type,
501 struct objfile *objfile)
505 Given a pointer to the name of a symbol that should be added to the
506 minimal symbol table, and the address associated with that
507 symbol, records this information for later use in building the
508 minimal symbol table.
513 record_minimal_symbol (name
, address
, ms_type
, objfile
)
516 enum minimal_symbol_type ms_type
;
517 struct objfile
*objfile
;
519 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
520 prim_record_minimal_symbol (name
, address
, ms_type
);
527 dwarfwarn -- issue a DWARF related warning
531 Issue warnings about DWARF related things that aren't serious enough
532 to warrant aborting with an error, but should not be ignored either.
533 This includes things like detectable corruption in DIE's, missing
534 DIE's, unimplemented features, etc.
536 In general, running across tags or attributes that we don't recognize
537 is not considered to be a problem and we should not issue warnings
542 We mostly follow the example of the error() routine, but without
543 returning to command level. It is arguable about whether warnings
544 should be issued at all, and if so, where they should go (stdout or
547 We assume that curdie is valid and contains at least the basic
548 information for the DIE where the problem was noticed.
559 fmt
= va_arg (ap
, char *);
561 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
562 if (curdie
-> at_name
)
564 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
566 vfprintf (stderr
, fmt
, ap
);
567 fprintf (stderr
, "\n");
576 read_lexical_block_scope -- process all dies in a lexical block
580 static void read_lexical_block_scope (struct dieinfo *dip,
581 char *thisdie, char *enddie)
585 Process all the DIES contained within a lexical block scope.
586 Start a new scope, process the dies, and then close the scope.
591 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
595 struct objfile
*objfile
;
597 register struct context_stack
*new;
599 (void) push_context (0, dip
-> at_low_pc
);
600 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
601 new = pop_context ();
602 if (local_symbols
!= NULL
)
604 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
605 dip
-> at_high_pc
, objfile
);
607 local_symbols
= new -> locals
;
614 lookup_utype -- look up a user defined type from die reference
618 static type *lookup_utype (DIE_REF die_ref)
622 Given a DIE reference, lookup the user defined type associated with
623 that DIE, if it has been registered already. If not registered, then
624 return NULL. Alloc_utype() can be called to register an empty
625 type for this reference, which will be filled in later when the
626 actual referenced DIE is processed.
630 lookup_utype (die_ref
)
633 struct type
*type
= NULL
;
636 utypeidx
= (die_ref
- dbroff
) / 4;
637 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
639 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
643 type
= *(utypes
+ utypeidx
);
653 alloc_utype -- add a user defined type for die reference
657 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
661 Given a die reference DIE_REF, and a possible pointer to a user
662 defined type UTYPEP, register that this reference has a user
663 defined type and either use the specified type in UTYPEP or
664 make a new empty type that will be filled in later.
666 We should only be called after calling lookup_utype() to verify that
667 there is not currently a type registered for DIE_REF.
671 alloc_utype (die_ref
, utypep
)
678 utypeidx
= (die_ref
- dbroff
) / 4;
679 typep
= utypes
+ utypeidx
;
680 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
682 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
683 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
685 else if (*typep
!= NULL
)
688 SQUAWK (("internal error: dup user type allocation"));
694 utypep
= (struct type
*)
695 obstack_alloc (¤t_objfile
-> type_obstack
,
696 sizeof (struct type
));
697 (void) memset (utypep
, 0, sizeof (struct type
));
698 TYPE_OBJFILE (utypep
) = current_objfile
;
709 decode_die_type -- return a type for a specified die
713 static struct type *decode_die_type (struct dieinfo *dip)
717 Given a pointer to a die information structure DIP, decode the
718 type of the die and return a pointer to the decoded type. All
719 dies without specific types default to type int.
723 decode_die_type (dip
)
726 struct type
*type
= NULL
;
728 if (dip
-> at_fund_type
!= 0)
730 type
= decode_fund_type (dip
-> at_fund_type
);
732 else if (dip
-> at_mod_fund_type
!= NULL
)
734 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
736 else if (dip
-> at_user_def_type
)
738 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
740 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
743 else if (dip
-> at_mod_u_d_type
)
745 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
749 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
758 struct_type -- compute and return the type for a struct or union
762 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
763 char *enddie, struct objfile *objfile)
767 Given pointer to a die information structure for a die which
768 defines a union or structure (and MUST define one or the other),
769 and pointers to the raw die data that define the range of dies which
770 define the members, compute and return the user defined type for the
775 struct_type (dip
, thisdie
, enddie
, objfile
)
779 struct objfile
*objfile
;
783 struct nextfield
*next
;
786 struct nextfield
*list
= NULL
;
787 struct nextfield
*new;
794 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
796 /* No forward references created an empty type, so install one now */
797 type
= alloc_utype (dip
-> die_ref
, NULL
);
799 INIT_CPLUS_SPECIFIC(type
);
800 switch (dip
-> die_tag
)
802 case TAG_structure_type
:
803 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
807 TYPE_CODE (type
) = TYPE_CODE_UNION
;
811 /* Should never happen */
812 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
814 SQUAWK (("missing structure or union tag"));
817 /* Some compilers try to be helpful by inventing "fake" names for
818 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
819 Thanks, but no thanks... */
820 if (dip
-> at_name
!= NULL
821 && *dip
-> at_name
!= '~'
822 && *dip
-> at_name
!= '.')
824 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
825 tpart1
, " ", dip
-> at_name
);
827 if (dip
-> at_byte_size
!= 0)
829 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
831 thisdie
+= dip
-> die_length
;
832 while (thisdie
< enddie
)
834 basicdieinfo (&mbr
, thisdie
, objfile
);
835 completedieinfo (&mbr
, objfile
);
836 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
840 else if (mbr
.at_sibling
!= 0)
842 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
846 nextdie
= thisdie
+ mbr
.die_length
;
851 /* Get space to record the next field's data. */
852 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
857 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
858 &objfile
-> type_obstack
);
859 list
-> field
.type
= decode_die_type (&mbr
);
860 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
861 /* Handle bit fields. */
862 list
-> field
.bitsize
= mbr
.at_bit_size
;
864 /* For big endian bits, the at_bit_offset gives the additional
865 bit offset from the MSB of the containing anonymous object to
866 the MSB of the field. We don't have to do anything special
867 since we don't need to know the size of the anonymous object. */
868 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
870 /* For little endian bits, we need to have a non-zero at_bit_size,
871 so that we know we are in fact dealing with a bitfield. Compute
872 the bit offset to the MSB of the anonymous object, subtract off
873 the number of bits from the MSB of the field to the MSB of the
874 object, and then subtract off the number of bits of the field
875 itself. The result is the bit offset of the LSB of the field. */
876 if (mbr
.at_bit_size
> 0)
878 list
-> field
.bitpos
+=
879 mbr
.at_byte_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
885 process_dies (thisdie
, nextdie
, objfile
);
890 /* Now create the vector of fields, and record how big it is. We may
891 not even have any fields, if this DIE was generated due to a reference
892 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
893 set, which clues gdb in to the fact that it needs to search elsewhere
894 for the full structure definition. */
897 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
901 TYPE_NFIELDS (type
) = nfields
;
902 TYPE_FIELDS (type
) = (struct field
*)
903 obstack_alloc (&objfile
-> type_obstack
,
904 sizeof (struct field
) * nfields
);
905 /* Copy the saved-up fields into the field vector. */
906 for (n
= nfields
; list
; list
= list
-> next
)
908 TYPE_FIELD (type
, --n
) = list
-> field
;
918 read_structure_scope -- process all dies within struct or union
922 static void read_structure_scope (struct dieinfo *dip,
923 char *thisdie, char *enddie, struct objfile *objfile)
927 Called when we find the DIE that starts a structure or union
928 scope (definition) to process all dies that define the members
929 of the structure or union. DIP is a pointer to the die info
930 struct for the DIE that names the structure or union.
934 Note that we need to call struct_type regardless of whether or not
935 the DIE has an at_name attribute, since it might be an anonymous
936 structure or union. This gets the type entered into our set of
939 However, if the structure is incomplete (an opaque struct/union)
940 then suppress creating a symbol table entry for it since gdb only
941 wants to find the one with the complete definition. Note that if
942 it is complete, we just call new_symbol, which does it's own
943 checking about whether the struct/union is anonymous or not (and
944 suppresses creating a symbol table entry itself).
949 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
953 struct objfile
*objfile
;
958 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
959 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
961 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
963 SYMBOL_TYPE (sym
) = type
;
972 decode_array_element_type -- decode type of the array elements
976 static struct type *decode_array_element_type (char *scan, char *end)
980 As the last step in decoding the array subscript information for an
981 array DIE, we need to decode the type of the array elements. We are
982 passed a pointer to this last part of the subscript information and
983 must return the appropriate type. If the type attribute is not
984 recognized, just warn about the problem and return type int.
988 decode_array_element_type (scan
)
993 unsigned short attribute
;
994 unsigned short fundtype
;
997 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
999 scan
+= SIZEOF_ATTRIBUTE
;
1000 if ((nbytes
= attribute_size (attribute
)) == -1)
1002 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1003 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1010 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1012 typep
= decode_fund_type (fundtype
);
1014 case AT_mod_fund_type
:
1015 typep
= decode_mod_fund_type (scan
);
1017 case AT_user_def_type
:
1018 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1020 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1022 typep
= alloc_utype (die_ref
, NULL
);
1025 case AT_mod_u_d_type
:
1026 typep
= decode_mod_u_d_type (scan
);
1029 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1030 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1041 decode_subscr_data -- decode array subscript and element type data
1045 static struct type *decode_subscr_data (char *scan, char *end)
1049 The array subscripts and the data type of the elements of an
1050 array are described by a list of data items, stored as a block
1051 of contiguous bytes. There is a data item describing each array
1052 dimension, and a final data item describing the element type.
1053 The data items are ordered the same as their appearance in the
1054 source (I.E. leftmost dimension first, next to leftmost second,
1057 We are passed a pointer to the start of the block of bytes
1058 containing the data items, and a pointer to the first byte past
1059 the data. This function decodes the data and returns a type.
1062 FIXME: This code only implements the forms currently used
1063 by the AT&T and GNU C compilers.
1065 The end pointer is supplied for error checking, maybe we should
1069 static struct type
*
1070 decode_subscr_data (scan
, end
)
1074 struct type
*typep
= NULL
;
1075 struct type
*nexttype
;
1076 unsigned int format
;
1077 unsigned short fundtype
;
1078 unsigned long lowbound
;
1079 unsigned long highbound
;
1082 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1084 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1088 typep
= decode_array_element_type (scan
);
1091 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1093 scan
+= SIZEOF_FMT_FT
;
1094 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1095 && fundtype
!= FT_unsigned_integer
)
1097 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1102 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1103 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1106 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1109 nexttype
= decode_subscr_data (scan
, end
);
1110 if (nexttype
!= NULL
)
1112 typep
= (struct type
*)
1113 obstack_alloc (¤t_objfile
-> type_obstack
,
1114 sizeof (struct type
));
1115 (void) memset (typep
, 0, sizeof (struct type
));
1116 TYPE_OBJFILE (typep
) = current_objfile
;
1117 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1118 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1119 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1120 TYPE_TARGET_TYPE (typep
) = nexttype
;
1131 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1134 SQUAWK (("unknown array subscript format %x", format
));
1144 dwarf_read_array_type -- read TAG_array_type DIE
1148 static void dwarf_read_array_type (struct dieinfo *dip)
1152 Extract all information from a TAG_array_type DIE and add to
1153 the user defined type vector.
1157 dwarf_read_array_type (dip
)
1158 struct dieinfo
*dip
;
1164 unsigned short blocksz
;
1167 if (dip
-> at_ordering
!= ORD_row_major
)
1169 /* FIXME: Can gdb even handle column major arrays? */
1170 SQUAWK (("array not row major; not handled correctly"));
1172 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1174 nbytes
= attribute_size (AT_subscr_data
);
1175 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1176 subend
= sub
+ nbytes
+ blocksz
;
1178 type
= decode_subscr_data (sub
, subend
);
1181 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1183 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1185 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1186 TYPE_TARGET_TYPE (utype
) =
1187 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1188 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1192 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1194 (void) alloc_utype (dip
-> die_ref
, type
);
1198 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1199 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1200 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1210 read_tag_pointer_type -- read TAG_pointer_type DIE
1214 static void read_tag_pointer_type (struct dieinfo *dip)
1218 Extract all information from a TAG_pointer_type DIE and add to
1219 the user defined type vector.
1223 read_tag_pointer_type (dip
)
1224 struct dieinfo
*dip
;
1229 type
= decode_die_type (dip
);
1230 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1232 utype
= lookup_pointer_type (type
);
1233 (void) alloc_utype (dip
-> die_ref
, utype
);
1237 TYPE_TARGET_TYPE (utype
) = type
;
1238 TYPE_POINTER_TYPE (type
) = utype
;
1240 /* We assume the machine has only one representation for pointers! */
1241 /* FIXME: This confuses host<->target data representations, and is a
1242 poor assumption besides. */
1244 TYPE_LENGTH (utype
) = sizeof (char *);
1245 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1253 read_subroutine_type -- process TAG_subroutine_type dies
1257 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1262 Handle DIES due to C code like:
1265 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1271 The parameter DIES are currently ignored. See if gdb has a way to
1272 include this info in it's type system, and decode them if so. Is
1273 this what the type structure's "arg_types" field is for? (FIXME)
1277 read_subroutine_type (dip
, thisdie
, enddie
)
1278 struct dieinfo
*dip
;
1282 struct type
*type
; /* Type that this function returns */
1283 struct type
*ftype
; /* Function that returns above type */
1285 /* Decode the type that this subroutine returns */
1287 type
= decode_die_type (dip
);
1289 /* Check to see if we already have a partially constructed user
1290 defined type for this DIE, from a forward reference. */
1292 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1294 /* This is the first reference to one of these types. Make
1295 a new one and place it in the user defined types. */
1296 ftype
= lookup_function_type (type
);
1297 (void) alloc_utype (dip
-> die_ref
, ftype
);
1301 /* We have an existing partially constructed type, so bash it
1302 into the correct type. */
1303 TYPE_TARGET_TYPE (ftype
) = type
;
1304 TYPE_FUNCTION_TYPE (type
) = ftype
;
1305 TYPE_LENGTH (ftype
) = 1;
1306 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1314 read_enumeration -- process dies which define an enumeration
1318 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1319 char *enddie, struct objfile *objfile)
1323 Given a pointer to a die which begins an enumeration, process all
1324 the dies that define the members of the enumeration.
1328 Note that we need to call enum_type regardless of whether or not we
1329 have a symbol, since we might have an enum without a tag name (thus
1330 no symbol for the tagname).
1334 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1335 struct dieinfo
*dip
;
1338 struct objfile
*objfile
;
1343 type
= enum_type (dip
, objfile
);
1344 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
1346 SYMBOL_TYPE (sym
) = type
;
1354 enum_type -- decode and return a type for an enumeration
1358 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1362 Given a pointer to a die information structure for the die which
1363 starts an enumeration, process all the dies that define the members
1364 of the enumeration and return a type pointer for the enumeration.
1366 At the same time, for each member of the enumeration, create a
1367 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1368 and give it the type of the enumeration itself.
1372 Note that the DWARF specification explicitly mandates that enum
1373 constants occur in reverse order from the source program order,
1374 for "consistency" and because this ordering is easier for many
1375 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1376 Entries). Because gdb wants to see the enum members in program
1377 source order, we have to ensure that the order gets reversed while
1378 we are processing them.
1381 static struct type
*
1382 enum_type (dip
, objfile
)
1383 struct dieinfo
*dip
;
1384 struct objfile
*objfile
;
1388 struct nextfield
*next
;
1391 struct nextfield
*list
= NULL
;
1392 struct nextfield
*new;
1397 unsigned short blocksz
;
1401 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1403 /* No forward references created an empty type, so install one now */
1404 type
= alloc_utype (dip
-> die_ref
, NULL
);
1406 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1407 /* Some compilers try to be helpful by inventing "fake" names for
1408 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1409 Thanks, but no thanks... */
1410 if (dip
-> at_name
!= NULL
1411 && *dip
-> at_name
!= '~'
1412 && *dip
-> at_name
!= '.')
1414 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1415 " ", dip
-> at_name
);
1417 if (dip
-> at_byte_size
!= 0)
1419 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1421 if ((scan
= dip
-> at_element_list
) != NULL
)
1423 if (dip
-> short_element_list
)
1425 nbytes
= attribute_size (AT_short_element_list
);
1429 nbytes
= attribute_size (AT_element_list
);
1431 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1432 listend
= scan
+ nbytes
+ blocksz
;
1434 while (scan
< listend
)
1436 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1439 list
-> field
.type
= NULL
;
1440 list
-> field
.bitsize
= 0;
1441 list
-> field
.bitpos
=
1442 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1444 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1445 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1446 &objfile
-> type_obstack
);
1447 scan
+= strlen (scan
) + 1;
1449 /* Handcraft a new symbol for this enum member. */
1450 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1451 sizeof (struct symbol
));
1452 (void) memset (sym
, 0, sizeof (struct symbol
));
1453 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1454 &objfile
->symbol_obstack
);
1455 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1456 SYMBOL_CLASS (sym
) = LOC_CONST
;
1457 SYMBOL_TYPE (sym
) = type
;
1458 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1459 add_symbol_to_list (sym
, list_in_scope
);
1461 /* Now create the vector of fields, and record how big it is. This is
1462 where we reverse the order, by pulling the members off the list in
1463 reverse order from how they were inserted. If we have no fields
1464 (this is apparently possible in C++) then skip building a field
1468 TYPE_NFIELDS (type
) = nfields
;
1469 TYPE_FIELDS (type
) = (struct field
*)
1470 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1471 /* Copy the saved-up fields into the field vector. */
1472 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1474 TYPE_FIELD (type
, n
++) = list
-> field
;
1485 read_func_scope -- process all dies within a function scope
1489 Process all dies within a given function scope. We are passed
1490 a die information structure pointer DIP for the die which
1491 starts the function scope, and pointers into the raw die data
1492 that define the dies within the function scope.
1494 For now, we ignore lexical block scopes within the function.
1495 The problem is that AT&T cc does not define a DWARF lexical
1496 block scope for the function itself, while gcc defines a
1497 lexical block scope for the function. We need to think about
1498 how to handle this difference, or if it is even a problem.
1503 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1504 struct dieinfo
*dip
;
1507 struct objfile
*objfile
;
1509 register struct context_stack
*new;
1511 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1512 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1514 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1515 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1517 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1519 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1520 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1522 new = push_context (0, dip
-> at_low_pc
);
1523 new -> name
= new_symbol (dip
, objfile
);
1524 list_in_scope
= &local_symbols
;
1525 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1526 new = pop_context ();
1527 /* Make a block for the local symbols within. */
1528 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1529 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1530 list_in_scope
= &file_symbols
;
1537 read_file_scope -- process all dies within a file scope
1541 Process all dies within a given file scope. We are passed a
1542 pointer to the die information structure for the die which
1543 starts the file scope, and pointers into the raw die data which
1544 mark the range of dies within the file scope.
1546 When the partial symbol table is built, the file offset for the line
1547 number table for each compilation unit is saved in the partial symbol
1548 table entry for that compilation unit. As the symbols for each
1549 compilation unit are read, the line number table is read into memory
1550 and the variable lnbase is set to point to it. Thus all we have to
1551 do is use lnbase to access the line number table for the current
1556 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1557 struct dieinfo
*dip
;
1560 struct objfile
*objfile
;
1562 struct cleanup
*back_to
;
1563 struct symtab
*symtab
;
1565 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1566 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1568 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1569 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1571 if (dip
-> at_producer
!= NULL
)
1573 processing_gcc_compilation
=
1574 STREQN (dip
-> at_producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1576 numutypes
= (enddie
- thisdie
) / 4;
1577 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1578 back_to
= make_cleanup (free
, utypes
);
1579 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1580 start_symtab (dip
-> at_name
, NULL
, dip
-> at_low_pc
);
1581 decode_line_numbers (lnbase
);
1582 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1583 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1584 /* FIXME: The following may need to be expanded for other languages */
1585 switch (dip
-> at_language
)
1589 symtab
-> language
= language_c
;
1591 case LANG_C_PLUS_PLUS
:
1592 symtab
-> language
= language_cplus
;
1597 do_cleanups (back_to
);
1606 process_dies -- process a range of DWARF Information Entries
1610 static void process_dies (char *thisdie, char *enddie,
1611 struct objfile *objfile)
1615 Process all DIE's in a specified range. May be (and almost
1616 certainly will be) called recursively.
1620 process_dies (thisdie
, enddie
, objfile
)
1623 struct objfile
*objfile
;
1628 while (thisdie
< enddie
)
1630 basicdieinfo (&di
, thisdie
, objfile
);
1631 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1635 else if (di
.die_tag
== TAG_padding
)
1637 nextdie
= thisdie
+ di
.die_length
;
1641 completedieinfo (&di
, objfile
);
1642 if (di
.at_sibling
!= 0)
1644 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1648 nextdie
= thisdie
+ di
.die_length
;
1652 case TAG_compile_unit
:
1653 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1655 case TAG_global_subroutine
:
1656 case TAG_subroutine
:
1657 if (di
.has_at_low_pc
)
1659 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1662 case TAG_lexical_block
:
1663 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1665 case TAG_structure_type
:
1666 case TAG_union_type
:
1667 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1669 case TAG_enumeration_type
:
1670 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1672 case TAG_subroutine_type
:
1673 read_subroutine_type (&di
, thisdie
, nextdie
);
1675 case TAG_array_type
:
1676 dwarf_read_array_type (&di
);
1678 case TAG_pointer_type
:
1679 read_tag_pointer_type (&di
);
1682 (void) new_symbol (&di
, objfile
);
1694 decode_line_numbers -- decode a line number table fragment
1698 static void decode_line_numbers (char *tblscan, char *tblend,
1699 long length, long base, long line, long pc)
1703 Translate the DWARF line number information to gdb form.
1705 The ".line" section contains one or more line number tables, one for
1706 each ".line" section from the objects that were linked.
1708 The AT_stmt_list attribute for each TAG_source_file entry in the
1709 ".debug" section contains the offset into the ".line" section for the
1710 start of the table for that file.
1712 The table itself has the following structure:
1714 <table length><base address><source statement entry>
1715 4 bytes 4 bytes 10 bytes
1717 The table length is the total size of the table, including the 4 bytes
1718 for the length information.
1720 The base address is the address of the first instruction generated
1721 for the source file.
1723 Each source statement entry has the following structure:
1725 <line number><statement position><address delta>
1726 4 bytes 2 bytes 4 bytes
1728 The line number is relative to the start of the file, starting with
1731 The statement position either -1 (0xFFFF) or the number of characters
1732 from the beginning of the line to the beginning of the statement.
1734 The address delta is the difference between the base address and
1735 the address of the first instruction for the statement.
1737 Note that we must copy the bytes from the packed table to our local
1738 variables before attempting to use them, to avoid alignment problems
1739 on some machines, particularly RISC processors.
1743 Does gdb expect the line numbers to be sorted? They are now by
1744 chance/luck, but are not required to be. (FIXME)
1746 The line with number 0 is unused, gdb apparently can discover the
1747 span of the last line some other way. How? (FIXME)
1751 decode_line_numbers (linetable
)
1756 unsigned long length
;
1761 if (linetable
!= NULL
)
1763 tblscan
= tblend
= linetable
;
1764 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1766 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1768 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1769 GET_UNSIGNED
, current_objfile
);
1770 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1772 while (tblscan
< tblend
)
1774 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1776 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1777 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1779 tblscan
+= SIZEOF_LINETBL_DELTA
;
1783 record_line (current_subfile
, line
, pc
);
1793 locval -- compute the value of a location attribute
1797 static int locval (char *loc)
1801 Given pointer to a string of bytes that define a location, compute
1802 the location and return the value.
1804 When computing values involving the current value of the frame pointer,
1805 the value zero is used, which results in a value relative to the frame
1806 pointer, rather than the absolute value. This is what GDB wants
1809 When the result is a register number, the global isreg flag is set,
1810 otherwise it is cleared. This is a kludge until we figure out a better
1811 way to handle the problem. Gdb's design does not mesh well with the
1812 DWARF notion of a location computing interpreter, which is a shame
1813 because the flexibility goes unused.
1817 Note that stack[0] is unused except as a default error return.
1818 Note that stack overflow is not yet handled.
1825 unsigned short nbytes
;
1826 unsigned short locsize
;
1827 auto long stack
[64];
1834 nbytes
= attribute_size (AT_location
);
1835 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
1837 end
= loc
+ locsize
;
1842 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
1845 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
1847 loc
+= SIZEOF_LOC_ATOM_CODE
;
1848 switch (loc_atom_code
)
1855 /* push register (number) */
1856 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1857 GET_UNSIGNED
, current_objfile
);
1858 loc
+= loc_value_size
;
1862 /* push value of register (number) */
1863 /* Actually, we compute the value as if register has 0 */
1865 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
1867 loc
+= loc_value_size
;
1870 stack
[++stacki
] = 0;
1874 stack
[++stacki
] = 0;
1875 SQUAWK (("BASEREG %d not handled!", regno
));
1879 /* push address (relocated address) */
1880 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1881 GET_UNSIGNED
, current_objfile
);
1882 loc
+= loc_value_size
;
1885 /* push constant (number) FIXME: signed or unsigned! */
1886 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1887 GET_SIGNED
, current_objfile
);
1888 loc
+= loc_value_size
;
1891 /* pop, deref and push 2 bytes (as a long) */
1892 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
1894 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1895 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
1897 case OP_ADD
: /* pop top 2 items, add, push result */
1898 stack
[stacki
- 1] += stack
[stacki
];
1903 return (stack
[stacki
]);
1910 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1914 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1918 When expanding a partial symbol table entry to a full symbol table
1919 entry, this is the function that gets called to read in the symbols
1920 for the compilation unit.
1922 Returns a pointer to the newly constructed symtab (which is now
1923 the new first one on the objfile's symtab list).
1926 static struct symtab
*
1927 read_ofile_symtab (pst
)
1928 struct partial_symtab
*pst
;
1930 struct cleanup
*back_to
;
1931 unsigned long lnsize
;
1934 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
1936 abfd
= pst
-> objfile
-> obfd
;
1937 current_objfile
= pst
-> objfile
;
1939 /* Allocate a buffer for the entire chunk of DIE's for this compilation
1940 unit, seek to the location in the file, and read in all the DIE's. */
1943 dbbase
= xmalloc (DBLENGTH(pst
));
1944 dbroff
= DBROFF(pst
);
1945 foffset
= DBFOFF(pst
) + dbroff
;
1946 baseaddr
= pst
-> addr
;
1947 if (bfd_seek (abfd
, foffset
, 0) ||
1948 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
1951 error ("can't read DWARF data");
1953 back_to
= make_cleanup (free
, dbbase
);
1955 /* If there is a line number table associated with this compilation unit
1956 then read the size of this fragment in bytes, from the fragment itself.
1957 Allocate a buffer for the fragment and read it in for future
1963 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1964 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
1965 sizeof (lnsizedata
)))
1967 error ("can't read DWARF line number table size");
1969 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
1970 GET_UNSIGNED
, pst
-> objfile
);
1971 lnbase
= xmalloc (lnsize
);
1972 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1973 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
1976 error ("can't read DWARF line numbers");
1978 make_cleanup (free
, lnbase
);
1981 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
1982 do_cleanups (back_to
);
1983 current_objfile
= NULL
;
1984 return (pst
-> objfile
-> symtabs
);
1991 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
1995 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
1999 Called once for each partial symbol table entry that needs to be
2000 expanded into a full symbol table entry.
2005 psymtab_to_symtab_1 (pst
)
2006 struct partial_symtab
*pst
;
2014 warning ("psymtab for %s already read in. Shouldn't happen.",
2019 /* Read in all partial symtabs on which this one is dependent */
2020 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2022 if (!pst
-> dependencies
[i
] -> readin
)
2024 /* Inform about additional files that need to be read in. */
2027 fputs_filtered (" ", stdout
);
2029 fputs_filtered ("and ", stdout
);
2031 printf_filtered ("%s...",
2032 pst
-> dependencies
[i
] -> filename
);
2034 fflush (stdout
); /* Flush output */
2036 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2039 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2041 pst
-> symtab
= read_ofile_symtab (pst
);
2044 printf_filtered ("%d DIE's, sorting...", diecount
);
2048 sort_symtab_syms (pst
-> symtab
);
2059 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2063 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2067 This is the DWARF support entry point for building a full symbol
2068 table entry from a partial symbol table entry. We are passed a
2069 pointer to the partial symbol table entry that needs to be expanded.
2074 dwarf_psymtab_to_symtab (pst
)
2075 struct partial_symtab
*pst
;
2082 warning ("psymtab for %s already read in. Shouldn't happen.",
2087 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2089 /* Print the message now, before starting serious work, to avoid
2090 disconcerting pauses. */
2093 printf_filtered ("Reading in symbols for %s...",
2098 psymtab_to_symtab_1 (pst
);
2100 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2101 we need to do an equivalent or is this something peculiar to
2103 Match with global symbols. This only needs to be done once,
2104 after all of the symtabs and dependencies have been read in.
2106 scan_file_globals (pst
-> objfile
);
2109 /* Finish up the verbose info message. */
2112 printf_filtered ("done.\n");
2124 init_psymbol_list -- initialize storage for partial symbols
2128 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2132 Initializes storage for all of the partial symbols that will be
2133 created by dwarf_build_psymtabs and subsidiaries.
2137 init_psymbol_list (objfile
, total_symbols
)
2138 struct objfile
*objfile
;
2141 /* Free any previously allocated psymbol lists. */
2143 if (objfile
-> global_psymbols
.list
)
2145 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2147 if (objfile
-> static_psymbols
.list
)
2149 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2152 /* Current best guess is that there are approximately a twentieth
2153 of the total symbols (in a debugging file) are global or static
2156 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2157 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2158 objfile
-> global_psymbols
.next
=
2159 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2160 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2161 * sizeof (struct partial_symbol
));
2162 objfile
-> static_psymbols
.next
=
2163 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2164 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2165 * sizeof (struct partial_symbol
));
2172 add_enum_psymbol -- add enumeration members to partial symbol table
2176 Given pointer to a DIE that is known to be for an enumeration,
2177 extract the symbolic names of the enumeration members and add
2178 partial symbols for them.
2182 add_enum_psymbol (dip
, objfile
)
2183 struct dieinfo
*dip
;
2184 struct objfile
*objfile
;
2188 unsigned short blocksz
;
2191 if ((scan
= dip
-> at_element_list
) != NULL
)
2193 if (dip
-> short_element_list
)
2195 nbytes
= attribute_size (AT_short_element_list
);
2199 nbytes
= attribute_size (AT_element_list
);
2201 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2203 listend
= scan
+ blocksz
;
2204 while (scan
< listend
)
2206 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2207 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2208 objfile
-> static_psymbols
, 0);
2209 scan
+= strlen (scan
) + 1;
2218 add_partial_symbol -- add symbol to partial symbol table
2222 Given a DIE, if it is one of the types that we want to
2223 add to a partial symbol table, finish filling in the die info
2224 and then add a partial symbol table entry for it.
2229 add_partial_symbol (dip
, objfile
)
2230 struct dieinfo
*dip
;
2231 struct objfile
*objfile
;
2233 switch (dip
-> die_tag
)
2235 case TAG_global_subroutine
:
2236 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2238 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2239 VAR_NAMESPACE
, LOC_BLOCK
,
2240 objfile
-> global_psymbols
,
2243 case TAG_global_variable
:
2244 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2246 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2247 VAR_NAMESPACE
, LOC_STATIC
,
2248 objfile
-> global_psymbols
,
2251 case TAG_subroutine
:
2252 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2253 VAR_NAMESPACE
, LOC_BLOCK
,
2254 objfile
-> static_psymbols
,
2257 case TAG_local_variable
:
2258 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2259 VAR_NAMESPACE
, LOC_STATIC
,
2260 objfile
-> static_psymbols
,
2264 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2265 VAR_NAMESPACE
, LOC_TYPEDEF
,
2266 objfile
-> static_psymbols
,
2269 case TAG_structure_type
:
2270 case TAG_union_type
:
2271 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2272 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2273 objfile
-> static_psymbols
,
2276 case TAG_enumeration_type
:
2279 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2280 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2281 objfile
-> static_psymbols
,
2284 add_enum_psymbol (dip
, objfile
);
2293 scan_partial_symbols -- scan DIE's within a single compilation unit
2297 Process the DIE's within a single compilation unit, looking for
2298 interesting DIE's that contribute to the partial symbol table entry
2299 for this compilation unit. Since we cannot follow any sibling
2300 chains without reading the complete DIE info for every DIE,
2301 it is probably faster to just sequentially check each one to
2302 see if it is one of the types we are interested in, and if so,
2303 then extract all the attributes info and generate a partial
2308 Don't attempt to add anonymous structures or unions since they have
2309 no name. Anonymous enumerations however are processed, because we
2310 want to extract their member names (the check for a tag name is
2313 Also, for variables and subroutines, check that this is the place
2314 where the actual definition occurs, rather than just a reference
2319 scan_partial_symbols (thisdie
, enddie
, objfile
)
2322 struct objfile
*objfile
;
2327 while (thisdie
< enddie
)
2329 basicdieinfo (&di
, thisdie
, objfile
);
2330 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2336 nextdie
= thisdie
+ di
.die_length
;
2337 /* To avoid getting complete die information for every die, we
2338 only do it (below) for the cases we are interested in. */
2341 case TAG_global_subroutine
:
2342 case TAG_subroutine
:
2343 case TAG_global_variable
:
2344 case TAG_local_variable
:
2345 completedieinfo (&di
, objfile
);
2346 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2348 add_partial_symbol (&di
, objfile
);
2352 case TAG_structure_type
:
2353 case TAG_union_type
:
2354 completedieinfo (&di
, objfile
);
2357 add_partial_symbol (&di
, objfile
);
2360 case TAG_enumeration_type
:
2361 completedieinfo (&di
, objfile
);
2362 add_partial_symbol (&di
, objfile
);
2374 scan_compilation_units -- build a psymtab entry for each compilation
2378 This is the top level dwarf parsing routine for building partial
2381 It scans from the beginning of the DWARF table looking for the first
2382 TAG_compile_unit DIE, and then follows the sibling chain to locate
2383 each additional TAG_compile_unit DIE.
2385 For each TAG_compile_unit DIE it creates a partial symtab structure,
2386 calls a subordinate routine to collect all the compilation unit's
2387 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2388 new partial symtab structure into the partial symbol table. It also
2389 records the appropriate information in the partial symbol table entry
2390 to allow the chunk of DIE's and line number table for this compilation
2391 unit to be located and re-read later, to generate a complete symbol
2392 table entry for the compilation unit.
2394 Thus it effectively partitions up a chunk of DIE's for multiple
2395 compilation units into smaller DIE chunks and line number tables,
2396 and associates them with a partial symbol table entry.
2400 If any compilation unit has no line number table associated with
2401 it for some reason (a missing at_stmt_list attribute, rather than
2402 just one with a value of zero, which is valid) then we ensure that
2403 the recorded file offset is zero so that the routine which later
2404 reads line number table fragments knows that there is no fragment
2414 scan_compilation_units (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2418 unsigned int dbfoff
;
2419 unsigned int lnoffset
;
2420 struct objfile
*objfile
;
2424 struct partial_symtab
*pst
;
2429 while (thisdie
< enddie
)
2431 basicdieinfo (&di
, thisdie
, objfile
);
2432 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2436 else if (di
.die_tag
!= TAG_compile_unit
)
2438 nextdie
= thisdie
+ di
.die_length
;
2442 completedieinfo (&di
, objfile
);
2443 if (di
.at_sibling
!= 0)
2445 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2449 nextdie
= thisdie
+ di
.die_length
;
2451 curoff
= thisdie
- dbbase
;
2452 culength
= nextdie
- thisdie
;
2453 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2455 /* First allocate a new partial symbol table structure */
2457 pst
= start_psymtab_common (objfile
, baseaddr
, di
.at_name
,
2459 objfile
-> global_psymbols
.next
,
2460 objfile
-> static_psymbols
.next
);
2462 pst
-> texthigh
= di
.at_high_pc
;
2463 pst
-> read_symtab_private
= (char *)
2464 obstack_alloc (&objfile
-> psymbol_obstack
,
2465 sizeof (struct dwfinfo
));
2466 DBFOFF (pst
) = dbfoff
;
2467 DBROFF (pst
) = curoff
;
2468 DBLENGTH (pst
) = culength
;
2469 LNFOFF (pst
) = curlnoffset
;
2470 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2472 /* Now look for partial symbols */
2474 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2476 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2477 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2478 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2479 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2480 sort_pst_symbols (pst
);
2481 /* If there is already a psymtab or symtab for a file of this name,
2482 remove it. (If there is a symtab, more drastic things also
2483 happen.) This happens in VxWorks. */
2484 free_named_symtabs (pst
-> filename
);
2494 new_symbol -- make a symbol table entry for a new symbol
2498 static struct symbol *new_symbol (struct dieinfo *dip,
2499 struct objfile *objfile)
2503 Given a pointer to a DWARF information entry, figure out if we need
2504 to make a symbol table entry for it, and if so, create a new entry
2505 and return a pointer to it.
2508 static struct symbol
*
2509 new_symbol (dip
, objfile
)
2510 struct dieinfo
*dip
;
2511 struct objfile
*objfile
;
2513 struct symbol
*sym
= NULL
;
2515 if (dip
-> at_name
!= NULL
)
2517 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2518 sizeof (struct symbol
));
2519 (void) memset (sym
, 0, sizeof (struct symbol
));
2520 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, &objfile
->symbol_obstack
);
2521 /* default assumptions */
2522 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2523 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2524 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2525 switch (dip
-> die_tag
)
2528 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2529 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2531 case TAG_global_subroutine
:
2532 case TAG_subroutine
:
2533 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2534 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2535 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2536 if (dip
-> die_tag
== TAG_global_subroutine
)
2538 add_symbol_to_list (sym
, &global_symbols
);
2542 add_symbol_to_list (sym
, list_in_scope
);
2545 case TAG_global_variable
:
2546 if (dip
-> at_location
!= NULL
)
2548 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2549 add_symbol_to_list (sym
, &global_symbols
);
2550 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2551 SYMBOL_VALUE (sym
) += baseaddr
;
2554 case TAG_local_variable
:
2555 if (dip
-> at_location
!= NULL
)
2557 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2558 add_symbol_to_list (sym
, list_in_scope
);
2561 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2565 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2569 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2570 SYMBOL_VALUE (sym
) += baseaddr
;
2574 case TAG_formal_parameter
:
2575 if (dip
-> at_location
!= NULL
)
2577 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2579 add_symbol_to_list (sym
, list_in_scope
);
2582 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2586 SYMBOL_CLASS (sym
) = LOC_ARG
;
2589 case TAG_unspecified_parameters
:
2590 /* From varargs functions; gdb doesn't seem to have any interest in
2591 this information, so just ignore it for now. (FIXME?) */
2593 case TAG_structure_type
:
2594 case TAG_union_type
:
2595 case TAG_enumeration_type
:
2596 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2597 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2598 add_symbol_to_list (sym
, list_in_scope
);
2601 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2602 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2603 add_symbol_to_list (sym
, list_in_scope
);
2606 /* Not a tag we recognize. Hopefully we aren't processing trash
2607 data, but since we must specifically ignore things we don't
2608 recognize, there is nothing else we should do at this point. */
2619 decode_mod_fund_type -- decode a modified fundamental type
2623 static struct type *decode_mod_fund_type (char *typedata)
2627 Decode a block of data containing a modified fundamental
2628 type specification. TYPEDATA is a pointer to the block,
2629 which starts with a length containing the size of the rest
2630 of the block. At the end of the block is a fundmental type
2631 code value that gives the fundamental type. Everything
2632 in between are type modifiers.
2634 We simply compute the number of modifiers and call the general
2635 function decode_modified_type to do the actual work.
2638 static struct type
*
2639 decode_mod_fund_type (typedata
)
2642 struct type
*typep
= NULL
;
2643 unsigned short modcount
;
2646 /* Get the total size of the block, exclusive of the size itself */
2648 nbytes
= attribute_size (AT_mod_fund_type
);
2649 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2652 /* Deduct the size of the fundamental type bytes at the end of the block. */
2654 modcount
-= attribute_size (AT_fund_type
);
2656 /* Now do the actual decoding */
2658 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2666 decode_mod_u_d_type -- decode a modified user defined type
2670 static struct type *decode_mod_u_d_type (char *typedata)
2674 Decode a block of data containing a modified user defined
2675 type specification. TYPEDATA is a pointer to the block,
2676 which consists of a two byte length, containing the size
2677 of the rest of the block. At the end of the block is a
2678 four byte value that gives a reference to a user defined type.
2679 Everything in between are type modifiers.
2681 We simply compute the number of modifiers and call the general
2682 function decode_modified_type to do the actual work.
2685 static struct type
*
2686 decode_mod_u_d_type (typedata
)
2689 struct type
*typep
= NULL
;
2690 unsigned short modcount
;
2693 /* Get the total size of the block, exclusive of the size itself */
2695 nbytes
= attribute_size (AT_mod_u_d_type
);
2696 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2699 /* Deduct the size of the reference type bytes at the end of the block. */
2701 modcount
-= attribute_size (AT_user_def_type
);
2703 /* Now do the actual decoding */
2705 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2713 decode_modified_type -- decode modified user or fundamental type
2717 static struct type *decode_modified_type (char *modifiers,
2718 unsigned short modcount, int mtype)
2722 Decode a modified type, either a modified fundamental type or
2723 a modified user defined type. MODIFIERS is a pointer to the
2724 block of bytes that define MODCOUNT modifiers. Immediately
2725 following the last modifier is a short containing the fundamental
2726 type or a long containing the reference to the user defined
2727 type. Which one is determined by MTYPE, which is either
2728 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2729 type we are generating.
2731 We call ourself recursively to generate each modified type,`
2732 until MODCOUNT reaches zero, at which point we have consumed
2733 all the modifiers and generate either the fundamental type or
2734 user defined type. When the recursion unwinds, each modifier
2735 is applied in turn to generate the full modified type.
2739 If we find a modifier that we don't recognize, and it is not one
2740 of those reserved for application specific use, then we issue a
2741 warning and simply ignore the modifier.
2745 We currently ignore MOD_const and MOD_volatile. (FIXME)
2749 static struct type
*
2750 decode_modified_type (modifiers
, modcount
, mtype
)
2752 unsigned int modcount
;
2755 struct type
*typep
= NULL
;
2756 unsigned short fundtype
;
2765 case AT_mod_fund_type
:
2766 nbytes
= attribute_size (AT_fund_type
);
2767 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2769 typep
= decode_fund_type (fundtype
);
2771 case AT_mod_u_d_type
:
2772 nbytes
= attribute_size (AT_user_def_type
);
2773 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2775 if ((typep
= lookup_utype (die_ref
)) == NULL
)
2777 typep
= alloc_utype (die_ref
, NULL
);
2781 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2782 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2788 modifier
= *modifiers
++;
2789 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2792 case MOD_pointer_to
:
2793 typep
= lookup_pointer_type (typep
);
2795 case MOD_reference_to
:
2796 typep
= lookup_reference_type (typep
);
2799 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2802 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2805 if (!(MOD_lo_user
<= (unsigned char) modifier
2806 && (unsigned char) modifier
<= MOD_hi_user
))
2808 SQUAWK (("unknown type modifier %u",
2809 (unsigned char) modifier
));
2821 decode_fund_type -- translate basic DWARF type to gdb base type
2825 Given an integer that is one of the fundamental DWARF types,
2826 translate it to one of the basic internal gdb types and return
2827 a pointer to the appropriate gdb type (a "struct type *").
2831 If we encounter a fundamental type that we are unprepared to
2832 deal with, and it is not in the range of those types defined
2833 as application specific types, then we issue a warning and
2834 treat the type as an "int".
2837 static struct type
*
2838 decode_fund_type (fundtype
)
2839 unsigned int fundtype
;
2841 struct type
*typep
= NULL
;
2847 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2850 case FT_boolean
: /* Was FT_set in AT&T version */
2851 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
2854 case FT_pointer
: /* (void *) */
2855 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2856 typep
= lookup_pointer_type (typep
);
2860 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
2863 case FT_signed_char
:
2864 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
2867 case FT_unsigned_char
:
2868 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
2872 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
2875 case FT_signed_short
:
2876 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
2879 case FT_unsigned_short
:
2880 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
2884 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2887 case FT_signed_integer
:
2888 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
2891 case FT_unsigned_integer
:
2892 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2896 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
2899 case FT_signed_long
:
2900 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
2903 case FT_unsigned_long
:
2904 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2908 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
2911 case FT_signed_long_long
:
2912 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
2915 case FT_unsigned_long_long
:
2916 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
2920 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2923 case FT_dbl_prec_float
:
2924 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
2927 case FT_ext_prec_float
:
2928 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
2932 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
2935 case FT_dbl_prec_complex
:
2936 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
2939 case FT_ext_prec_complex
:
2940 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
2945 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
2947 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
2948 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2958 create_name -- allocate a fresh copy of a string on an obstack
2962 Given a pointer to a string and a pointer to an obstack, allocates
2963 a fresh copy of the string on the specified obstack.
2968 create_name (name
, obstackp
)
2970 struct obstack
*obstackp
;
2975 length
= strlen (name
) + 1;
2976 newname
= (char *) obstack_alloc (obstackp
, length
);
2977 (void) strcpy (newname
, name
);
2985 basicdieinfo -- extract the minimal die info from raw die data
2989 void basicdieinfo (char *diep, struct dieinfo *dip,
2990 struct objfile *objfile)
2994 Given a pointer to raw DIE data, and a pointer to an instance of a
2995 die info structure, this function extracts the basic information
2996 from the DIE data required to continue processing this DIE, along
2997 with some bookkeeping information about the DIE.
2999 The information we absolutely must have includes the DIE tag,
3000 and the DIE length. If we need the sibling reference, then we
3001 will have to call completedieinfo() to process all the remaining
3004 Note that since there is no guarantee that the data is properly
3005 aligned in memory for the type of access required (indirection
3006 through anything other than a char pointer), and there is no
3007 guarantee that it is in the same byte order as the gdb host,
3008 we call a function which deals with both alignment and byte
3009 swapping issues. Possibly inefficient, but quite portable.
3011 We also take care of some other basic things at this point, such
3012 as ensuring that the instance of the die info structure starts
3013 out completely zero'd and that curdie is initialized for use
3014 in error reporting if we have a problem with the current die.
3018 All DIE's must have at least a valid length, thus the minimum
3019 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3020 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3021 are forced to be TAG_padding DIES.
3023 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3024 that if a padding DIE is used for alignment and the amount needed is
3025 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3026 enough to align to the next alignment boundry.
3030 basicdieinfo (dip
, diep
, objfile
)
3031 struct dieinfo
*dip
;
3033 struct objfile
*objfile
;
3036 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3038 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3039 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3041 if (dip
-> die_length
< SIZEOF_DIE_LENGTH
)
3043 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3045 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3047 dip
-> die_tag
= TAG_padding
;
3051 diep
+= SIZEOF_DIE_LENGTH
;
3052 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3061 completedieinfo -- finish reading the information for a given DIE
3065 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3069 Given a pointer to an already partially initialized die info structure,
3070 scan the raw DIE data and finish filling in the die info structure
3071 from the various attributes found.
3073 Note that since there is no guarantee that the data is properly
3074 aligned in memory for the type of access required (indirection
3075 through anything other than a char pointer), and there is no
3076 guarantee that it is in the same byte order as the gdb host,
3077 we call a function which deals with both alignment and byte
3078 swapping issues. Possibly inefficient, but quite portable.
3082 Each time we are called, we increment the diecount variable, which
3083 keeps an approximate count of the number of dies processed for
3084 each compilation unit. This information is presented to the user
3085 if the info_verbose flag is set.
3090 completedieinfo (dip
, objfile
)
3091 struct dieinfo
*dip
;
3092 struct objfile
*objfile
;
3094 char *diep
; /* Current pointer into raw DIE data */
3095 char *end
; /* Terminate DIE scan here */
3096 unsigned short attr
; /* Current attribute being scanned */
3097 unsigned short form
; /* Form of the attribute */
3098 int nbytes
; /* Size of next field to read */
3102 end
= diep
+ dip
-> die_length
;
3103 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3106 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3107 diep
+= SIZEOF_ATTRIBUTE
;
3108 if ((nbytes
= attribute_size (attr
)) == -1)
3110 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3117 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3121 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3125 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3129 dip
-> at_visibility
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3133 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3137 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3139 dip
-> has_at_stmt_list
= 1;
3142 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3144 dip
-> at_low_pc
+= baseaddr
;
3145 dip
-> has_at_low_pc
= 1;
3148 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3150 dip
-> at_high_pc
+= baseaddr
;
3153 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3156 case AT_user_def_type
:
3157 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3158 GET_UNSIGNED
, objfile
);
3161 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3165 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3169 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3173 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3177 dip
-> at_import
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3181 dip
-> at_location
= diep
;
3183 case AT_mod_fund_type
:
3184 dip
-> at_mod_fund_type
= diep
;
3186 case AT_subscr_data
:
3187 dip
-> at_subscr_data
= diep
;
3189 case AT_mod_u_d_type
:
3190 dip
-> at_mod_u_d_type
= diep
;
3192 case AT_element_list
:
3193 dip
-> at_element_list
= diep
;
3194 dip
-> short_element_list
= 0;
3196 case AT_short_element_list
:
3197 dip
-> at_element_list
= diep
;
3198 dip
-> short_element_list
= 1;
3200 case AT_discr_value
:
3201 dip
-> at_discr_value
= diep
;
3203 case AT_string_length
:
3204 dip
-> at_string_length
= diep
;
3207 dip
-> at_name
= diep
;
3210 dip
-> at_comp_dir
= diep
;
3213 dip
-> at_producer
= diep
;
3216 dip
-> at_frame_base
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3219 case AT_start_scope
:
3220 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3223 case AT_stride_size
:
3224 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3228 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3232 dip
-> at_prototyped
= diep
;
3235 /* Found an attribute that we are unprepared to handle. However
3236 it is specifically one of the design goals of DWARF that
3237 consumers should ignore unknown attributes. As long as the
3238 form is one that we recognize (so we know how to skip it),
3239 we can just ignore the unknown attribute. */
3242 form
= FORM_FROM_ATTR (attr
);
3256 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3259 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3262 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3265 diep
+= strlen (diep
) + 1;
3268 SQUAWK (("unknown attribute form (0x%x)", form
));
3269 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3280 target_to_host -- swap in target data to host
3284 target_to_host (char *from, int nbytes, int signextend,
3285 struct objfile *objfile)
3289 Given pointer to data in target format in FROM, a byte count for
3290 the size of the data in NBYTES, a flag indicating whether or not
3291 the data is signed in SIGNEXTEND, and a pointer to the current
3292 objfile in OBJFILE, convert the data to host format and return
3293 the converted value.
3297 FIXME: If we read data that is known to be signed, and expect to
3298 use it as signed data, then we need to explicitly sign extend the
3299 result until the bfd library is able to do this for us.
3303 static unsigned long
3304 target_to_host (from
, nbytes
, signextend
, objfile
)
3307 int signextend
; /* FIXME: Unused */
3308 struct objfile
*objfile
;
3310 unsigned long rtnval
;
3315 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3318 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3321 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3324 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3327 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3338 attribute_size -- compute size of data for a DWARF attribute
3342 static int attribute_size (unsigned int attr)
3346 Given a DWARF attribute in ATTR, compute the size of the first
3347 piece of data associated with this attribute and return that
3350 Returns -1 for unrecognized attributes.
3355 attribute_size (attr
)
3358 int nbytes
; /* Size of next data for this attribute */
3359 unsigned short form
; /* Form of the attribute */
3361 form
= FORM_FROM_ATTR (attr
);
3364 case FORM_STRING
: /* A variable length field is next */
3367 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3368 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3371 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3372 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3373 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3376 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3379 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3380 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3383 SQUAWK (("unknown attribute form (0x%x)", form
));