1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991 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: Currently we ignore host/target byte ordering and integer size
30 differences. Should remap data from external form to an internal form
31 before trying to use it.
33 FIXME: Resolve minor differences between what information we put in the
34 partial symbol table and what dbxread puts in. For example, we don't yet
35 put enum constants there. And dbxread seems to invent a lot of typedefs
36 we never see. Use the new printpsym command to see the partial symbol table
39 FIXME: Figure out a better way to tell gdb about the name of the function
40 contain the user's entry point (I.E. main())
42 FIXME: The current DWARF specification has a very strong bias towards
43 machines with 32-bit integers, as it assumes that many attributes of the
44 program (such as an address) will fit in such an integer. There are many
45 references in the spec to things that are 2, 4, or 8 bytes long. Given that
46 we will probably run into problems on machines where some of these assumptions
47 are invalid (64-bit ints for example), we don't bother at this time to try to
48 make this code more flexible and just use shorts, ints, and longs (and their
49 sizes) where it seems appropriate. I.E. we use a short int to hold DWARF
50 tags, and assume that the tag size in the file is the same as sizeof(short).
52 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
53 other things to work on, if you get bored. :-)
69 #include "elf/dwarf.h"
73 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
74 #define SQUAWK(stuff) dwarfwarn stuff
79 #ifndef R_FP /* FIXME */
80 #define R_FP 14 /* Kludge to get frame pointer register number */
83 typedef unsigned int DIEREF
; /* Reference to a DIE */
86 #define GCC_PRODUCER "GNU C "
89 #define STREQ(a,b) (strcmp(a,b)==0)
90 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
92 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
93 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
94 However, the Issue 2 DWARF specification from AT&T defines it as
95 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
96 For backwards compatibility with the AT&T compiler produced executables
97 we define AT_short_element_list for this variant. */
99 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
101 /* External variables referenced. */
103 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
104 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
105 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
106 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
107 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
108 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
109 extern int info_verbose
; /* From main.c; nonzero => verbose */
112 /* The DWARF debugging information consists of two major pieces,
113 one is a block of DWARF Information Entries (DIE's) and the other
114 is a line number table. The "struct dieinfo" structure contains
115 the information for a single DIE, the one currently being processed.
117 In order to make it easier to randomly access the attribute fields
118 of the current DIE, which are specifically unordered within the DIE
119 each DIE is scanned and an instance of the "struct dieinfo"
120 structure is initialized.
122 Initialization is done in two levels. The first, done by basicdieinfo(),
123 just initializes those fields that are vital to deciding whether or not
124 to use this DIE, how to skip past it, etc. The second, done by the
125 function completedieinfo(), fills in the rest of the information.
127 Attributes which have block forms are not interpreted at the time
128 the DIE is scanned, instead we just save pointers to the start
129 of their value fields.
131 Some fields have a flag <name>_p that is set when the value of the
132 field is valid (I.E. we found a matching attribute in the DIE). Since
133 we may want to test for the presence of some attributes in the DIE,
134 such as AT_low_pc, without restricting the values of the field,
135 we need someway to note that we found such an attribute.
142 char * die
; /* Pointer to the raw DIE data */
143 long dielength
; /* Length of the raw DIE data */
144 DIEREF dieref
; /* Offset of this DIE */
145 short dietag
; /* Tag for this DIE */
150 unsigned short at_fund_type
;
151 BLOCK
* at_mod_fund_type
;
152 long at_user_def_type
;
153 BLOCK
* at_mod_u_d_type
;
155 BLOCK
* at_subscr_data
;
159 BLOCK
* at_element_list
;
166 BLOCK
* at_discr_value
;
169 BLOCK
* at_string_length
;
177 unsigned int has_at_low_pc
:1;
178 unsigned int has_at_stmt_list
:1;
179 unsigned int short_element_list
:1;
182 static int diecount
; /* Approximate count of dies for compilation unit */
183 static struct dieinfo
*curdie
; /* For warnings and such */
185 static char *dbbase
; /* Base pointer to dwarf info */
186 static int dbroff
; /* Relative offset from start of .debug section */
187 static char *lnbase
; /* Base pointer to line section */
188 static int isreg
; /* Kludge to identify register variables */
189 static int offreg
; /* Kludge to identify basereg references */
191 static CORE_ADDR baseaddr
; /* Add to each symbol value */
193 /* Each partial symbol table entry contains a pointer to private data for the
194 read_symtab() function to use when expanding a partial symbol table entry
195 to a full symbol table entry. For DWARF debugging info, this data is
196 contained in the following structure and macros are provided for easy
197 access to the members given a pointer to a partial symbol table entry.
199 dbfoff Always the absolute file offset to the start of the ".debug"
200 section for the file containing the DIE's being accessed.
202 dbroff Relative offset from the start of the ".debug" access to the
203 first DIE to be accessed. When building the partial symbol
204 table, this value will be zero since we are accessing the
205 entire ".debug" section. When expanding a partial symbol
206 table entry, this value will be the offset to the first
207 DIE for the compilation unit containing the symbol that
208 triggers the expansion.
210 dblength The size of the chunk of DIE's being examined, in bytes.
212 lnfoff The absolute file offset to the line table fragment. Ignored
213 when building partial symbol tables, but used when expanding
214 them, and contains the absolute file offset to the fragment
215 of the ".line" section containing the line numbers for the
216 current compilation unit.
220 int dbfoff
; /* Absolute file offset to start of .debug section */
221 int dbroff
; /* Relative offset from start of .debug section */
222 int dblength
; /* Size of the chunk of DIE's being examined */
223 int lnfoff
; /* Absolute file offset to line table fragment */
226 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
227 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
228 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
229 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
231 /* The generic symbol table building routines have separate lists for
232 file scope symbols and all all other scopes (local scopes). So
233 we need to select the right one to pass to add_symbol_to_list().
234 We do it by keeping a pointer to the correct list in list_in_scope.
236 FIXME: The original dwarf code just treated the file scope as the first
237 local scope, and all other local scopes as nested local scopes, and worked
238 fine. Check to see if we really need to distinguish these in buildsym.c */
240 struct pending
**list_in_scope
= &file_symbols
;
242 /* DIES which have user defined types or modified user defined types refer to
243 other DIES for the type information. Thus we need to associate the offset
244 of a DIE for a user defined type with a pointer to the type information.
246 Originally this was done using a simple but expensive algorithm, with an
247 array of unsorted structures, each containing an offset/type-pointer pair.
248 This array was scanned linearly each time a lookup was done. The result
249 was that gdb was spending over half it's startup time munging through this
250 array of pointers looking for a structure that had the right offset member.
252 The second attempt used the same array of structures, but the array was
253 sorted using qsort each time a new offset/type was recorded, and a binary
254 search was used to find the type pointer for a given DIE offset. This was
255 even slower, due to the overhead of sorting the array each time a new
256 offset/type pair was entered.
258 The third attempt uses a fixed size array of type pointers, indexed by a
259 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
260 we can divide any DIE offset by 4 to obtain a unique index into this fixed
261 size array. Since each element is a 4 byte pointer, it takes exactly as
262 much memory to hold this array as to hold the DWARF info for a given
263 compilation unit. But it gets freed as soon as we are done with it. */
265 static struct type
**utypes
; /* Pointer to array of user type pointers */
266 static int numutypes
; /* Max number of user type pointers */
268 /* Forward declarations of static functions so we don't have to worry
269 about ordering within this file. The EXFUN macro may be slightly
270 misleading. Should probably be called DCLFUN instead, or something
271 more intuitive, since it can be used for both static and external
275 EXFUN (dwarfwarn
, (char *fmt DOTS
));
278 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
281 EXFUN (scan_compilation_units
,
282 (char *filename AND
char *thisdie AND
char *enddie
283 AND
unsigned int dbfoff AND
unsigned int lnoffset
284 AND
struct objfile
*objfile
));
286 static struct partial_symtab
*
287 EXFUN(dwarf_start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
288 AND
char *filename AND CORE_ADDR textlow
289 AND CORE_ADDR texthigh AND
int dbfoff
290 AND
int curoff AND
int culength AND
int lnfoff
291 AND
struct partial_symbol
*global_syms
292 AND
struct partial_symbol
*static_syms
));
295 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
298 EXFUN(init_psymbol_list
, (int total_symbols
));
301 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
304 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
307 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
310 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
312 static struct symtab
*
313 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
317 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
320 EXFUN(read_structure_scope
,
321 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
322 struct objfile
*objfile
));
325 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
328 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
331 EXFUN(dwarf_read_array_type
, (struct dieinfo
*dip
));
334 EXFUN(read_tag_pointer_type
, (struct dieinfo
*dip
));
337 EXFUN(read_subroutine_type
,
338 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
341 EXFUN(read_enumeration
,
342 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
346 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
347 struct objfile
*objfile
));
350 EXFUN(enum_type
, (struct dieinfo
*dip
));
353 EXFUN(decode_line_numbers
, (char *linetable
));
356 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
359 EXFUN(decode_mod_fund_type
, (char *typedata
));
362 EXFUN(decode_mod_u_d_type
, (char *typedata
));
365 EXFUN(decode_modified_type
,
366 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
369 EXFUN(decode_fund_type
, (unsigned short fundtype
));
372 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
375 EXFUN(lookup_utype
, (DIEREF dieref
));
378 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
380 static struct symbol
*
381 EXFUN(new_symbol
, (struct dieinfo
*dip
));
384 EXFUN(locval
, (char *loc
));
387 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
388 enum misc_function_type
));
391 EXFUN(compare_psymbols
,
392 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
399 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
403 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
404 int mainline, unsigned int dbfoff, unsigned int dbsize,
405 unsigned int lnoffset, unsigned int lnsize,
406 struct objfile *objfile)
410 This function is called upon to build partial symtabs from files
411 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
413 It is passed a file descriptor for an open file containing the DIES
414 and line number information, the corresponding filename for that
415 file, a base address for relocating the symbols, a flag indicating
416 whether or not this debugging information is from a "main symbol
417 table" rather than a shared library or dynamically linked file,
418 and file offset/size pairs for the DIE information and line number
428 DEFUN(dwarf_build_psymtabs
,
429 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
435 unsigned int dbfoff AND
436 unsigned int dbsize AND
437 unsigned int lnoffset AND
438 unsigned int lnsize AND
439 struct objfile
*objfile
)
441 struct cleanup
*back_to
;
443 dbbase
= xmalloc (dbsize
);
445 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
446 (read (desc
, dbbase
, dbsize
) != dbsize
))
449 error ("can't read DWARF data from '%s'", filename
);
451 back_to
= make_cleanup (free
, dbbase
);
453 /* If we are reinitializing, or if we have never loaded syms yet, init.
454 Since we have no idea how many DIES we are looking at, we just guess
455 some arbitrary value. */
457 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
459 init_psymbol_list (1024);
462 /* From this point on, we don't need to pass mainline around, so zap
463 baseaddr to zero if we don't need relocation. */
474 /* Follow the compilation unit sibling chain, building a partial symbol
475 table entry for each one. Save enough information about each compilation
476 unit to locate the full DWARF information later. */
478 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
479 dbfoff
, lnoffset
, objfile
);
481 do_cleanups (back_to
);
489 record_misc_function -- add entry to miscellaneous function vector
493 static void record_misc_function (char *name, CORE_ADDR address,
494 enum misc_function_type mf_type)
498 Given a pointer to the name of a symbol that should be added to the
499 miscellaneous function vector, and the address associated with that
500 symbol, records this information for later use in building the
501 miscellaneous function vector.
506 DEFUN(record_misc_function
, (name
, address
, mf_type
),
507 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
509 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
517 dwarfwarn -- issue a DWARF related warning
521 Issue warnings about DWARF related things that aren't serious enough
522 to warrant aborting with an error, but should not be ignored either.
523 This includes things like detectable corruption in DIE's, missing
524 DIE's, unimplemented features, etc.
526 In general, running across tags or attributes that we don't recognize
527 is not considered to be a problem and we should not issue warnings
532 We mostly follow the example of the error() routine, but without
533 returning to command level. It is arguable about whether warnings
534 should be issued at all, and if so, where they should go (stdout or
537 We assume that curdie is valid and contains at least the basic
538 information for the DIE where the problem was noticed.
544 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
550 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
551 if (curdie
-> at_name
)
553 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
555 vfprintf (stderr
, fmt
, ap
);
556 fprintf (stderr
, "\n");
571 fmt
= va_arg (ap
, char *);
573 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
574 if (curdie
-> at_name
)
576 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
578 vfprintf (stderr
, fmt
, ap
);
579 fprintf (stderr
, "\n");
590 compare_psymbols -- compare two partial symbols by name
594 Given pointer to two partial symbol table entries, compare
595 them by name and return -N, 0, or +N (ala strcmp). Typically
596 used by sorting routines like qsort().
600 This is a copy from dbxread.c. It should be moved to a generic
601 gdb file and made available for all psymtab builders (FIXME).
603 Does direct compare of first two characters before punting
604 and passing to strcmp for longer compares. Note that the
605 original version had a bug whereby two null strings or two
606 identically named one character strings would return the
607 comparison of memory following the null byte.
612 DEFUN(compare_psymbols
, (s1
, s2
),
613 struct partial_symbol
*s1 AND
614 struct partial_symbol
*s2
)
616 register char *st1
= SYMBOL_NAME (s1
);
617 register char *st2
= SYMBOL_NAME (s2
);
619 if ((st1
[0] - st2
[0]) || !st1
[0])
621 return (st1
[0] - st2
[0]);
623 else if ((st1
[1] - st2
[1]) || !st1
[1])
625 return (st1
[1] - st2
[1]);
629 return (strcmp (st1
+ 2, st2
+ 2));
637 read_lexical_block_scope -- process all dies in a lexical block
641 static void read_lexical_block_scope (struct dieinfo *dip,
642 char *thisdie, char *enddie)
646 Process all the DIES contained within a lexical block scope.
647 Start a new scope, process the dies, and then close the scope.
652 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
653 struct dieinfo
*dip AND
656 struct objfile
*objfile
)
658 register struct context_stack
*new;
660 (void) push_context (0, dip
-> at_low_pc
);
661 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
662 new = pop_context ();
663 if (local_symbols
!= NULL
)
665 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
668 local_symbols
= new -> locals
;
675 lookup_utype -- look up a user defined type from die reference
679 static type *lookup_utype (DIEREF dieref)
683 Given a DIE reference, lookup the user defined type associated with
684 that DIE, if it has been registered already. If not registered, then
685 return NULL. Alloc_utype() can be called to register an empty
686 type for this reference, which will be filled in later when the
687 actual referenced DIE is processed.
691 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
693 struct type
*type
= NULL
;
696 utypeidx
= (dieref
- dbroff
) / 4;
697 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
699 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
703 type
= *(utypes
+ utypeidx
);
713 alloc_utype -- add a user defined type for die reference
717 static type *alloc_utype (DIEREF dieref, struct type *utypep)
721 Given a die reference DIEREF, and a possible pointer to a user
722 defined type UTYPEP, register that this reference has a user
723 defined type and either use the specified type in UTYPEP or
724 make a new empty type that will be filled in later.
726 We should only be called after calling lookup_utype() to verify that
727 there is not currently a type registered for DIEREF.
731 DEFUN(alloc_utype
, (dieref
, utypep
),
738 utypeidx
= (dieref
- dbroff
) / 4;
739 typep
= utypes
+ utypeidx
;
740 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
742 utypep
= builtin_type_int
;
743 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
745 else if (*typep
!= NULL
)
748 SQUAWK (("internal error: dup user type allocation"));
754 utypep
= (struct type
*)
755 obstack_alloc (symbol_obstack
, sizeof (struct type
));
756 (void) memset (utypep
, 0, sizeof (struct type
));
767 decode_die_type -- return a type for a specified die
771 static struct type *decode_die_type (struct dieinfo *dip)
775 Given a pointer to a die information structure DIP, decode the
776 type of the die and return a pointer to the decoded type. All
777 dies without specific types default to type int.
781 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
783 struct type
*type
= NULL
;
785 if (dip
-> at_fund_type
!= 0)
787 type
= decode_fund_type (dip
-> at_fund_type
);
789 else if (dip
-> at_mod_fund_type
!= NULL
)
791 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
793 else if (dip
-> at_user_def_type
)
795 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
797 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
800 else if (dip
-> at_mod_u_d_type
)
802 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
806 type
= builtin_type_int
;
815 struct_type -- compute and return the type for a struct or union
819 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
820 char *enddie, struct objfile *objfile)
824 Given pointer to a die information structure for a die which
825 defines a union or structure (and MUST define one or the other),
826 and pointers to the raw die data that define the range of dies which
827 define the members, compute and return the user defined type for the
832 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
833 struct dieinfo
*dip AND
836 struct objfile
*objfile
)
840 struct nextfield
*next
;
843 struct nextfield
*list
= NULL
;
844 struct nextfield
*new;
851 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
853 /* No forward references created an empty type, so install one now */
854 type
= alloc_utype (dip
-> dieref
, NULL
);
856 INIT_CPLUS_SPECIFIC(type
);
857 switch (dip
-> dietag
)
859 case TAG_structure_type
:
860 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
864 TYPE_CODE (type
) = TYPE_CODE_UNION
;
868 /* Should never happen */
869 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
871 SQUAWK (("missing structure or union tag"));
874 /* Some compilers try to be helpful by inventing "fake" names for
875 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
876 Thanks, but no thanks... */
877 if (dip
-> at_name
!= NULL
878 && *dip
-> at_name
!= '~'
879 && *dip
-> at_name
!= '.')
881 TYPE_NAME (type
) = obconcat (tpart1
, " ", dip
-> at_name
);
883 if (dip
-> at_byte_size
!= 0)
885 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
887 thisdie
+= dip
-> dielength
;
888 while (thisdie
< enddie
)
890 basicdieinfo (&mbr
, thisdie
);
891 completedieinfo (&mbr
);
892 if (mbr
.dielength
<= sizeof (long))
896 else if (mbr
.at_sibling
!= 0)
898 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
902 nextdie
= thisdie
+ mbr
.dielength
;
907 /* Get space to record the next field's data. */
908 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
912 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
913 list
-> field
.type
= decode_die_type (&mbr
);
914 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
915 list
-> field
.bitsize
= 0;
919 process_dies (thisdie
, nextdie
, objfile
);
924 /* Now create the vector of fields, and record how big it is. We may
925 not even have any fields, if this DIE was generated due to a reference
926 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
927 set, which clues gdb in to the fact that it needs to search elsewhere
928 for the full structure definition. */
931 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
935 TYPE_NFIELDS (type
) = nfields
;
936 TYPE_FIELDS (type
) = (struct field
*)
937 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
938 /* Copy the saved-up fields into the field vector. */
939 for (n
= nfields
; list
; list
= list
-> next
)
941 TYPE_FIELD (type
, --n
) = list
-> field
;
951 read_structure_scope -- process all dies within struct or union
955 static void read_structure_scope (struct dieinfo *dip,
956 char *thisdie, char *enddie, struct objfile *objfile)
960 Called when we find the DIE that starts a structure or union
961 scope (definition) to process all dies that define the members
962 of the structure or union. DIP is a pointer to the die info
963 struct for the DIE that names the structure or union.
967 Note that we need to call struct_type regardless of whether or not
968 the DIE has an at_name attribute, since it might be an anonymous
969 structure or union. This gets the type entered into our set of
972 However, if the structure is incomplete (an opaque struct/union)
973 then suppress creating a symbol table entry for it since gdb only
974 wants to find the one with the complete definition. Note that if
975 it is complete, we just call new_symbol, which does it's own
976 checking about whether the struct/union is anonymous or not (and
977 suppresses creating a symbol table entry itself).
982 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
983 struct dieinfo
*dip AND
986 struct objfile
*objfile
)
991 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
992 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
994 if ((sym
= new_symbol (dip
)) != NULL
)
996 SYMBOL_TYPE (sym
) = type
;
1005 decode_array_element_type -- decode type of the array elements
1009 static struct type *decode_array_element_type (char *scan, char *end)
1013 As the last step in decoding the array subscript information for an
1014 array DIE, we need to decode the type of the array elements. We are
1015 passed a pointer to this last part of the subscript information and
1016 must return the appropriate type. If the type attribute is not
1017 recognized, just warn about the problem and return type int.
1020 static struct type
*
1021 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1026 unsigned short fundtype
;
1028 (void) memcpy (&attribute
, scan
, sizeof (short));
1029 scan
+= sizeof (short);
1033 (void) memcpy (&fundtype
, scan
, sizeof (short));
1034 typep
= decode_fund_type (fundtype
);
1036 case AT_mod_fund_type
:
1037 typep
= decode_mod_fund_type (scan
);
1039 case AT_user_def_type
:
1040 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1041 if ((typep
= lookup_utype (dieref
)) == NULL
)
1043 typep
= alloc_utype (dieref
, NULL
);
1046 case AT_mod_u_d_type
:
1047 typep
= decode_mod_u_d_type (scan
);
1050 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1051 typep
= builtin_type_int
;
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 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1092 struct type
*typep
= NULL
;
1093 struct type
*nexttype
;
1103 typep
= decode_array_element_type (scan
, end
);
1106 (void) memcpy (&fundtype
, scan
, sizeof (short));
1107 scan
+= sizeof (short);
1108 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1109 && fundtype
!= FT_unsigned_integer
)
1111 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1116 (void) memcpy (&lowbound
, scan
, sizeof (long));
1117 scan
+= sizeof (long);
1118 (void) memcpy (&highbound
, scan
, sizeof (long));
1119 scan
+= sizeof (long);
1120 nexttype
= decode_subscr_data (scan
, end
);
1121 if (nexttype
!= NULL
)
1123 typep
= (struct type
*)
1124 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1125 (void) memset (typep
, 0, sizeof (struct type
));
1126 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1127 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1128 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1129 TYPE_TARGET_TYPE (typep
) = nexttype
;
1140 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1143 SQUAWK (("unknown array subscript format %x", format
));
1153 dwarf_read_array_type -- read TAG_array_type DIE
1157 static void dwarf_read_array_type (struct dieinfo *dip)
1161 Extract all information from a TAG_array_type DIE and add to
1162 the user defined type vector.
1166 DEFUN(dwarf_read_array_type
, (dip
), struct dieinfo
*dip
)
1174 if (dip
-> at_ordering
!= ORD_row_major
)
1176 /* FIXME: Can gdb even handle column major arrays? */
1177 SQUAWK (("array not row major; not handled correctly"));
1179 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1181 (void) memcpy (&temp
, sub
, sizeof (short));
1182 subend
= sub
+ sizeof (short) + temp
;
1183 sub
+= sizeof (short);
1184 type
= decode_subscr_data (sub
, subend
);
1187 if ((utype
= lookup_utype (dip
-> dieref
)) == NULL
)
1189 utype
= alloc_utype (dip
-> dieref
, NULL
);
1191 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1192 TYPE_TARGET_TYPE (utype
) = builtin_type_int
;
1193 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1197 if ((utype
= lookup_utype (dip
-> dieref
)) == NULL
)
1199 (void) alloc_utype (dip
-> dieref
, type
);
1203 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1204 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1205 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1215 read_tag_pointer_type -- read TAG_pointer_type DIE
1219 static void read_tag_pointer_type (struct dieinfo *dip)
1223 Extract all information from a TAG_pointer_type DIE and add to
1224 the user defined type vector.
1228 DEFUN(read_tag_pointer_type
, (dip
), struct dieinfo
*dip
)
1236 type
= decode_die_type (dip
);
1237 if ((utype
= lookup_utype (dip
-> dieref
)) == NULL
)
1239 utype
= lookup_pointer_type (type
);
1240 (void) alloc_utype (dip
-> dieref
, utype
);
1244 TYPE_TARGET_TYPE (utype
) = type
;
1245 TYPE_POINTER_TYPE (type
) = utype
;
1247 /* We assume the machine has only one representation for pointers! */
1248 /* FIXME: This confuses host<->target data representations, and is a
1249 poor assumption besides. */
1251 TYPE_LENGTH (utype
) = sizeof (char *);
1252 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1260 read_subroutine_type -- process TAG_subroutine_type dies
1264 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1269 Handle DIES due to C code like:
1272 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1278 The parameter DIES are currently ignored. See if gdb has a way to
1279 include this info in it's type system, and decode them if so. Is
1280 this what the type structure's "arg_types" field is for? (FIXME)
1284 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1285 struct dieinfo
*dip AND
1289 struct type
*type
; /* Type that this function returns */
1290 struct type
*ftype
; /* Function that returns above type */
1292 /* Decode the type that this subroutine returns */
1294 type
= decode_die_type (dip
);
1296 /* Check to see if we already have a partially constructed user
1297 defined type for this DIE, from a forward reference. */
1299 if ((ftype
= lookup_utype (dip
-> dieref
)) == NULL
)
1301 /* This is the first reference to one of these types. Make
1302 a new one and place it in the user defined types. */
1303 ftype
= lookup_function_type (type
);
1304 (void) alloc_utype (dip
-> dieref
, ftype
);
1308 /* We have an existing partially constructed type, so bash it
1309 into the correct type. */
1310 TYPE_TARGET_TYPE (ftype
) = type
;
1311 TYPE_FUNCTION_TYPE (type
) = ftype
;
1312 TYPE_LENGTH (ftype
) = 1;
1313 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1321 read_enumeration -- process dies which define an enumeration
1325 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1330 Given a pointer to a die which begins an enumeration, process all
1331 the dies that define the members of the enumeration.
1335 Note that we need to call enum_type regardless of whether or not we
1336 have a symbol, since we might have an enum without a tag name (thus
1337 no symbol for the tagname).
1341 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1342 struct dieinfo
*dip AND
1349 type
= enum_type (dip
);
1350 if ((sym
= new_symbol (dip
)) != NULL
)
1352 SYMBOL_TYPE (sym
) = type
;
1360 enum_type -- decode and return a type for an enumeration
1364 static type *enum_type (struct dieinfo *dip)
1368 Given a pointer to a die information structure for the die which
1369 starts an enumeration, process all the dies that define the members
1370 of the enumeration and return a type pointer for the enumeration.
1372 At the same time, for each member of the enumeration, create a
1373 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1374 and give it the type of the enumeration itself.
1378 Note that the DWARF specification explicitly mandates that enum
1379 constants occur in reverse order from the source program order,
1380 for "consistency" and because this ordering is easier for many
1381 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1382 Entries). Because gdb wants to see the enum members in program
1383 source order, we have to ensure that the order gets reversed while
1384 we are processing them.
1387 static struct type
*
1388 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1392 struct nextfield
*next
;
1395 struct nextfield
*list
= NULL
;
1396 struct nextfield
*new;
1405 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1407 /* No forward references created an empty type, so install one now */
1408 type
= alloc_utype (dip
-> dieref
, NULL
);
1410 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1411 /* Some compilers try to be helpful by inventing "fake" names for
1412 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1413 Thanks, but no thanks... */
1414 if (dip
-> at_name
!= NULL
1415 && *dip
-> at_name
!= '~'
1416 && *dip
-> at_name
!= '.')
1418 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1420 if (dip
-> at_byte_size
!= 0)
1422 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1424 if ((scan
= dip
-> at_element_list
) != NULL
)
1426 if (dip
-> short_element_list
)
1428 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1429 listend
= scan
+ stemp
+ sizeof (stemp
);
1430 scan
+= sizeof (stemp
);
1434 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1435 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1436 scan
+= sizeof (ltemp
);
1438 while (scan
< listend
)
1440 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1443 list
-> field
.type
= NULL
;
1444 list
-> field
.bitsize
= 0;
1445 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1446 scan
+= sizeof (long);
1447 list
-> field
.name
= savestring (scan
, strlen (scan
));
1448 scan
+= strlen (scan
) + 1;
1450 /* Handcraft a new symbol for this enum member. */
1451 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1452 sizeof (struct symbol
));
1453 (void) memset (sym
, 0, sizeof (struct symbol
));
1454 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, 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 of 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 (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 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1504 struct dieinfo
*dip AND
1507 struct objfile
*objfile
)
1509 register struct context_stack
*new;
1511 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1513 entry_scope_lowpc
= dip
-> at_low_pc
;
1514 entry_scope_highpc
= dip
-> at_high_pc
;
1516 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1518 main_scope_lowpc
= dip
-> at_low_pc
;
1519 main_scope_highpc
= dip
-> at_high_pc
;
1521 new = push_context (0, dip
-> at_low_pc
);
1522 new -> name
= new_symbol (dip
);
1523 list_in_scope
= &local_symbols
;
1524 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1525 new = pop_context ();
1526 /* Make a block for the local symbols within. */
1527 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1528 new -> start_addr
, dip
-> at_high_pc
);
1529 list_in_scope
= &file_symbols
;
1536 read_file_scope -- process all dies within a file scope
1540 Process all dies within a given file scope. We are passed a
1541 pointer to the die information structure for the die which
1542 starts the file scope, and pointers into the raw die data which
1543 mark the range of dies within the file scope.
1545 When the partial symbol table is built, the file offset for the line
1546 number table for each compilation unit is saved in the partial symbol
1547 table entry for that compilation unit. As the symbols for each
1548 compilation unit are read, the line number table is read into memory
1549 and the variable lnbase is set to point to it. Thus all we have to
1550 do is use lnbase to access the line number table for the current
1555 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1556 struct dieinfo
*dip AND
1559 struct objfile
*objfile
)
1561 struct cleanup
*back_to
;
1562 struct symtab
*symtab
;
1564 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1566 startup_file_start
= dip
-> at_low_pc
;
1567 startup_file_end
= dip
-> at_high_pc
;
1569 if (dip
-> at_producer
!= NULL
)
1571 processing_gcc_compilation
=
1572 STREQN (dip
-> at_producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1574 numutypes
= (enddie
- thisdie
) / 4;
1575 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1576 back_to
= make_cleanup (free
, utypes
);
1577 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1578 start_symtab (dip
-> at_name
, NULL
, dip
-> at_low_pc
);
1579 decode_line_numbers (lnbase
);
1580 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1581 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1582 /* FIXME: The following may need to be expanded for other languages */
1583 switch (dip
-> at_language
)
1587 symtab
-> language
= language_c
;
1589 case LANG_C_PLUS_PLUS
:
1590 symtab
-> language
= language_cplus
;
1595 do_cleanups (back_to
);
1604 process_dies -- process a range of DWARF Information Entries
1608 static void process_dies (char *thisdie, char *enddie,
1609 struct objfile *objfile)
1613 Process all DIE's in a specified range. May be (and almost
1614 certainly will be) called recursively.
1618 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1619 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1624 while (thisdie
< enddie
)
1626 basicdieinfo (&di
, thisdie
);
1627 if (di
.dielength
< sizeof (long))
1631 else if (di
.dietag
== TAG_padding
)
1633 nextdie
= thisdie
+ di
.dielength
;
1637 completedieinfo (&di
);
1638 if (di
.at_sibling
!= 0)
1640 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1644 nextdie
= thisdie
+ di
.dielength
;
1648 case TAG_compile_unit
:
1649 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1651 case TAG_global_subroutine
:
1652 case TAG_subroutine
:
1653 if (di
.has_at_low_pc
)
1655 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1658 case TAG_lexical_block
:
1659 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1661 case TAG_structure_type
:
1662 case TAG_union_type
:
1663 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1665 case TAG_enumeration_type
:
1666 read_enumeration (&di
, thisdie
, nextdie
);
1668 case TAG_subroutine_type
:
1669 read_subroutine_type (&di
, thisdie
, nextdie
);
1671 case TAG_array_type
:
1672 dwarf_read_array_type (&di
);
1674 case TAG_pointer_type
:
1675 read_tag_pointer_type (&di
);
1678 (void) new_symbol (&di
);
1690 decode_line_numbers -- decode a line number table fragment
1694 static void decode_line_numbers (char *tblscan, char *tblend,
1695 long length, long base, long line, long pc)
1699 Translate the DWARF line number information to gdb form.
1701 The ".line" section contains one or more line number tables, one for
1702 each ".line" section from the objects that were linked.
1704 The AT_stmt_list attribute for each TAG_source_file entry in the
1705 ".debug" section contains the offset into the ".line" section for the
1706 start of the table for that file.
1708 The table itself has the following structure:
1710 <table length><base address><source statement entry>
1711 4 bytes 4 bytes 10 bytes
1713 The table length is the total size of the table, including the 4 bytes
1714 for the length information.
1716 The base address is the address of the first instruction generated
1717 for the source file.
1719 Each source statement entry has the following structure:
1721 <line number><statement position><address delta>
1722 4 bytes 2 bytes 4 bytes
1724 The line number is relative to the start of the file, starting with
1727 The statement position either -1 (0xFFFF) or the number of characters
1728 from the beginning of the line to the beginning of the statement.
1730 The address delta is the difference between the base address and
1731 the address of the first instruction for the statement.
1733 Note that we must copy the bytes from the packed table to our local
1734 variables before attempting to use them, to avoid alignment problems
1735 on some machines, particularly RISC processors.
1739 Does gdb expect the line numbers to be sorted? They are now by
1740 chance/luck, but are not required to be. (FIXME)
1742 The line with number 0 is unused, gdb apparently can discover the
1743 span of the last line some other way. How? (FIXME)
1747 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
1756 if (linetable
!= NULL
)
1758 tblscan
= tblend
= linetable
;
1759 (void) memcpy (&length
, tblscan
, sizeof (long));
1760 tblscan
+= sizeof (long);
1762 (void) memcpy (&base
, tblscan
, sizeof (long));
1764 tblscan
+= sizeof (long);
1765 while (tblscan
< tblend
)
1767 (void) memcpy (&line
, tblscan
, sizeof (long));
1768 tblscan
+= sizeof (long) + sizeof (short);
1769 (void) memcpy (&pc
, tblscan
, sizeof (long));
1770 tblscan
+= sizeof (long);
1774 record_line (current_subfile
, line
, pc
);
1784 locval -- compute the value of a location attribute
1788 static int locval (char *loc)
1792 Given pointer to a string of bytes that define a location, compute
1793 the location and return the value.
1795 When computing values involving the current value of the frame pointer,
1796 the value zero is used, which results in a value relative to the frame
1797 pointer, rather than the absolute value. This is what GDB wants
1800 When the result is a register number, the global isreg flag is set,
1801 otherwise it is cleared. This is a kludge until we figure out a better
1802 way to handle the problem. Gdb's design does not mesh well with the
1803 DWARF notion of a location computing interpreter, which is a shame
1804 because the flexibility goes unused.
1808 Note that stack[0] is unused except as a default error return.
1809 Note that stack overflow is not yet handled.
1813 DEFUN(locval
, (loc
), char *loc
)
1815 unsigned short nbytes
;
1821 (void) memcpy (&nbytes
, loc
, sizeof (short));
1822 end
= loc
+ sizeof (short) + nbytes
;
1827 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
1835 /* push register (number) */
1836 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1840 /* push value of register (number) */
1841 /* Actually, we compute the value as if register has 0 */
1843 (void) memcpy (®no
, loc
, sizeof (long));
1846 stack
[++stacki
] = 0;
1850 stack
[++stacki
] = 0;
1851 SQUAWK (("BASEREG %d not handled!", regno
));
1855 /* push address (relocated address) */
1856 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1859 /* push constant (number) */
1860 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1863 /* pop, deref and push 2 bytes (as a long) */
1864 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
1866 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1867 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
1869 case OP_ADD
: /* pop top 2 items, add, push result */
1870 stack
[stacki
- 1] += stack
[stacki
];
1875 return (stack
[stacki
]);
1882 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1886 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1892 static struct symtab
*
1893 DEFUN(read_ofile_symtab
, (pst
),
1894 struct partial_symtab
*pst
)
1896 struct cleanup
*back_to
;
1899 bfd
*abfd
= pst
->objfile
->obfd
;
1901 /* Allocate a buffer for the entire chunk of DIE's for this compilation
1902 unit, seek to the location in the file, and read in all the DIE's. */
1905 dbbase
= xmalloc (DBLENGTH(pst
));
1906 dbroff
= DBROFF(pst
);
1907 foffset
= DBFOFF(pst
) + dbroff
;
1908 baseaddr
= pst
-> addr
;
1909 if (bfd_seek (abfd
, foffset
, 0) ||
1910 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
1913 error ("can't read DWARF data");
1915 back_to
= make_cleanup (free
, dbbase
);
1917 /* If there is a line number table associated with this compilation unit
1918 then read the first long word from the line number table fragment, which
1919 contains the size of the fragment in bytes (including the long word
1920 itself). Allocate a buffer for the fragment and read it in for future
1926 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1927 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
1929 error ("can't read DWARF line number table size");
1931 lnbase
= xmalloc (lnsize
);
1932 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1933 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
1936 error ("can't read DWARF line numbers");
1938 make_cleanup (free
, lnbase
);
1941 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
1942 do_cleanups (back_to
);
1943 return (symtab_list
);
1950 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
1954 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
1958 Called once for each partial symbol table entry that needs to be
1959 expanded into a full symbol table entry.
1964 DEFUN(psymtab_to_symtab_1
,
1966 struct partial_symtab
*pst
)
1976 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1981 /* Read in all partial symtabs on which this one is dependent */
1982 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
1983 if (!pst
-> dependencies
[i
] -> readin
)
1985 /* Inform about additional files that need to be read in. */
1988 fputs_filtered (" ", stdout
);
1990 fputs_filtered ("and ", stdout
);
1992 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
1993 wrap_here (""); /* Flush output */
1996 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
1999 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2001 pst
-> symtab
= read_ofile_symtab (pst
);
2004 printf_filtered ("%d DIE's, sorting...", diecount
);
2007 sort_symtab_syms (pst
-> symtab
);
2016 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2020 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2024 This is the DWARF support entry point for building a full symbol
2025 table entry from a partial symbol table entry. We are passed a
2026 pointer to the partial symbol table entry that needs to be expanded.
2031 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2040 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2045 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2047 /* Print the message now, before starting serious work, to avoid
2048 disconcerting pauses. */
2051 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2055 psymtab_to_symtab_1 (pst
);
2057 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2058 we need to do an equivalent or is this something peculiar to
2059 stabs/a.out format. */
2060 /* Match with global symbols. This only needs to be done once,
2061 after all of the symtabs and dependencies have been read in. */
2062 scan_file_globals ();
2065 /* Finish up the debug error message. */
2068 printf_filtered ("done.\n");
2077 init_psymbol_list -- initialize storage for partial symbols
2081 static void init_psymbol_list (int total_symbols)
2085 Initializes storage for all of the partial symbols that will be
2086 created by dwarf_build_psymtabs and subsidiaries.
2090 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2092 /* Free any previously allocated psymbol lists. */
2094 if (global_psymbols
.list
)
2096 free (global_psymbols
.list
);
2098 if (static_psymbols
.list
)
2100 free (static_psymbols
.list
);
2103 /* Current best guess is that there are approximately a twentieth
2104 of the total symbols (in a debugging file) are global or static
2107 global_psymbols
.size
= total_symbols
/ 10;
2108 static_psymbols
.size
= total_symbols
/ 10;
2109 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2110 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2111 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2112 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2119 dwarf_start_psymtab -- allocate and fill a partial symtab entry
2123 Allocate and partially fill a partial symtab. It will be completely
2124 filled at the end of the symbol list.
2126 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2127 ADDR is the address relative to which its symbols are (incremental)
2128 or 0 (normal). FILENAME is the name of the compilation unit that
2129 these symbols were defined in, and they appear starting a address
2130 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2131 the full symbols can be read for compilation unit FILENAME.
2132 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2137 static struct partial_symtab
*
2138 DEFUN(dwarf_start_psymtab
,
2139 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2140 culength
, lnfoff
, global_syms
, static_syms
),
2141 struct objfile
*objfile AND
2144 CORE_ADDR textlow AND
2145 CORE_ADDR texthigh AND
2150 struct partial_symbol
*global_syms AND
2151 struct partial_symbol
*static_syms
)
2153 struct partial_symtab
*result
;
2155 result
= (struct partial_symtab
*)
2156 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2157 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2158 result
-> addr
= addr
;
2159 result
-> objfile
= objfile
;
2160 result
-> filename
= create_name (filename
, psymbol_obstack
);
2161 result
-> textlow
= textlow
;
2162 result
-> texthigh
= texthigh
;
2163 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2164 sizeof (struct dwfinfo
));
2165 DBFOFF (result
) = dbfoff
;
2166 DBROFF (result
) = curoff
;
2167 DBLENGTH (result
) = culength
;
2168 LNFOFF (result
) = lnfoff
;
2169 result
-> readin
= 0;
2170 result
-> symtab
= NULL
;
2171 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2172 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2173 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2175 result
->n_global_syms
= 0;
2176 result
->n_static_syms
= 0;
2185 add_enum_psymbol -- add enumeration members to partial symbol table
2189 Given pointer to a DIE that is known to be for an enumeration,
2190 extract the symbolic names of the enumeration members and add
2191 partial symbols for them.
2195 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2202 if ((scan
= dip
-> at_element_list
) != NULL
)
2204 if (dip
-> short_element_list
)
2206 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2207 listend
= scan
+ stemp
+ sizeof (stemp
);
2208 scan
+= sizeof (stemp
);
2212 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2213 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2214 scan
+= sizeof (ltemp
);
2216 while (scan
< listend
)
2218 scan
+= sizeof (long);
2219 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2220 static_psymbols
, 0);
2221 scan
+= strlen (scan
) + 1;
2230 add_partial_symbol -- add symbol to partial symbol table
2234 Given a DIE, if it is one of the types that we want to
2235 add to a partial symbol table, finish filling in the die info
2236 and then add a partial symbol table entry for it.
2241 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2243 switch (dip
-> dietag
)
2245 case TAG_global_subroutine
:
2246 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2247 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2248 VAR_NAMESPACE
, LOC_BLOCK
, global_psymbols
,
2251 case TAG_global_variable
:
2252 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2254 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2255 VAR_NAMESPACE
, LOC_STATIC
, global_psymbols
,
2258 case TAG_subroutine
:
2259 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2260 VAR_NAMESPACE
, LOC_BLOCK
, static_psymbols
,
2263 case TAG_local_variable
:
2264 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2265 VAR_NAMESPACE
, LOC_STATIC
, static_psymbols
,
2269 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2270 VAR_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2273 case TAG_structure_type
:
2274 case TAG_union_type
:
2275 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2276 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2279 case TAG_enumeration_type
:
2282 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2283 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2286 add_enum_psymbol (dip
);
2295 scan_partial_symbols -- scan DIE's within a single compilation unit
2299 Process the DIE's within a single compilation unit, looking for
2300 interesting DIE's that contribute to the partial symbol table entry
2301 for this compilation unit. Since we cannot follow any sibling
2302 chains without reading the complete DIE info for every DIE,
2303 it is probably faster to just sequentially check each one to
2304 see if it is one of the types we are interested in, and if so,
2305 then extract all the attributes info and generate a partial
2310 Don't attempt to add anonymous structures or unions since they have
2311 no name. Anonymous enumerations however are processed, because we
2312 want to extract their member names (the check for a tag name is
2315 Also, for variables and subroutines, check that this is the place
2316 where the actual definition occurs, rather than just a reference
2321 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2326 while (thisdie
< enddie
)
2328 basicdieinfo (&di
, thisdie
);
2329 if (di
.dielength
< sizeof (long))
2335 nextdie
= thisdie
+ di
.dielength
;
2336 /* To avoid getting complete die information for every die, we
2337 only do it (below) for the cases we are interested in. */
2340 case TAG_global_subroutine
:
2341 case TAG_subroutine
:
2342 case TAG_global_variable
:
2343 case TAG_local_variable
:
2344 completedieinfo (&di
);
2345 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2347 add_partial_symbol (&di
);
2351 case TAG_structure_type
:
2352 case TAG_union_type
:
2353 completedieinfo (&di
);
2356 add_partial_symbol (&di
);
2359 case TAG_enumeration_type
:
2360 completedieinfo (&di
);
2361 add_partial_symbol (&di
);
2373 scan_compilation_units -- build a psymtab entry for each compilation
2377 This is the top level dwarf parsing routine for building partial
2380 It scans from the beginning of the DWARF table looking for the first
2381 TAG_compile_unit DIE, and then follows the sibling chain to locate
2382 each additional TAG_compile_unit DIE.
2384 For each TAG_compile_unit DIE it creates a partial symtab structure,
2385 calls a subordinate routine to collect all the compilation unit's
2386 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2387 new partial symtab structure into the partial symbol table. It also
2388 records the appropriate information in the partial symbol table entry
2389 to allow the chunk of DIE's and line number table for this compilation
2390 unit to be located and re-read later, to generate a complete symbol
2391 table entry for the compilation unit.
2393 Thus it effectively partitions up a chunk of DIE's for multiple
2394 compilation units into smaller DIE chunks and line number tables,
2395 and associates them with a partial symbol table entry.
2399 If any compilation unit has no line number table associated with
2400 it for some reason (a missing at_stmt_list attribute, rather than
2401 just one with a value of zero, which is valid) then we ensure that
2402 the recorded file offset is zero so that the routine which later
2403 reads line number table fragments knows that there is no fragment
2413 DEFUN(scan_compilation_units
,
2414 (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2418 unsigned int dbfoff AND
2419 unsigned int lnoffset AND
2420 struct objfile
*objfile
)
2424 struct partial_symtab
*pst
;
2429 while (thisdie
< enddie
)
2431 basicdieinfo (&di
, thisdie
);
2432 if (di
.dielength
< sizeof (long))
2436 else if (di
.dietag
!= TAG_compile_unit
)
2438 nextdie
= thisdie
+ di
.dielength
;
2442 completedieinfo (&di
);
2443 if (di
.at_sibling
!= 0)
2445 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2449 nextdie
= thisdie
+ di
.dielength
;
2451 curoff
= thisdie
- dbbase
;
2452 culength
= nextdie
- thisdie
;
2453 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2454 pst
= dwarf_start_psymtab (objfile
, baseaddr
, di
.at_name
,
2457 dbfoff
, curoff
, culength
, curlnoffset
,
2458 global_psymbols
.next
,
2459 static_psymbols
.next
);
2460 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2461 pst
-> n_global_syms
= global_psymbols
.next
-
2462 (global_psymbols
.list
+ pst
-> globals_offset
);
2463 pst
-> n_static_syms
= static_psymbols
.next
-
2464 (static_psymbols
.list
+ pst
-> statics_offset
);
2465 /* Sort the global list; don't sort the static list */
2466 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2467 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2469 /* If there is already a psymtab or symtab for a file of this name,
2470 remove it. (If there is a symtab, more drastic things also
2471 happen.) This happens in VxWorks. */
2472 free_named_symtabs (pst
-> filename
);
2473 /* Place the partial symtab on the partial symtab list */
2474 pst
-> next
= partial_symtab_list
;
2475 partial_symtab_list
= pst
;
2485 new_symbol -- make a symbol table entry for a new symbol
2489 static struct symbol *new_symbol (struct dieinfo *dip)
2493 Given a pointer to a DWARF information entry, figure out if we need
2494 to make a symbol table entry for it, and if so, create a new entry
2495 and return a pointer to it.
2498 static struct symbol
*
2499 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2501 struct symbol
*sym
= NULL
;
2503 if (dip
-> at_name
!= NULL
)
2505 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2506 sizeof (struct symbol
));
2507 (void) memset (sym
, 0, sizeof (struct symbol
));
2508 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2509 /* default assumptions */
2510 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2511 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2512 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2513 switch (dip
-> dietag
)
2516 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2517 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2519 case TAG_global_subroutine
:
2520 case TAG_subroutine
:
2521 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2522 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2523 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2524 if (dip
-> dietag
== TAG_global_subroutine
)
2526 add_symbol_to_list (sym
, &global_symbols
);
2530 add_symbol_to_list (sym
, list_in_scope
);
2533 case TAG_global_variable
:
2534 if (dip
-> at_location
!= NULL
)
2536 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2537 add_symbol_to_list (sym
, &global_symbols
);
2538 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2539 SYMBOL_VALUE (sym
) += baseaddr
;
2542 case TAG_local_variable
:
2543 if (dip
-> at_location
!= NULL
)
2545 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2546 add_symbol_to_list (sym
, list_in_scope
);
2549 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2553 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2557 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2558 SYMBOL_VALUE (sym
) += baseaddr
;
2562 case TAG_formal_parameter
:
2563 if (dip
-> at_location
!= NULL
)
2565 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2567 add_symbol_to_list (sym
, list_in_scope
);
2570 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2574 SYMBOL_CLASS (sym
) = LOC_ARG
;
2577 case TAG_unspecified_parameters
:
2578 /* From varargs functions; gdb doesn't seem to have any interest in
2579 this information, so just ignore it for now. (FIXME?) */
2581 case TAG_structure_type
:
2582 case TAG_union_type
:
2583 case TAG_enumeration_type
:
2584 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2585 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2586 add_symbol_to_list (sym
, list_in_scope
);
2589 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2590 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2591 add_symbol_to_list (sym
, list_in_scope
);
2594 /* Not a tag we recognize. Hopefully we aren't processing trash
2595 data, but since we must specifically ignore things we don't
2596 recognize, there is nothing else we should do at this point. */
2607 decode_mod_fund_type -- decode a modified fundamental type
2611 static struct type *decode_mod_fund_type (char *typedata)
2615 Decode a block of data containing a modified fundamental
2616 type specification. TYPEDATA is a pointer to the block,
2617 which consists of a two byte length, containing the size
2618 of the rest of the block. At the end of the block is a
2619 two byte value that gives the fundamental type. Everything
2620 in between are type modifiers.
2622 We simply compute the number of modifiers and call the general
2623 function decode_modified_type to do the actual work.
2626 static struct type
*
2627 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
2629 struct type
*typep
= NULL
;
2630 unsigned short modcount
;
2631 unsigned char *modifiers
;
2633 /* Get the total size of the block, exclusive of the size itself */
2634 (void) memcpy (&modcount
, typedata
, sizeof (short));
2635 /* Deduct the size of the fundamental type bytes at the end of the block. */
2636 modcount
-= sizeof (short);
2637 /* Skip over the two size bytes at the beginning of the block. */
2638 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2639 /* Now do the actual decoding */
2640 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
2648 decode_mod_u_d_type -- decode a modified user defined type
2652 static struct type *decode_mod_u_d_type (char *typedata)
2656 Decode a block of data containing a modified user defined
2657 type specification. TYPEDATA is a pointer to the block,
2658 which consists of a two byte length, containing the size
2659 of the rest of the block. At the end of the block is a
2660 four byte value that gives a reference to a user defined type.
2661 Everything in between are type modifiers.
2663 We simply compute the number of modifiers and call the general
2664 function decode_modified_type to do the actual work.
2667 static struct type
*
2668 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
2670 struct type
*typep
= NULL
;
2671 unsigned short modcount
;
2672 unsigned char *modifiers
;
2674 /* Get the total size of the block, exclusive of the size itself */
2675 (void) memcpy (&modcount
, typedata
, sizeof (short));
2676 /* Deduct the size of the reference type bytes at the end of the block. */
2677 modcount
-= sizeof (long);
2678 /* Skip over the two size bytes at the beginning of the block. */
2679 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2680 /* Now do the actual decoding */
2681 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
2689 decode_modified_type -- decode modified user or fundamental type
2693 static struct type *decode_modified_type (unsigned char *modifiers,
2694 unsigned short modcount, int mtype)
2698 Decode a modified type, either a modified fundamental type or
2699 a modified user defined type. MODIFIERS is a pointer to the
2700 block of bytes that define MODCOUNT modifiers. Immediately
2701 following the last modifier is a short containing the fundamental
2702 type or a long containing the reference to the user defined
2703 type. Which one is determined by MTYPE, which is either
2704 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2705 type we are generating.
2707 We call ourself recursively to generate each modified type,`
2708 until MODCOUNT reaches zero, at which point we have consumed
2709 all the modifiers and generate either the fundamental type or
2710 user defined type. When the recursion unwinds, each modifier
2711 is applied in turn to generate the full modified type.
2715 If we find a modifier that we don't recognize, and it is not one
2716 of those reserved for application specific use, then we issue a
2717 warning and simply ignore the modifier.
2721 We currently ignore MOD_const and MOD_volatile. (FIXME)
2725 static struct type
*
2726 DEFUN(decode_modified_type
,
2727 (modifiers
, modcount
, mtype
),
2728 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
2730 struct type
*typep
= NULL
;
2731 unsigned short fundtype
;
2733 unsigned char modifier
;
2739 case AT_mod_fund_type
:
2740 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
2741 typep
= decode_fund_type (fundtype
);
2743 case AT_mod_u_d_type
:
2744 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
2745 if ((typep
= lookup_utype (dieref
)) == NULL
)
2747 typep
= alloc_utype (dieref
, NULL
);
2751 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2752 typep
= builtin_type_int
;
2758 modifier
= *modifiers
++;
2759 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2762 case MOD_pointer_to
:
2763 typep
= lookup_pointer_type (typep
);
2765 case MOD_reference_to
:
2766 typep
= lookup_reference_type (typep
);
2769 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2772 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2775 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
2777 SQUAWK (("unknown type modifier %u", modifier
));
2789 decode_fund_type -- translate basic DWARF type to gdb base type
2793 Given an integer that is one of the fundamental DWARF types,
2794 translate it to one of the basic internal gdb types and return
2795 a pointer to the appropriate gdb type (a "struct type *").
2799 If we encounter a fundamental type that we are unprepared to
2800 deal with, and it is not in the range of those types defined
2801 as application specific types, then we issue a warning and
2802 treat the type as builtin_type_int.
2805 static struct type
*
2806 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
2808 struct type
*typep
= NULL
;
2814 typep
= builtin_type_void
;
2817 case FT_pointer
: /* (void *) */
2818 typep
= lookup_pointer_type (builtin_type_void
);
2822 case FT_signed_char
:
2823 typep
= builtin_type_char
;
2827 case FT_signed_short
:
2828 typep
= builtin_type_short
;
2832 case FT_signed_integer
:
2833 case FT_boolean
: /* Was FT_set in AT&T version */
2834 typep
= builtin_type_int
;
2838 case FT_signed_long
:
2839 typep
= builtin_type_long
;
2843 typep
= builtin_type_float
;
2846 case FT_dbl_prec_float
:
2847 typep
= builtin_type_double
;
2850 case FT_unsigned_char
:
2851 typep
= builtin_type_unsigned_char
;
2854 case FT_unsigned_short
:
2855 typep
= builtin_type_unsigned_short
;
2858 case FT_unsigned_integer
:
2859 typep
= builtin_type_unsigned_int
;
2862 case FT_unsigned_long
:
2863 typep
= builtin_type_unsigned_long
;
2866 case FT_ext_prec_float
:
2867 typep
= builtin_type_long_double
;
2871 typep
= builtin_type_complex
;
2874 case FT_dbl_prec_complex
:
2875 typep
= builtin_type_double_complex
;
2879 case FT_signed_long_long
:
2880 typep
= builtin_type_long_long
;
2883 case FT_unsigned_long_long
:
2884 typep
= builtin_type_unsigned_long_long
;
2889 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
2891 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
2892 typep
= builtin_type_void
;
2902 create_name -- allocate a fresh copy of a string on an obstack
2906 Given a pointer to a string and a pointer to an obstack, allocates
2907 a fresh copy of the string on the specified obstack.
2912 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
2917 length
= strlen (name
) + 1;
2918 newname
= (char *) obstack_alloc (obstackp
, length
);
2919 (void) strcpy (newname
, name
);
2927 basicdieinfo -- extract the minimal die info from raw die data
2931 void basicdieinfo (char *diep, struct dieinfo *dip)
2935 Given a pointer to raw DIE data, and a pointer to an instance of a
2936 die info structure, this function extracts the basic information
2937 from the DIE data required to continue processing this DIE, along
2938 with some bookkeeping information about the DIE.
2940 The information we absolutely must have includes the DIE tag,
2941 and the DIE length. If we need the sibling reference, then we
2942 will have to call completedieinfo() to process all the remaining
2945 Note that since there is no guarantee that the data is properly
2946 aligned in memory for the type of access required (indirection
2947 through anything other than a char pointer), we use memcpy to
2948 shuffle data items larger than a char. Possibly inefficient, but
2951 We also take care of some other basic things at this point, such
2952 as ensuring that the instance of the die info structure starts
2953 out completely zero'd and that curdie is initialized for use
2954 in error reporting if we have a problem with the current die.
2958 All DIE's must have at least a valid length, thus the minimum
2959 DIE size is sizeof (long). In order to have a valid tag, the
2960 DIE size must be at least sizeof (short) larger, otherwise they
2961 are forced to be TAG_padding DIES.
2963 Padding DIES must be at least sizeof(long) in length, implying that
2964 if a padding DIE is used for alignment and the amount needed is less
2965 than sizeof(long) then the padding DIE has to be big enough to align
2966 to the next alignment boundry.
2970 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
2973 (void) memset (dip
, 0, sizeof (struct dieinfo
));
2975 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
2976 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
2977 if (dip
-> dielength
< sizeof (long))
2979 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
2981 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
2983 dip
-> dietag
= TAG_padding
;
2987 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
2995 completedieinfo -- finish reading the information for a given DIE
2999 void completedieinfo (struct dieinfo *dip)
3003 Given a pointer to an already partially initialized die info structure,
3004 scan the raw DIE data and finish filling in the die info structure
3005 from the various attributes found.
3007 Note that since there is no guarantee that the data is properly
3008 aligned in memory for the type of access required (indirection
3009 through anything other than a char pointer), we use memcpy to
3010 shuffle data items larger than a char. Possibly inefficient, but
3015 Each time we are called, we increment the diecount variable, which
3016 keeps an approximate count of the number of dies processed for
3017 each compilation unit. This information is presented to the user
3018 if the info_verbose flag is set.
3023 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3025 char *diep
; /* Current pointer into raw DIE data */
3026 char *end
; /* Terminate DIE scan here */
3027 unsigned short attr
; /* Current attribute being scanned */
3028 unsigned short form
; /* Form of the attribute */
3029 short block2sz
; /* Size of a block2 attribute field */
3030 long block4sz
; /* Size of a block4 attribute field */
3034 end
= diep
+ dip
-> dielength
;
3035 diep
+= sizeof (long) + sizeof (short);
3038 (void) memcpy (&attr
, diep
, sizeof (short));
3039 diep
+= sizeof (short);
3043 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3046 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3049 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3052 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3055 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3058 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3059 dip
-> has_at_stmt_list
= 1;
3062 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3063 dip
-> at_low_pc
+= baseaddr
;
3064 dip
-> has_at_low_pc
= 1;
3067 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3068 dip
-> at_high_pc
+= baseaddr
;
3071 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3073 case AT_user_def_type
:
3074 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3077 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3080 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3083 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3086 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3089 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3092 dip
-> at_location
= diep
;
3094 case AT_mod_fund_type
:
3095 dip
-> at_mod_fund_type
= diep
;
3097 case AT_subscr_data
:
3098 dip
-> at_subscr_data
= diep
;
3100 case AT_mod_u_d_type
:
3101 dip
-> at_mod_u_d_type
= diep
;
3103 case AT_element_list
:
3104 dip
-> at_element_list
= diep
;
3105 dip
-> short_element_list
= 0;
3107 case AT_short_element_list
:
3108 dip
-> at_element_list
= diep
;
3109 dip
-> short_element_list
= 1;
3111 case AT_discr_value
:
3112 dip
-> at_discr_value
= diep
;
3114 case AT_string_length
:
3115 dip
-> at_string_length
= diep
;
3118 dip
-> at_name
= diep
;
3121 dip
-> at_comp_dir
= diep
;
3124 dip
-> at_producer
= diep
;
3127 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3129 case AT_start_scope
:
3130 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3132 case AT_stride_size
:
3133 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3136 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3139 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3142 /* Found an attribute that we are unprepared to handle. However
3143 it is specifically one of the design goals of DWARF that
3144 consumers should ignore unknown attributes. As long as the
3145 form is one that we recognize (so we know how to skip it),
3146 we can just ignore the unknown attribute. */
3153 diep
+= sizeof (short);
3156 diep
+= sizeof (long);
3159 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3163 diep
+= sizeof (long);
3166 (void) memcpy (&block2sz
, diep
, sizeof (short));
3167 block2sz
+= sizeof (short);
3171 (void) memcpy (&block4sz
, diep
, sizeof (long));
3172 block4sz
+= sizeof (long);
3176 diep
+= strlen (diep
) + 1;
3179 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));