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 */
190 static CORE_ADDR baseaddr
; /* Add to each symbol value */
192 /* Each partial symbol table entry contains a pointer to private data for the
193 read_symtab() function to use when expanding a partial symbol table entry
194 to a full symbol table entry. For DWARF debugging info, this data is
195 contained in the following structure and macros are provided for easy
196 access to the members given a pointer to a partial symbol table entry.
198 dbfoff Always the absolute file offset to the start of the ".debug"
199 section for the file containing the DIE's being accessed.
201 dbroff Relative offset from the start of the ".debug" access to the
202 first DIE to be accessed. When building the partial symbol
203 table, this value will be zero since we are accessing the
204 entire ".debug" section. When expanding a partial symbol
205 table entry, this value will be the offset to the first
206 DIE for the compilation unit containing the symbol that
207 triggers the expansion.
209 dblength The size of the chunk of DIE's being examined, in bytes.
211 lnfoff The absolute file offset to the line table fragment. Ignored
212 when building partial symbol tables, but used when expanding
213 them, and contains the absolute file offset to the fragment
214 of the ".line" section containing the line numbers for the
215 current compilation unit.
219 int dbfoff
; /* Absolute file offset to start of .debug section */
220 int dbroff
; /* Relative offset from start of .debug section */
221 int dblength
; /* Size of the chunk of DIE's being examined */
222 int lnfoff
; /* Absolute file offset to line table fragment */
225 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
226 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
227 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
228 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
230 /* The generic symbol table building routines have separate lists for
231 file scope symbols and all all other scopes (local scopes). So
232 we need to select the right one to pass to add_symbol_to_list().
233 We do it by keeping a pointer to the correct list in list_in_scope.
235 FIXME: The original dwarf code just treated the file scope as the first
236 local scope, and all other local scopes as nested local scopes, and worked
237 fine. Check to see if we really need to distinguish these in buildsym.c */
239 struct pending
**list_in_scope
;
241 /* DIES which have user defined types or modified user defined types refer to
242 other DIES for the type information. Thus we need to associate the offset
243 of a DIE for a user defined type with a pointer to the type information.
245 Originally this was done using a simple but expensive algorithm, with an
246 array of unsorted structures, each containing an offset/type-pointer pair.
247 This array was scanned linearly each time a lookup was done. The result
248 was that gdb was spending over half it's startup time munging through this
249 array of pointers looking for a structure that had the right offset member.
251 The second attempt used the same array of structures, but the array was
252 sorted using qsort each time a new offset/type was recorded, and a binary
253 search was used to find the type pointer for a given DIE offset. This was
254 even slower, due to the overhead of sorting the array each time a new
255 offset/type pair was entered.
257 The third attempt uses a fixed size array of type pointers, indexed by a
258 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
259 we can divide any DIE offset by 4 to obtain a unique index into this fixed
260 size array. Since each element is a 4 byte pointer, it takes exactly as
261 much memory to hold this array as to hold the DWARF info for a given
262 compilation unit. But it gets freed as soon as we are done with it. */
264 static struct type
**utypes
; /* Pointer to array of user type pointers */
265 static int numutypes
; /* Max number of user type pointers */
267 /* Forward declarations of static functions so we don't have to worry
268 about ordering within this file. The EXFUN macro may be slightly
269 misleading. Should probably be called DCLFUN instead, or something
270 more intuitive, since it can be used for both static and external
274 EXFUN (dwarfwarn
, (char *fmt DOTS
));
277 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
280 EXFUN (scan_compilation_units
,
281 (char *filename AND
char *thisdie AND
char *enddie
282 AND
unsigned int dbfoff AND
unsigned int lnoffset
283 AND
struct objfile
*objfile
));
285 static struct partial_symtab
*
286 EXFUN(dwarf_start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
287 AND
char *filename AND CORE_ADDR textlow
288 AND CORE_ADDR texthigh AND
int dbfoff
289 AND
int curoff AND
int culength AND
int lnfoff
290 AND
struct partial_symbol
*global_syms
291 AND
struct partial_symbol
*static_syms
));
294 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
297 EXFUN(init_psymbol_list
, (int total_symbols
));
300 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
303 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
306 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
309 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
311 static struct symtab
*
312 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
316 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
319 EXFUN(read_structure_scope
,
320 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
321 struct objfile
*objfile
));
324 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
327 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
330 EXFUN(dwarf_read_array_type
, (struct dieinfo
*dip
));
333 EXFUN(read_subroutine_type
,
334 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
337 EXFUN(read_enumeration
,
338 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
342 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
343 struct objfile
*objfile
));
346 EXFUN(enum_type
, (struct dieinfo
*dip
));
349 EXFUN(decode_line_numbers
, (char *linetable
));
352 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
355 EXFUN(decode_mod_fund_type
, (char *typedata
));
358 EXFUN(decode_mod_u_d_type
, (char *typedata
));
361 EXFUN(decode_modified_type
,
362 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
365 EXFUN(decode_fund_type
, (unsigned short fundtype
));
368 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
371 EXFUN(lookup_utype
, (DIEREF dieref
));
374 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
376 static struct symbol
*
377 EXFUN(new_symbol
, (struct dieinfo
*dip
));
380 EXFUN(locval
, (char *loc
));
383 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
384 enum misc_function_type
));
387 EXFUN(compare_psymbols
,
388 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
395 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
399 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
400 int mainline, unsigned int dbfoff, unsigned int dbsize,
401 unsigned int lnoffset, unsigned int lnsize,
402 struct objfile *objfile)
406 This function is called upon to build partial symtabs from files
407 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
409 It is passed a file descriptor for an open file containing the DIES
410 and line number information, the corresponding filename for that
411 file, a base address for relocating the symbols, a flag indicating
412 whether or not this debugging information is from a "main symbol
413 table" rather than a shared library or dynamically linked file,
414 and file offset/size pairs for the DIE information and line number
424 DEFUN(dwarf_build_psymtabs
,
425 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
431 unsigned int dbfoff AND
432 unsigned int dbsize AND
433 unsigned int lnoffset AND
434 unsigned int lnsize AND
435 struct objfile
*objfile
)
437 struct cleanup
*back_to
;
439 dbbase
= xmalloc (dbsize
);
441 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
442 (read (desc
, dbbase
, dbsize
) != dbsize
))
445 error ("can't read DWARF data from '%s'", filename
);
447 back_to
= make_cleanup (free
, dbbase
);
449 /* If we are reinitializing, or if we have never loaded syms yet, init.
450 Since we have no idea how many DIES we are looking at, we just guess
451 some arbitrary value. */
453 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
455 init_psymbol_list (1024);
458 /* From this point on, we don't need to pass mainline around, so zap
459 baseaddr to zero if we don't need relocation. */
470 /* Follow the compilation unit sibling chain, building a partial symbol
471 table entry for each one. Save enough information about each compilation
472 unit to locate the full DWARF information later. */
474 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
475 dbfoff
, lnoffset
, objfile
);
477 do_cleanups (back_to
);
485 record_misc_function -- add entry to miscellaneous function vector
489 static void record_misc_function (char *name, CORE_ADDR address,
490 enum misc_function_type mf_type)
494 Given a pointer to the name of a symbol that should be added to the
495 miscellaneous function vector, and the address associated with that
496 symbol, records this information for later use in building the
497 miscellaneous function vector.
502 DEFUN(record_misc_function
, (name
, address
, mf_type
),
503 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
505 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
513 dwarfwarn -- issue a DWARF related warning
517 Issue warnings about DWARF related things that aren't serious enough
518 to warrant aborting with an error, but should not be ignored either.
519 This includes things like detectable corruption in DIE's, missing
520 DIE's, unimplemented features, etc.
522 In general, running across tags or attributes that we don't recognize
523 is not considered to be a problem and we should not issue warnings
528 We mostly follow the example of the error() routine, but without
529 returning to command level. It is arguable about whether warnings
530 should be issued at all, and if so, where they should go (stdout or
533 We assume that curdie is valid and contains at least the basic
534 information for the DIE where the problem was noticed.
540 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
546 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
547 if (curdie
-> at_name
)
549 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
551 vfprintf (stderr
, fmt
, ap
);
552 fprintf (stderr
, "\n");
567 fmt
= va_arg (ap
, char *);
569 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
570 if (curdie
-> at_name
)
572 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
574 vfprintf (stderr
, fmt
, ap
);
575 fprintf (stderr
, "\n");
586 compare_psymbols -- compare two partial symbols by name
590 Given pointer to two partial symbol table entries, compare
591 them by name and return -N, 0, or +N (ala strcmp). Typically
592 used by sorting routines like qsort().
596 This is a copy from dbxread.c. It should be moved to a generic
597 gdb file and made available for all psymtab builders (FIXME).
599 Does direct compare of first two characters before punting
600 and passing to strcmp for longer compares. Note that the
601 original version had a bug whereby two null strings or two
602 identically named one character strings would return the
603 comparison of memory following the null byte.
608 DEFUN(compare_psymbols
, (s1
, s2
),
609 struct partial_symbol
*s1 AND
610 struct partial_symbol
*s2
)
612 register char *st1
= SYMBOL_NAME (s1
);
613 register char *st2
= SYMBOL_NAME (s2
);
615 if ((st1
[0] - st2
[0]) || !st1
[0])
617 return (st1
[0] - st2
[0]);
619 else if ((st1
[1] - st2
[1]) || !st1
[1])
621 return (st1
[1] - st2
[1]);
625 return (strcmp (st1
+ 2, st2
+ 2));
633 read_lexical_block_scope -- process all dies in a lexical block
637 static void read_lexical_block_scope (struct dieinfo *dip,
638 char *thisdie, char *enddie)
642 Process all the DIES contained within a lexical block scope.
643 Start a new scope, process the dies, and then close the scope.
648 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
649 struct dieinfo
*dip AND
652 struct objfile
*objfile
)
654 register struct context_stack
*new;
656 (void) push_context (0, dip
-> at_low_pc
);
657 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
658 new = pop_context ();
659 if (local_symbols
!= NULL
)
661 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
664 local_symbols
= new -> locals
;
671 lookup_utype -- look up a user defined type from die reference
675 static type *lookup_utype (DIEREF dieref)
679 Given a DIE reference, lookup the user defined type associated with
680 that DIE, if it has been registered already. If not registered, then
681 return NULL. Alloc_utype() can be called to register an empty
682 type for this reference, which will be filled in later when the
683 actual referenced DIE is processed.
687 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
689 struct type
*type
= NULL
;
692 utypeidx
= (dieref
- dbroff
) / 4;
693 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
695 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
699 type
= *(utypes
+ utypeidx
);
709 alloc_utype -- add a user defined type for die reference
713 static type *alloc_utype (DIEREF dieref, struct type *utypep)
717 Given a die reference DIEREF, and a possible pointer to a user
718 defined type UTYPEP, register that this reference has a user
719 defined type and either use the specified type in UTYPEP or
720 make a new empty type that will be filled in later.
722 We should only be called after calling lookup_utype() to verify that
723 there is not currently a type registered for DIEREF.
727 DEFUN(alloc_utype
, (dieref
, utypep
),
734 utypeidx
= (dieref
- dbroff
) / 4;
735 typep
= utypes
+ utypeidx
;
736 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
738 utypep
= builtin_type_int
;
739 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
741 else if (*typep
!= NULL
)
744 SQUAWK (("internal error: dup user type allocation"));
750 utypep
= (struct type
*)
751 obstack_alloc (symbol_obstack
, sizeof (struct type
));
752 (void) memset (utypep
, 0, sizeof (struct type
));
763 decode_die_type -- return a type for a specified die
767 static struct type *decode_die_type (struct dieinfo *dip)
771 Given a pointer to a die information structure DIP, decode the
772 type of the die and return a pointer to the decoded type. All
773 dies without specific types default to type int.
777 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
779 struct type
*type
= NULL
;
781 if (dip
-> at_fund_type
!= 0)
783 type
= decode_fund_type (dip
-> at_fund_type
);
785 else if (dip
-> at_mod_fund_type
!= NULL
)
787 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
789 else if (dip
-> at_user_def_type
)
791 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
793 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
796 else if (dip
-> at_mod_u_d_type
)
798 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
802 type
= builtin_type_int
;
811 struct_type -- compute and return the type for a struct or union
815 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
816 char *enddie, struct objfile *objfile)
820 Given pointer to a die information structure for a die which
821 defines a union or structure (and MUST define one or the other),
822 and pointers to the raw die data that define the range of dies which
823 define the members, compute and return the user defined type for the
828 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
829 struct dieinfo
*dip AND
832 struct objfile
*objfile
)
836 struct nextfield
*next
;
839 struct nextfield
*list
= NULL
;
840 struct nextfield
*new;
847 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
849 /* No forward references created an empty type, so install one now */
850 type
= alloc_utype (dip
-> dieref
, NULL
);
852 INIT_CPLUS_SPECIFIC(type
);
853 switch (dip
-> dietag
)
855 case TAG_structure_type
:
856 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
860 TYPE_CODE (type
) = TYPE_CODE_UNION
;
864 /* Should never happen */
865 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
867 SQUAWK (("missing structure or union tag"));
870 /* Some compilers try to be helpful by inventing "fake" names for
871 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
872 Thanks, but no thanks... */
873 if (dip
-> at_name
!= NULL
874 && *dip
-> at_name
!= '~'
875 && *dip
-> at_name
!= '.')
877 TYPE_NAME (type
) = obconcat (tpart1
, " ", dip
-> at_name
);
879 if (dip
-> at_byte_size
!= 0)
881 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
883 thisdie
+= dip
-> dielength
;
884 while (thisdie
< enddie
)
886 basicdieinfo (&mbr
, thisdie
);
887 completedieinfo (&mbr
);
888 if (mbr
.dielength
<= sizeof (long))
892 else if (mbr
.at_sibling
!= 0)
894 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
898 nextdie
= thisdie
+ mbr
.dielength
;
903 /* Get space to record the next field's data. */
904 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
908 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
909 list
-> field
.type
= decode_die_type (&mbr
);
910 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
911 list
-> field
.bitsize
= 0;
915 process_dies (thisdie
, nextdie
, objfile
);
920 /* Now create the vector of fields, and record how big it is. We may
921 not even have any fields, if this DIE was generated due to a reference
922 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
923 set, which clues gdb in to the fact that it needs to search elsewhere
924 for the full structure definition. */
927 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
931 TYPE_NFIELDS (type
) = nfields
;
932 TYPE_FIELDS (type
) = (struct field
*)
933 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
934 /* Copy the saved-up fields into the field vector. */
935 for (n
= nfields
; list
; list
= list
-> next
)
937 TYPE_FIELD (type
, --n
) = list
-> field
;
947 read_structure_scope -- process all dies within struct or union
951 static void read_structure_scope (struct dieinfo *dip,
952 char *thisdie, char *enddie, struct objfile *objfile)
956 Called when we find the DIE that starts a structure or union
957 scope (definition) to process all dies that define the members
958 of the structure or union. DIP is a pointer to the die info
959 struct for the DIE that names the structure or union.
963 Note that we need to call struct_type regardless of whether or not
964 the DIE has an at_name attribute, since it might be an anonymous
965 structure or union. This gets the type entered into our set of
968 However, if the structure is incomplete (an opaque struct/union)
969 then suppress creating a symbol table entry for it since gdb only
970 wants to find the one with the complete definition. Note that if
971 it is complete, we just call new_symbol, which does it's own
972 checking about whether the struct/union is anonymous or not (and
973 suppresses creating a symbol table entry itself).
978 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
979 struct dieinfo
*dip AND
982 struct objfile
*objfile
)
987 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
988 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
990 if ((sym
= new_symbol (dip
)) != NULL
)
992 SYMBOL_TYPE (sym
) = type
;
1001 decode_array_element_type -- decode type of the array elements
1005 static struct type *decode_array_element_type (char *scan, char *end)
1009 As the last step in decoding the array subscript information for an
1010 array DIE, we need to decode the type of the array elements. We are
1011 passed a pointer to this last part of the subscript information and
1012 must return the appropriate type. If the type attribute is not
1013 recognized, just warn about the problem and return type int.
1016 static struct type
*
1017 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1022 unsigned short fundtype
;
1024 (void) memcpy (&attribute
, scan
, sizeof (short));
1025 scan
+= sizeof (short);
1029 (void) memcpy (&fundtype
, scan
, sizeof (short));
1030 typep
= decode_fund_type (fundtype
);
1032 case AT_mod_fund_type
:
1033 typep
= decode_mod_fund_type (scan
);
1035 case AT_user_def_type
:
1036 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1037 if ((typep
= lookup_utype (dieref
)) == NULL
)
1039 typep
= alloc_utype (dieref
, NULL
);
1042 case AT_mod_u_d_type
:
1043 typep
= decode_mod_u_d_type (scan
);
1046 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1047 typep
= builtin_type_int
;
1057 decode_subscr_data -- decode array subscript and element type data
1061 static struct type *decode_subscr_data (char *scan, char *end)
1065 The array subscripts and the data type of the elements of an
1066 array are described by a list of data items, stored as a block
1067 of contiguous bytes. There is a data item describing each array
1068 dimension, and a final data item describing the element type.
1069 The data items are ordered the same as their appearance in the
1070 source (I.E. leftmost dimension first, next to leftmost second,
1073 We are passed a pointer to the start of the block of bytes
1074 containing the data items, and a pointer to the first byte past
1075 the data. This function decodes the data and returns a type.
1078 FIXME: This code only implements the forms currently used
1079 by the AT&T and GNU C compilers.
1081 The end pointer is supplied for error checking, maybe we should
1085 static struct type
*
1086 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1088 struct type
*typep
= NULL
;
1089 struct type
*nexttype
;
1099 typep
= decode_array_element_type (scan
, end
);
1102 (void) memcpy (&fundtype
, scan
, sizeof (short));
1103 scan
+= sizeof (short);
1104 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1105 && fundtype
!= FT_unsigned_integer
)
1107 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1112 (void) memcpy (&lowbound
, scan
, sizeof (long));
1113 scan
+= sizeof (long);
1114 (void) memcpy (&highbound
, scan
, sizeof (long));
1115 scan
+= sizeof (long);
1116 nexttype
= decode_subscr_data (scan
, end
);
1117 if (nexttype
!= NULL
)
1119 typep
= (struct type
*)
1120 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1121 (void) memset (typep
, 0, sizeof (struct type
));
1122 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1123 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1124 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1125 TYPE_TARGET_TYPE (typep
) = nexttype
;
1136 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1139 SQUAWK (("unknown array subscript format %x", format
));
1149 dwarf_read_array_type -- read TAG_array_type DIE
1153 static void dwarf_read_array_type (struct dieinfo *dip)
1157 Extract all information from a TAG_array_type DIE and add to
1158 the user defined type vector.
1162 DEFUN(dwarf_read_array_type
, (dip
), struct dieinfo
*dip
)
1169 if (dip
-> at_ordering
!= ORD_row_major
)
1171 /* FIXME: Can gdb even handle column major arrays? */
1172 SQUAWK (("array not row major; not handled correctly"));
1174 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1176 (void) memcpy (&temp
, sub
, sizeof (short));
1177 subend
= sub
+ sizeof (short) + temp
;
1178 sub
+= sizeof (short);
1179 type
= decode_subscr_data (sub
, subend
);
1182 type
= alloc_utype (dip
-> dieref
, NULL
);
1183 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1184 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1185 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1189 type
= alloc_utype (dip
-> dieref
, type
);
1198 read_subroutine_type -- process TAG_subroutine_type dies
1202 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1207 Handle DIES due to C code like:
1210 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1216 The parameter DIES are currently ignored. See if gdb has a way to
1217 include this info in it's type system, and decode them if so. Is
1218 this what the type structure's "arg_types" field is for? (FIXME)
1222 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1223 struct dieinfo
*dip AND
1229 type
= decode_die_type (dip
);
1230 type
= lookup_function_type (type
);
1231 type
= alloc_utype (dip
-> dieref
, type
);
1238 read_enumeration -- process dies which define an enumeration
1242 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1247 Given a pointer to a die which begins an enumeration, process all
1248 the dies that define the members of the enumeration.
1252 Note that we need to call enum_type regardless of whether or not we
1253 have a symbol, since we might have an enum without a tag name (thus
1254 no symbol for the tagname).
1258 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1259 struct dieinfo
*dip AND
1266 type
= enum_type (dip
);
1267 if ((sym
= new_symbol (dip
)) != NULL
)
1269 SYMBOL_TYPE (sym
) = type
;
1277 enum_type -- decode and return a type for an enumeration
1281 static type *enum_type (struct dieinfo *dip)
1285 Given a pointer to a die information structure for the die which
1286 starts an enumeration, process all the dies that define the members
1287 of the enumeration and return a type pointer for the enumeration.
1289 At the same time, for each member of the enumeration, create a
1290 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1291 and give it the type of the enumeration itself.
1295 Note that the DWARF specification explicitly mandates that enum
1296 constants occur in reverse order from the source program order,
1297 for "consistency" and because this ordering is easier for many
1298 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1299 Entries). Because gdb wants to see the enum members in program
1300 source order, we have to ensure that the order gets reversed while
1301 we are processing them.
1304 static struct type
*
1305 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1309 struct nextfield
*next
;
1312 struct nextfield
*list
= NULL
;
1313 struct nextfield
*new;
1322 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1324 /* No forward references created an empty type, so install one now */
1325 type
= alloc_utype (dip
-> dieref
, NULL
);
1327 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1328 /* Some compilers try to be helpful by inventing "fake" names for
1329 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1330 Thanks, but no thanks... */
1331 if (dip
-> at_name
!= NULL
1332 && *dip
-> at_name
!= '~'
1333 && *dip
-> at_name
!= '.')
1335 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1337 if (dip
-> at_byte_size
!= 0)
1339 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1341 if ((scan
= dip
-> at_element_list
) != NULL
)
1343 if (dip
-> short_element_list
)
1345 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1346 listend
= scan
+ stemp
+ sizeof (stemp
);
1347 scan
+= sizeof (stemp
);
1351 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1352 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1353 scan
+= sizeof (ltemp
);
1355 while (scan
< listend
)
1357 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1360 list
-> field
.type
= NULL
;
1361 list
-> field
.bitsize
= 0;
1362 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1363 scan
+= sizeof (long);
1364 list
-> field
.name
= savestring (scan
, strlen (scan
));
1365 scan
+= strlen (scan
) + 1;
1367 /* Handcraft a new symbol for this enum member. */
1368 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1369 sizeof (struct symbol
));
1370 (void) memset (sym
, 0, sizeof (struct symbol
));
1371 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, symbol_obstack
);
1372 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1373 SYMBOL_CLASS (sym
) = LOC_CONST
;
1374 SYMBOL_TYPE (sym
) = type
;
1375 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1376 add_symbol_to_list (sym
, list_in_scope
);
1378 /* Now create the vector of fields, and record how big it is. This is
1379 where we reverse the order, by pulling the members of the list in
1380 reverse order from how they were inserted. If we have no fields
1381 (this is apparently possible in C++) then skip building a field
1385 TYPE_NFIELDS (type
) = nfields
;
1386 TYPE_FIELDS (type
) = (struct field
*)
1387 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1388 /* Copy the saved-up fields into the field vector. */
1389 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1391 TYPE_FIELD (type
, n
++) = list
-> field
;
1402 read_func_scope -- process all dies within a function scope
1406 Process all dies within a given function scope. We are passed
1407 a die information structure pointer DIP for the die which
1408 starts the function scope, and pointers into the raw die data
1409 that define the dies within the function scope.
1411 For now, we ignore lexical block scopes within the function.
1412 The problem is that AT&T cc does not define a DWARF lexical
1413 block scope for the function itself, while gcc defines a
1414 lexical block scope for the function. We need to think about
1415 how to handle this difference, or if it is even a problem.
1420 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1421 struct dieinfo
*dip AND
1424 struct objfile
*objfile
)
1426 register struct context_stack
*new;
1428 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1430 entry_scope_lowpc
= dip
-> at_low_pc
;
1431 entry_scope_highpc
= dip
-> at_high_pc
;
1433 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1435 main_scope_lowpc
= dip
-> at_low_pc
;
1436 main_scope_highpc
= dip
-> at_high_pc
;
1438 new = push_context (0, dip
-> at_low_pc
);
1439 new -> name
= new_symbol (dip
);
1440 list_in_scope
= &local_symbols
;
1441 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1442 new = pop_context ();
1443 /* Make a block for the local symbols within. */
1444 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1445 new -> start_addr
, dip
-> at_high_pc
);
1446 list_in_scope
= &file_symbols
;
1453 read_file_scope -- process all dies within a file scope
1457 Process all dies within a given file scope. We are passed a
1458 pointer to the die information structure for the die which
1459 starts the file scope, and pointers into the raw die data which
1460 mark the range of dies within the file scope.
1462 When the partial symbol table is built, the file offset for the line
1463 number table for each compilation unit is saved in the partial symbol
1464 table entry for that compilation unit. As the symbols for each
1465 compilation unit are read, the line number table is read into memory
1466 and the variable lnbase is set to point to it. Thus all we have to
1467 do is use lnbase to access the line number table for the current
1472 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1473 struct dieinfo
*dip AND
1476 struct objfile
*objfile
)
1478 struct cleanup
*back_to
;
1479 struct symtab
*symtab
;
1481 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1483 startup_file_start
= dip
-> at_low_pc
;
1484 startup_file_end
= dip
-> at_high_pc
;
1486 if (dip
-> at_producer
!= NULL
)
1488 processing_gcc_compilation
=
1489 STREQN (dip
-> at_producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1491 numutypes
= (enddie
- thisdie
) / 4;
1492 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1493 back_to
= make_cleanup (free
, utypes
);
1494 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1495 start_symtab (dip
-> at_name
, NULL
, dip
-> at_low_pc
);
1496 decode_line_numbers (lnbase
);
1497 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1498 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1499 /* FIXME: The following may need to be expanded for other languages */
1500 switch (dip
-> at_language
)
1504 symtab
-> language
= language_c
;
1506 case LANG_C_PLUS_PLUS
:
1507 symtab
-> language
= language_cplus
;
1512 do_cleanups (back_to
);
1521 process_dies -- process a range of DWARF Information Entries
1525 static void process_dies (char *thisdie, char *enddie,
1526 struct objfile *objfile)
1530 Process all DIE's in a specified range. May be (and almost
1531 certainly will be) called recursively.
1535 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1536 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1541 while (thisdie
< enddie
)
1543 basicdieinfo (&di
, thisdie
);
1544 if (di
.dielength
< sizeof (long))
1548 else if (di
.dietag
== TAG_padding
)
1550 nextdie
= thisdie
+ di
.dielength
;
1554 completedieinfo (&di
);
1555 if (di
.at_sibling
!= 0)
1557 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1561 nextdie
= thisdie
+ di
.dielength
;
1565 case TAG_compile_unit
:
1566 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1568 case TAG_global_subroutine
:
1569 case TAG_subroutine
:
1570 if (di
.has_at_low_pc
)
1572 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1575 case TAG_lexical_block
:
1576 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1578 case TAG_structure_type
:
1579 case TAG_union_type
:
1580 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1582 case TAG_enumeration_type
:
1583 read_enumeration (&di
, thisdie
, nextdie
);
1585 case TAG_subroutine_type
:
1586 read_subroutine_type (&di
, thisdie
, nextdie
);
1588 case TAG_array_type
:
1589 dwarf_read_array_type (&di
);
1592 (void) new_symbol (&di
);
1604 decode_line_numbers -- decode a line number table fragment
1608 static void decode_line_numbers (char *tblscan, char *tblend,
1609 long length, long base, long line, long pc)
1613 Translate the DWARF line number information to gdb form.
1615 The ".line" section contains one or more line number tables, one for
1616 each ".line" section from the objects that were linked.
1618 The AT_stmt_list attribute for each TAG_source_file entry in the
1619 ".debug" section contains the offset into the ".line" section for the
1620 start of the table for that file.
1622 The table itself has the following structure:
1624 <table length><base address><source statement entry>
1625 4 bytes 4 bytes 10 bytes
1627 The table length is the total size of the table, including the 4 bytes
1628 for the length information.
1630 The base address is the address of the first instruction generated
1631 for the source file.
1633 Each source statement entry has the following structure:
1635 <line number><statement position><address delta>
1636 4 bytes 2 bytes 4 bytes
1638 The line number is relative to the start of the file, starting with
1641 The statement position either -1 (0xFFFF) or the number of characters
1642 from the beginning of the line to the beginning of the statement.
1644 The address delta is the difference between the base address and
1645 the address of the first instruction for the statement.
1647 Note that we must copy the bytes from the packed table to our local
1648 variables before attempting to use them, to avoid alignment problems
1649 on some machines, particularly RISC processors.
1653 Does gdb expect the line numbers to be sorted? They are now by
1654 chance/luck, but are not required to be. (FIXME)
1656 The line with number 0 is unused, gdb apparently can discover the
1657 span of the last line some other way. How? (FIXME)
1661 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
1670 if (linetable
!= NULL
)
1672 tblscan
= tblend
= linetable
;
1673 (void) memcpy (&length
, tblscan
, sizeof (long));
1674 tblscan
+= sizeof (long);
1676 (void) memcpy (&base
, tblscan
, sizeof (long));
1678 tblscan
+= sizeof (long);
1679 while (tblscan
< tblend
)
1681 (void) memcpy (&line
, tblscan
, sizeof (long));
1682 tblscan
+= sizeof (long) + sizeof (short);
1683 (void) memcpy (&pc
, tblscan
, sizeof (long));
1684 tblscan
+= sizeof (long);
1688 record_line (current_subfile
, line
, pc
);
1698 locval -- compute the value of a location attribute
1702 static int locval (char *loc)
1706 Given pointer to a string of bytes that define a location, compute
1707 the location and return the value.
1709 When computing values involving the current value of the frame pointer,
1710 the value zero is used, which results in a value relative to the frame
1711 pointer, rather than the absolute value. This is what GDB wants
1714 When the result is a register number, the global isreg flag is set,
1715 otherwise it is cleared. This is a kludge until we figure out a better
1716 way to handle the problem. Gdb's design does not mesh well with the
1717 DWARF notion of a location computing interpreter, which is a shame
1718 because the flexibility goes unused.
1722 Note that stack[0] is unused except as a default error return.
1723 Note that stack overflow is not yet handled.
1727 DEFUN(locval
, (loc
), char *loc
)
1729 unsigned short nbytes
;
1735 (void) memcpy (&nbytes
, loc
, sizeof (short));
1736 end
= loc
+ sizeof (short) + nbytes
;
1740 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
1748 /* push register (number) */
1749 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1753 /* push value of register (number) */
1754 /* Actually, we compute the value as if register has 0 */
1755 (void) memcpy (®no
, loc
, sizeof (long));
1758 stack
[++stacki
] = 0;
1762 stack
[++stacki
] = 0;
1763 SQUAWK (("BASEREG %d not handled!", regno
));
1767 /* push address (relocated address) */
1768 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1771 /* push constant (number) */
1772 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1775 /* pop, deref and push 2 bytes (as a long) */
1776 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
1778 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1779 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
1781 case OP_ADD
: /* pop top 2 items, add, push result */
1782 stack
[stacki
- 1] += stack
[stacki
];
1787 return (stack
[stacki
]);
1794 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1798 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1804 static struct symtab
*
1805 DEFUN(read_ofile_symtab
, (pst
),
1806 struct partial_symtab
*pst
)
1808 struct cleanup
*back_to
;
1811 bfd
*abfd
= pst
->objfile
->obfd
;
1813 /* Allocate a buffer for the entire chunk of DIE's for this compilation
1814 unit, seek to the location in the file, and read in all the DIE's. */
1817 dbbase
= xmalloc (DBLENGTH(pst
));
1818 dbroff
= DBROFF(pst
);
1819 foffset
= DBFOFF(pst
) + dbroff
;
1820 baseaddr
= pst
-> addr
;
1821 if (bfd_seek (abfd
, foffset
, 0) ||
1822 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
1825 error ("can't read DWARF data");
1827 back_to
= make_cleanup (free
, dbbase
);
1829 /* If there is a line number table associated with this compilation unit
1830 then read the first long word from the line number table fragment, which
1831 contains the size of the fragment in bytes (including the long word
1832 itself). Allocate a buffer for the fragment and read it in for future
1838 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1839 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
1841 error ("can't read DWARF line number table size");
1843 lnbase
= xmalloc (lnsize
);
1844 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1845 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
1848 error ("can't read DWARF line numbers");
1850 make_cleanup (free
, lnbase
);
1853 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
1854 do_cleanups (back_to
);
1855 return (symtab_list
);
1862 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
1866 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
1870 Called once for each partial symbol table entry that needs to be
1871 expanded into a full symbol table entry.
1876 DEFUN(psymtab_to_symtab_1
,
1878 struct partial_symtab
*pst
)
1888 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1893 /* Read in all partial symtabs on which this one is dependent */
1894 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
1895 if (!pst
-> dependencies
[i
] -> readin
)
1897 /* Inform about additional files that need to be read in. */
1900 fputs_filtered (" ", stdout
);
1902 fputs_filtered ("and ", stdout
);
1904 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
1905 wrap_here (""); /* Flush output */
1908 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
1911 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
1913 pst
-> symtab
= read_ofile_symtab (pst
);
1916 printf_filtered ("%d DIE's, sorting...", diecount
);
1919 sort_symtab_syms (pst
-> symtab
);
1928 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
1932 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
1936 This is the DWARF support entry point for building a full symbol
1937 table entry from a partial symbol table entry. We are passed a
1938 pointer to the partial symbol table entry that needs to be expanded.
1943 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
1952 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1957 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
1959 /* Print the message now, before starting serious work, to avoid
1960 disconcerting pauses. */
1963 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
1967 psymtab_to_symtab_1 (pst
);
1969 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
1970 we need to do an equivalent or is this something peculiar to
1971 stabs/a.out format. */
1972 /* Match with global symbols. This only needs to be done once,
1973 after all of the symtabs and dependencies have been read in. */
1974 scan_file_globals ();
1977 /* Finish up the debug error message. */
1980 printf_filtered ("done.\n");
1989 init_psymbol_list -- initialize storage for partial symbols
1993 static void init_psymbol_list (int total_symbols)
1997 Initializes storage for all of the partial symbols that will be
1998 created by dwarf_build_psymtabs and subsidiaries.
2002 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2004 /* Free any previously allocated psymbol lists. */
2006 if (global_psymbols
.list
)
2008 free (global_psymbols
.list
);
2010 if (static_psymbols
.list
)
2012 free (static_psymbols
.list
);
2015 /* Current best guess is that there are approximately a twentieth
2016 of the total symbols (in a debugging file) are global or static
2019 global_psymbols
.size
= total_symbols
/ 10;
2020 static_psymbols
.size
= total_symbols
/ 10;
2021 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2022 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2023 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2024 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2031 dwarf_start_psymtab -- allocate and fill a partial symtab entry
2035 Allocate and partially fill a partial symtab. It will be completely
2036 filled at the end of the symbol list.
2038 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2039 ADDR is the address relative to which its symbols are (incremental)
2040 or 0 (normal). FILENAME is the name of the compilation unit that
2041 these symbols were defined in, and they appear starting a address
2042 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2043 the full symbols can be read for compilation unit FILENAME.
2044 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2049 static struct partial_symtab
*
2050 DEFUN(dwarf_start_psymtab
,
2051 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2052 culength
, lnfoff
, global_syms
, static_syms
),
2053 struct objfile
*objfile AND
2056 CORE_ADDR textlow AND
2057 CORE_ADDR texthigh AND
2062 struct partial_symbol
*global_syms AND
2063 struct partial_symbol
*static_syms
)
2065 struct partial_symtab
*result
;
2067 result
= (struct partial_symtab
*)
2068 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2069 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2070 result
-> addr
= addr
;
2071 result
-> objfile
= objfile
;
2072 result
-> filename
= create_name (filename
, psymbol_obstack
);
2073 result
-> textlow
= textlow
;
2074 result
-> texthigh
= texthigh
;
2075 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2076 sizeof (struct dwfinfo
));
2077 DBFOFF (result
) = dbfoff
;
2078 DBROFF (result
) = curoff
;
2079 DBLENGTH (result
) = culength
;
2080 LNFOFF (result
) = lnfoff
;
2081 result
-> readin
= 0;
2082 result
-> symtab
= NULL
;
2083 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2084 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2085 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2087 result
->n_global_syms
= 0;
2088 result
->n_static_syms
= 0;
2097 add_enum_psymbol -- add enumeration members to partial symbol table
2101 Given pointer to a DIE that is known to be for an enumeration,
2102 extract the symbolic names of the enumeration members and add
2103 partial symbols for them.
2107 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2114 if ((scan
= dip
-> at_element_list
) != NULL
)
2116 if (dip
-> short_element_list
)
2118 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2119 listend
= scan
+ stemp
+ sizeof (stemp
);
2120 scan
+= sizeof (stemp
);
2124 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2125 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2126 scan
+= sizeof (ltemp
);
2128 while (scan
< listend
)
2130 scan
+= sizeof (long);
2131 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2132 static_psymbols
, 0);
2133 scan
+= strlen (scan
) + 1;
2142 add_partial_symbol -- add symbol to partial symbol table
2146 Given a DIE, if it is one of the types that we want to
2147 add to a partial symbol table, finish filling in the die info
2148 and then add a partial symbol table entry for it.
2153 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2155 switch (dip
-> dietag
)
2157 case TAG_global_subroutine
:
2158 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2159 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2160 VAR_NAMESPACE
, LOC_BLOCK
, global_psymbols
,
2163 case TAG_global_variable
:
2164 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2166 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2167 VAR_NAMESPACE
, LOC_STATIC
, global_psymbols
,
2170 case TAG_subroutine
:
2171 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2172 VAR_NAMESPACE
, LOC_BLOCK
, static_psymbols
,
2175 case TAG_local_variable
:
2176 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2177 VAR_NAMESPACE
, LOC_STATIC
, static_psymbols
,
2181 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2182 VAR_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2185 case TAG_structure_type
:
2186 case TAG_union_type
:
2187 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2188 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2191 case TAG_enumeration_type
:
2194 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2195 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2198 add_enum_psymbol (dip
);
2207 scan_partial_symbols -- scan DIE's within a single compilation unit
2211 Process the DIE's within a single compilation unit, looking for
2212 interesting DIE's that contribute to the partial symbol table entry
2213 for this compilation unit. Since we cannot follow any sibling
2214 chains without reading the complete DIE info for every DIE,
2215 it is probably faster to just sequentially check each one to
2216 see if it is one of the types we are interested in, and if so,
2217 then extract all the attributes info and generate a partial
2222 Don't attempt to add anonymous structures or unions since they have
2223 no name. Anonymous enumerations however are processed, because we
2224 want to extract their member names (the check for a tag name is
2227 Also, for variables and subroutines, check that this is the place
2228 where the actual definition occurs, rather than just a reference
2233 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2238 while (thisdie
< enddie
)
2240 basicdieinfo (&di
, thisdie
);
2241 if (di
.dielength
< sizeof (long))
2247 nextdie
= thisdie
+ di
.dielength
;
2248 /* To avoid getting complete die information for every die, we
2249 only do it (below) for the cases we are interested in. */
2252 case TAG_global_subroutine
:
2253 case TAG_subroutine
:
2254 case TAG_global_variable
:
2255 case TAG_local_variable
:
2256 completedieinfo (&di
);
2257 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2259 add_partial_symbol (&di
);
2263 case TAG_structure_type
:
2264 case TAG_union_type
:
2265 completedieinfo (&di
);
2268 add_partial_symbol (&di
);
2271 case TAG_enumeration_type
:
2272 completedieinfo (&di
);
2273 add_partial_symbol (&di
);
2285 scan_compilation_units -- build a psymtab entry for each compilation
2289 This is the top level dwarf parsing routine for building partial
2292 It scans from the beginning of the DWARF table looking for the first
2293 TAG_compile_unit DIE, and then follows the sibling chain to locate
2294 each additional TAG_compile_unit DIE.
2296 For each TAG_compile_unit DIE it creates a partial symtab structure,
2297 calls a subordinate routine to collect all the compilation unit's
2298 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2299 new partial symtab structure into the partial symbol table. It also
2300 records the appropriate information in the partial symbol table entry
2301 to allow the chunk of DIE's and line number table for this compilation
2302 unit to be located and re-read later, to generate a complete symbol
2303 table entry for the compilation unit.
2305 Thus it effectively partitions up a chunk of DIE's for multiple
2306 compilation units into smaller DIE chunks and line number tables,
2307 and associates them with a partial symbol table entry.
2311 If any compilation unit has no line number table associated with
2312 it for some reason (a missing at_stmt_list attribute, rather than
2313 just one with a value of zero, which is valid) then we ensure that
2314 the recorded file offset is zero so that the routine which later
2315 reads line number table fragments knows that there is no fragment
2325 DEFUN(scan_compilation_units
,
2326 (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2330 unsigned int dbfoff AND
2331 unsigned int lnoffset AND
2332 struct objfile
*objfile
)
2336 struct partial_symtab
*pst
;
2341 while (thisdie
< enddie
)
2343 basicdieinfo (&di
, thisdie
);
2344 if (di
.dielength
< sizeof (long))
2348 else if (di
.dietag
!= TAG_compile_unit
)
2350 nextdie
= thisdie
+ di
.dielength
;
2354 completedieinfo (&di
);
2355 if (di
.at_sibling
!= 0)
2357 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2361 nextdie
= thisdie
+ di
.dielength
;
2363 curoff
= thisdie
- dbbase
;
2364 culength
= nextdie
- thisdie
;
2365 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2366 pst
= dwarf_start_psymtab (objfile
, baseaddr
, di
.at_name
,
2369 dbfoff
, curoff
, culength
, curlnoffset
,
2370 global_psymbols
.next
,
2371 static_psymbols
.next
);
2372 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2373 pst
-> n_global_syms
= global_psymbols
.next
-
2374 (global_psymbols
.list
+ pst
-> globals_offset
);
2375 pst
-> n_static_syms
= static_psymbols
.next
-
2376 (static_psymbols
.list
+ pst
-> statics_offset
);
2377 /* Sort the global list; don't sort the static list */
2378 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2379 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2381 /* If there is already a psymtab or symtab for a file of this name,
2382 remove it. (If there is a symtab, more drastic things also
2383 happen.) This happens in VxWorks. */
2384 free_named_symtabs (pst
-> filename
);
2385 /* Place the partial symtab on the partial symtab list */
2386 pst
-> next
= partial_symtab_list
;
2387 partial_symtab_list
= pst
;
2397 new_symbol -- make a symbol table entry for a new symbol
2401 static struct symbol *new_symbol (struct dieinfo *dip)
2405 Given a pointer to a DWARF information entry, figure out if we need
2406 to make a symbol table entry for it, and if so, create a new entry
2407 and return a pointer to it.
2410 static struct symbol
*
2411 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2413 struct symbol
*sym
= NULL
;
2415 if (dip
-> at_name
!= NULL
)
2417 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2418 sizeof (struct symbol
));
2419 (void) memset (sym
, 0, sizeof (struct symbol
));
2420 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2421 /* default assumptions */
2422 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2423 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2424 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2425 switch (dip
-> dietag
)
2428 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2429 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2431 case TAG_global_subroutine
:
2432 case TAG_subroutine
:
2433 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2434 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2435 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2436 if (dip
-> dietag
== TAG_global_subroutine
)
2438 add_symbol_to_list (sym
, &global_symbols
);
2442 add_symbol_to_list (sym
, list_in_scope
);
2445 case TAG_global_variable
:
2446 case TAG_local_variable
:
2447 if (dip
-> at_location
!= NULL
)
2449 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2451 if (dip
-> dietag
== TAG_global_variable
)
2453 add_symbol_to_list (sym
, &global_symbols
);
2454 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2455 SYMBOL_VALUE (sym
) += baseaddr
;
2459 add_symbol_to_list (sym
, list_in_scope
);
2460 if (context_stack_depth
> 0)
2464 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2468 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2473 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2474 SYMBOL_VALUE (sym
) += baseaddr
;
2478 case TAG_formal_parameter
:
2479 if (dip
-> at_location
!= NULL
)
2481 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2483 add_symbol_to_list (sym
, list_in_scope
);
2486 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2490 SYMBOL_CLASS (sym
) = LOC_ARG
;
2493 case TAG_unspecified_parameters
:
2494 /* From varargs functions; gdb doesn't seem to have any interest in
2495 this information, so just ignore it for now. (FIXME?) */
2497 case TAG_structure_type
:
2498 case TAG_union_type
:
2499 case TAG_enumeration_type
:
2500 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2501 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2502 add_symbol_to_list (sym
, list_in_scope
);
2505 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2506 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2507 add_symbol_to_list (sym
, list_in_scope
);
2510 /* Not a tag we recognize. Hopefully we aren't processing trash
2511 data, but since we must specifically ignore things we don't
2512 recognize, there is nothing else we should do at this point. */
2523 decode_mod_fund_type -- decode a modified fundamental type
2527 static struct type *decode_mod_fund_type (char *typedata)
2531 Decode a block of data containing a modified fundamental
2532 type specification. TYPEDATA is a pointer to the block,
2533 which consists of a two byte length, containing the size
2534 of the rest of the block. At the end of the block is a
2535 two byte value that gives the fundamental type. Everything
2536 in between are type modifiers.
2538 We simply compute the number of modifiers and call the general
2539 function decode_modified_type to do the actual work.
2542 static struct type
*
2543 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
2545 struct type
*typep
= NULL
;
2546 unsigned short modcount
;
2547 unsigned char *modifiers
;
2549 /* Get the total size of the block, exclusive of the size itself */
2550 (void) memcpy (&modcount
, typedata
, sizeof (short));
2551 /* Deduct the size of the fundamental type bytes at the end of the block. */
2552 modcount
-= sizeof (short);
2553 /* Skip over the two size bytes at the beginning of the block. */
2554 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2555 /* Now do the actual decoding */
2556 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
2564 decode_mod_u_d_type -- decode a modified user defined type
2568 static struct type *decode_mod_u_d_type (char *typedata)
2572 Decode a block of data containing a modified user defined
2573 type specification. TYPEDATA is a pointer to the block,
2574 which consists of a two byte length, containing the size
2575 of the rest of the block. At the end of the block is a
2576 four byte value that gives a reference to a user defined type.
2577 Everything in between are type modifiers.
2579 We simply compute the number of modifiers and call the general
2580 function decode_modified_type to do the actual work.
2583 static struct type
*
2584 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
2586 struct type
*typep
= NULL
;
2587 unsigned short modcount
;
2588 unsigned char *modifiers
;
2590 /* Get the total size of the block, exclusive of the size itself */
2591 (void) memcpy (&modcount
, typedata
, sizeof (short));
2592 /* Deduct the size of the reference type bytes at the end of the block. */
2593 modcount
-= sizeof (long);
2594 /* Skip over the two size bytes at the beginning of the block. */
2595 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2596 /* Now do the actual decoding */
2597 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
2605 decode_modified_type -- decode modified user or fundamental type
2609 static struct type *decode_modified_type (unsigned char *modifiers,
2610 unsigned short modcount, int mtype)
2614 Decode a modified type, either a modified fundamental type or
2615 a modified user defined type. MODIFIERS is a pointer to the
2616 block of bytes that define MODCOUNT modifiers. Immediately
2617 following the last modifier is a short containing the fundamental
2618 type or a long containing the reference to the user defined
2619 type. Which one is determined by MTYPE, which is either
2620 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2621 type we are generating.
2623 We call ourself recursively to generate each modified type,`
2624 until MODCOUNT reaches zero, at which point we have consumed
2625 all the modifiers and generate either the fundamental type or
2626 user defined type. When the recursion unwinds, each modifier
2627 is applied in turn to generate the full modified type.
2631 If we find a modifier that we don't recognize, and it is not one
2632 of those reserved for application specific use, then we issue a
2633 warning and simply ignore the modifier.
2637 We currently ignore MOD_const and MOD_volatile. (FIXME)
2641 static struct type
*
2642 DEFUN(decode_modified_type
,
2643 (modifiers
, modcount
, mtype
),
2644 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
2646 struct type
*typep
= NULL
;
2647 unsigned short fundtype
;
2649 unsigned char modifier
;
2655 case AT_mod_fund_type
:
2656 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
2657 typep
= decode_fund_type (fundtype
);
2659 case AT_mod_u_d_type
:
2660 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
2661 if ((typep
= lookup_utype (dieref
)) == NULL
)
2663 typep
= alloc_utype (dieref
, NULL
);
2667 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2668 typep
= builtin_type_int
;
2674 modifier
= *modifiers
++;
2675 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2678 case MOD_pointer_to
:
2679 typep
= lookup_pointer_type (typep
);
2681 case MOD_reference_to
:
2682 typep
= lookup_reference_type (typep
);
2685 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2688 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2691 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
2693 SQUAWK (("unknown type modifier %u", modifier
));
2705 decode_fund_type -- translate basic DWARF type to gdb base type
2709 Given an integer that is one of the fundamental DWARF types,
2710 translate it to one of the basic internal gdb types and return
2711 a pointer to the appropriate gdb type (a "struct type *").
2715 If we encounter a fundamental type that we are unprepared to
2716 deal with, and it is not in the range of those types defined
2717 as application specific types, then we issue a warning and
2718 treat the type as builtin_type_int.
2721 static struct type
*
2722 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
2724 struct type
*typep
= NULL
;
2730 typep
= builtin_type_void
;
2733 case FT_pointer
: /* (void *) */
2734 typep
= lookup_pointer_type (builtin_type_void
);
2738 case FT_signed_char
:
2739 typep
= builtin_type_char
;
2743 case FT_signed_short
:
2744 typep
= builtin_type_short
;
2748 case FT_signed_integer
:
2749 case FT_boolean
: /* Was FT_set in AT&T version */
2750 typep
= builtin_type_int
;
2754 case FT_signed_long
:
2755 typep
= builtin_type_long
;
2759 typep
= builtin_type_float
;
2762 case FT_dbl_prec_float
:
2763 typep
= builtin_type_double
;
2766 case FT_unsigned_char
:
2767 typep
= builtin_type_unsigned_char
;
2770 case FT_unsigned_short
:
2771 typep
= builtin_type_unsigned_short
;
2774 case FT_unsigned_integer
:
2775 typep
= builtin_type_unsigned_int
;
2778 case FT_unsigned_long
:
2779 typep
= builtin_type_unsigned_long
;
2782 case FT_ext_prec_float
:
2783 typep
= builtin_type_long_double
;
2787 typep
= builtin_type_complex
;
2790 case FT_dbl_prec_complex
:
2791 typep
= builtin_type_double_complex
;
2795 case FT_signed_long_long
:
2796 typep
= builtin_type_long_long
;
2799 case FT_unsigned_long_long
:
2800 typep
= builtin_type_unsigned_long_long
;
2805 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
2807 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
2808 typep
= builtin_type_void
;
2818 create_name -- allocate a fresh copy of a string on an obstack
2822 Given a pointer to a string and a pointer to an obstack, allocates
2823 a fresh copy of the string on the specified obstack.
2828 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
2833 length
= strlen (name
) + 1;
2834 newname
= (char *) obstack_alloc (obstackp
, length
);
2835 (void) strcpy (newname
, name
);
2843 basicdieinfo -- extract the minimal die info from raw die data
2847 void basicdieinfo (char *diep, struct dieinfo *dip)
2851 Given a pointer to raw DIE data, and a pointer to an instance of a
2852 die info structure, this function extracts the basic information
2853 from the DIE data required to continue processing this DIE, along
2854 with some bookkeeping information about the DIE.
2856 The information we absolutely must have includes the DIE tag,
2857 and the DIE length. If we need the sibling reference, then we
2858 will have to call completedieinfo() to process all the remaining
2861 Note that since there is no guarantee that the data is properly
2862 aligned in memory for the type of access required (indirection
2863 through anything other than a char pointer), we use memcpy to
2864 shuffle data items larger than a char. Possibly inefficient, but
2867 We also take care of some other basic things at this point, such
2868 as ensuring that the instance of the die info structure starts
2869 out completely zero'd and that curdie is initialized for use
2870 in error reporting if we have a problem with the current die.
2874 All DIE's must have at least a valid length, thus the minimum
2875 DIE size is sizeof (long). In order to have a valid tag, the
2876 DIE size must be at least sizeof (short) larger, otherwise they
2877 are forced to be TAG_padding DIES.
2879 Padding DIES must be at least sizeof(long) in length, implying that
2880 if a padding DIE is used for alignment and the amount needed is less
2881 than sizeof(long) then the padding DIE has to be big enough to align
2882 to the next alignment boundry.
2886 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
2889 (void) memset (dip
, 0, sizeof (struct dieinfo
));
2891 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
2892 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
2893 if (dip
-> dielength
< sizeof (long))
2895 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
2897 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
2899 dip
-> dietag
= TAG_padding
;
2903 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
2911 completedieinfo -- finish reading the information for a given DIE
2915 void completedieinfo (struct dieinfo *dip)
2919 Given a pointer to an already partially initialized die info structure,
2920 scan the raw DIE data and finish filling in the die info structure
2921 from the various attributes found.
2923 Note that since there is no guarantee that the data is properly
2924 aligned in memory for the type of access required (indirection
2925 through anything other than a char pointer), we use memcpy to
2926 shuffle data items larger than a char. Possibly inefficient, but
2931 Each time we are called, we increment the diecount variable, which
2932 keeps an approximate count of the number of dies processed for
2933 each compilation unit. This information is presented to the user
2934 if the info_verbose flag is set.
2939 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
2941 char *diep
; /* Current pointer into raw DIE data */
2942 char *end
; /* Terminate DIE scan here */
2943 unsigned short attr
; /* Current attribute being scanned */
2944 unsigned short form
; /* Form of the attribute */
2945 short block2sz
; /* Size of a block2 attribute field */
2946 long block4sz
; /* Size of a block4 attribute field */
2950 end
= diep
+ dip
-> dielength
;
2951 diep
+= sizeof (long) + sizeof (short);
2954 (void) memcpy (&attr
, diep
, sizeof (short));
2955 diep
+= sizeof (short);
2959 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
2962 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
2965 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
2968 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
2971 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
2974 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
2975 dip
-> has_at_stmt_list
= 1;
2978 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
2979 dip
-> at_low_pc
+= baseaddr
;
2980 dip
-> has_at_low_pc
= 1;
2983 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
2984 dip
-> at_high_pc
+= baseaddr
;
2987 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
2989 case AT_user_def_type
:
2990 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
2993 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
2996 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
2999 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3002 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3005 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3008 dip
-> at_location
= diep
;
3010 case AT_mod_fund_type
:
3011 dip
-> at_mod_fund_type
= diep
;
3013 case AT_subscr_data
:
3014 dip
-> at_subscr_data
= diep
;
3016 case AT_mod_u_d_type
:
3017 dip
-> at_mod_u_d_type
= diep
;
3019 case AT_element_list
:
3020 dip
-> at_element_list
= diep
;
3021 dip
-> short_element_list
= 0;
3023 case AT_short_element_list
:
3024 dip
-> at_element_list
= diep
;
3025 dip
-> short_element_list
= 1;
3027 case AT_discr_value
:
3028 dip
-> at_discr_value
= diep
;
3030 case AT_string_length
:
3031 dip
-> at_string_length
= diep
;
3034 dip
-> at_name
= diep
;
3037 dip
-> at_comp_dir
= diep
;
3040 dip
-> at_producer
= diep
;
3043 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3045 case AT_start_scope
:
3046 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3048 case AT_stride_size
:
3049 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3052 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3055 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3058 /* Found an attribute that we are unprepared to handle. However
3059 it is specifically one of the design goals of DWARF that
3060 consumers should ignore unknown attributes. As long as the
3061 form is one that we recognize (so we know how to skip it),
3062 we can just ignore the unknown attribute. */
3069 diep
+= sizeof (short);
3072 diep
+= sizeof (long);
3075 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3079 diep
+= sizeof (long);
3082 (void) memcpy (&block2sz
, diep
, sizeof (short));
3083 block2sz
+= sizeof (short);
3087 (void) memcpy (&block4sz
, diep
, sizeof (long));
3088 block4sz
+= sizeof (long);
3092 diep
+= strlen (diep
) + 1;
3095 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));