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
;
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_subroutine_type
,
335 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
338 EXFUN(read_enumeration
,
339 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
343 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
344 struct objfile
*objfile
));
347 EXFUN(enum_type
, (struct dieinfo
*dip
));
350 EXFUN(decode_line_numbers
, (char *linetable
));
353 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
356 EXFUN(decode_mod_fund_type
, (char *typedata
));
359 EXFUN(decode_mod_u_d_type
, (char *typedata
));
362 EXFUN(decode_modified_type
,
363 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
366 EXFUN(decode_fund_type
, (unsigned short fundtype
));
369 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
372 EXFUN(lookup_utype
, (DIEREF dieref
));
375 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
377 static struct symbol
*
378 EXFUN(new_symbol
, (struct dieinfo
*dip
));
381 EXFUN(locval
, (char *loc
));
384 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
385 enum misc_function_type
));
388 EXFUN(compare_psymbols
,
389 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
396 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
400 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
401 int mainline, unsigned int dbfoff, unsigned int dbsize,
402 unsigned int lnoffset, unsigned int lnsize,
403 struct objfile *objfile)
407 This function is called upon to build partial symtabs from files
408 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
410 It is passed a file descriptor for an open file containing the DIES
411 and line number information, the corresponding filename for that
412 file, a base address for relocating the symbols, a flag indicating
413 whether or not this debugging information is from a "main symbol
414 table" rather than a shared library or dynamically linked file,
415 and file offset/size pairs for the DIE information and line number
425 DEFUN(dwarf_build_psymtabs
,
426 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
432 unsigned int dbfoff AND
433 unsigned int dbsize AND
434 unsigned int lnoffset AND
435 unsigned int lnsize AND
436 struct objfile
*objfile
)
438 struct cleanup
*back_to
;
440 dbbase
= xmalloc (dbsize
);
442 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
443 (read (desc
, dbbase
, dbsize
) != dbsize
))
446 error ("can't read DWARF data from '%s'", filename
);
448 back_to
= make_cleanup (free
, dbbase
);
450 /* If we are reinitializing, or if we have never loaded syms yet, init.
451 Since we have no idea how many DIES we are looking at, we just guess
452 some arbitrary value. */
454 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
456 init_psymbol_list (1024);
459 /* From this point on, we don't need to pass mainline around, so zap
460 baseaddr to zero if we don't need relocation. */
471 /* Follow the compilation unit sibling chain, building a partial symbol
472 table entry for each one. Save enough information about each compilation
473 unit to locate the full DWARF information later. */
475 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
476 dbfoff
, lnoffset
, objfile
);
478 do_cleanups (back_to
);
486 record_misc_function -- add entry to miscellaneous function vector
490 static void record_misc_function (char *name, CORE_ADDR address,
491 enum misc_function_type mf_type)
495 Given a pointer to the name of a symbol that should be added to the
496 miscellaneous function vector, and the address associated with that
497 symbol, records this information for later use in building the
498 miscellaneous function vector.
503 DEFUN(record_misc_function
, (name
, address
, mf_type
),
504 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
506 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
514 dwarfwarn -- issue a DWARF related warning
518 Issue warnings about DWARF related things that aren't serious enough
519 to warrant aborting with an error, but should not be ignored either.
520 This includes things like detectable corruption in DIE's, missing
521 DIE's, unimplemented features, etc.
523 In general, running across tags or attributes that we don't recognize
524 is not considered to be a problem and we should not issue warnings
529 We mostly follow the example of the error() routine, but without
530 returning to command level. It is arguable about whether warnings
531 should be issued at all, and if so, where they should go (stdout or
534 We assume that curdie is valid and contains at least the basic
535 information for the DIE where the problem was noticed.
541 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
547 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
548 if (curdie
-> at_name
)
550 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
552 vfprintf (stderr
, fmt
, ap
);
553 fprintf (stderr
, "\n");
568 fmt
= va_arg (ap
, char *);
570 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
571 if (curdie
-> at_name
)
573 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
575 vfprintf (stderr
, fmt
, ap
);
576 fprintf (stderr
, "\n");
587 compare_psymbols -- compare two partial symbols by name
591 Given pointer to two partial symbol table entries, compare
592 them by name and return -N, 0, or +N (ala strcmp). Typically
593 used by sorting routines like qsort().
597 This is a copy from dbxread.c. It should be moved to a generic
598 gdb file and made available for all psymtab builders (FIXME).
600 Does direct compare of first two characters before punting
601 and passing to strcmp for longer compares. Note that the
602 original version had a bug whereby two null strings or two
603 identically named one character strings would return the
604 comparison of memory following the null byte.
609 DEFUN(compare_psymbols
, (s1
, s2
),
610 struct partial_symbol
*s1 AND
611 struct partial_symbol
*s2
)
613 register char *st1
= SYMBOL_NAME (s1
);
614 register char *st2
= SYMBOL_NAME (s2
);
616 if ((st1
[0] - st2
[0]) || !st1
[0])
618 return (st1
[0] - st2
[0]);
620 else if ((st1
[1] - st2
[1]) || !st1
[1])
622 return (st1
[1] - st2
[1]);
626 return (strcmp (st1
+ 2, st2
+ 2));
634 read_lexical_block_scope -- process all dies in a lexical block
638 static void read_lexical_block_scope (struct dieinfo *dip,
639 char *thisdie, char *enddie)
643 Process all the DIES contained within a lexical block scope.
644 Start a new scope, process the dies, and then close the scope.
649 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
650 struct dieinfo
*dip AND
653 struct objfile
*objfile
)
655 register struct context_stack
*new;
657 (void) push_context (0, dip
-> at_low_pc
);
658 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
659 new = pop_context ();
660 if (local_symbols
!= NULL
)
662 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
665 local_symbols
= new -> locals
;
672 lookup_utype -- look up a user defined type from die reference
676 static type *lookup_utype (DIEREF dieref)
680 Given a DIE reference, lookup the user defined type associated with
681 that DIE, if it has been registered already. If not registered, then
682 return NULL. Alloc_utype() can be called to register an empty
683 type for this reference, which will be filled in later when the
684 actual referenced DIE is processed.
688 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
690 struct type
*type
= NULL
;
693 utypeidx
= (dieref
- dbroff
) / 4;
694 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
696 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
700 type
= *(utypes
+ utypeidx
);
710 alloc_utype -- add a user defined type for die reference
714 static type *alloc_utype (DIEREF dieref, struct type *utypep)
718 Given a die reference DIEREF, and a possible pointer to a user
719 defined type UTYPEP, register that this reference has a user
720 defined type and either use the specified type in UTYPEP or
721 make a new empty type that will be filled in later.
723 We should only be called after calling lookup_utype() to verify that
724 there is not currently a type registered for DIEREF.
728 DEFUN(alloc_utype
, (dieref
, utypep
),
735 utypeidx
= (dieref
- dbroff
) / 4;
736 typep
= utypes
+ utypeidx
;
737 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
739 utypep
= builtin_type_int
;
740 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
742 else if (*typep
!= NULL
)
745 SQUAWK (("internal error: dup user type allocation"));
751 utypep
= (struct type
*)
752 obstack_alloc (symbol_obstack
, sizeof (struct type
));
753 (void) memset (utypep
, 0, sizeof (struct type
));
764 decode_die_type -- return a type for a specified die
768 static struct type *decode_die_type (struct dieinfo *dip)
772 Given a pointer to a die information structure DIP, decode the
773 type of the die and return a pointer to the decoded type. All
774 dies without specific types default to type int.
778 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
780 struct type
*type
= NULL
;
782 if (dip
-> at_fund_type
!= 0)
784 type
= decode_fund_type (dip
-> at_fund_type
);
786 else if (dip
-> at_mod_fund_type
!= NULL
)
788 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
790 else if (dip
-> at_user_def_type
)
792 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
794 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
797 else if (dip
-> at_mod_u_d_type
)
799 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
803 type
= builtin_type_int
;
812 struct_type -- compute and return the type for a struct or union
816 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
817 char *enddie, struct objfile *objfile)
821 Given pointer to a die information structure for a die which
822 defines a union or structure (and MUST define one or the other),
823 and pointers to the raw die data that define the range of dies which
824 define the members, compute and return the user defined type for the
829 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
830 struct dieinfo
*dip AND
833 struct objfile
*objfile
)
837 struct nextfield
*next
;
840 struct nextfield
*list
= NULL
;
841 struct nextfield
*new;
848 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
850 /* No forward references created an empty type, so install one now */
851 type
= alloc_utype (dip
-> dieref
, NULL
);
853 INIT_CPLUS_SPECIFIC(type
);
854 switch (dip
-> dietag
)
856 case TAG_structure_type
:
857 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
861 TYPE_CODE (type
) = TYPE_CODE_UNION
;
865 /* Should never happen */
866 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
868 SQUAWK (("missing structure or union tag"));
871 /* Some compilers try to be helpful by inventing "fake" names for
872 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
873 Thanks, but no thanks... */
874 if (dip
-> at_name
!= NULL
875 && *dip
-> at_name
!= '~'
876 && *dip
-> at_name
!= '.')
878 TYPE_NAME (type
) = obconcat (tpart1
, " ", dip
-> at_name
);
880 if (dip
-> at_byte_size
!= 0)
882 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
884 thisdie
+= dip
-> dielength
;
885 while (thisdie
< enddie
)
887 basicdieinfo (&mbr
, thisdie
);
888 completedieinfo (&mbr
);
889 if (mbr
.dielength
<= sizeof (long))
893 else if (mbr
.at_sibling
!= 0)
895 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
899 nextdie
= thisdie
+ mbr
.dielength
;
904 /* Get space to record the next field's data. */
905 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
909 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
910 list
-> field
.type
= decode_die_type (&mbr
);
911 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
912 list
-> field
.bitsize
= 0;
916 process_dies (thisdie
, nextdie
, objfile
);
921 /* Now create the vector of fields, and record how big it is. We may
922 not even have any fields, if this DIE was generated due to a reference
923 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
924 set, which clues gdb in to the fact that it needs to search elsewhere
925 for the full structure definition. */
928 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
932 TYPE_NFIELDS (type
) = nfields
;
933 TYPE_FIELDS (type
) = (struct field
*)
934 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
935 /* Copy the saved-up fields into the field vector. */
936 for (n
= nfields
; list
; list
= list
-> next
)
938 TYPE_FIELD (type
, --n
) = list
-> field
;
948 read_structure_scope -- process all dies within struct or union
952 static void read_structure_scope (struct dieinfo *dip,
953 char *thisdie, char *enddie, struct objfile *objfile)
957 Called when we find the DIE that starts a structure or union
958 scope (definition) to process all dies that define the members
959 of the structure or union. DIP is a pointer to the die info
960 struct for the DIE that names the structure or union.
964 Note that we need to call struct_type regardless of whether or not
965 the DIE has an at_name attribute, since it might be an anonymous
966 structure or union. This gets the type entered into our set of
969 However, if the structure is incomplete (an opaque struct/union)
970 then suppress creating a symbol table entry for it since gdb only
971 wants to find the one with the complete definition. Note that if
972 it is complete, we just call new_symbol, which does it's own
973 checking about whether the struct/union is anonymous or not (and
974 suppresses creating a symbol table entry itself).
979 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
980 struct dieinfo
*dip AND
983 struct objfile
*objfile
)
988 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
989 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
991 if ((sym
= new_symbol (dip
)) != NULL
)
993 SYMBOL_TYPE (sym
) = type
;
1002 decode_array_element_type -- decode type of the array elements
1006 static struct type *decode_array_element_type (char *scan, char *end)
1010 As the last step in decoding the array subscript information for an
1011 array DIE, we need to decode the type of the array elements. We are
1012 passed a pointer to this last part of the subscript information and
1013 must return the appropriate type. If the type attribute is not
1014 recognized, just warn about the problem and return type int.
1017 static struct type
*
1018 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1023 unsigned short fundtype
;
1025 (void) memcpy (&attribute
, scan
, sizeof (short));
1026 scan
+= sizeof (short);
1030 (void) memcpy (&fundtype
, scan
, sizeof (short));
1031 typep
= decode_fund_type (fundtype
);
1033 case AT_mod_fund_type
:
1034 typep
= decode_mod_fund_type (scan
);
1036 case AT_user_def_type
:
1037 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1038 if ((typep
= lookup_utype (dieref
)) == NULL
)
1040 typep
= alloc_utype (dieref
, NULL
);
1043 case AT_mod_u_d_type
:
1044 typep
= decode_mod_u_d_type (scan
);
1047 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1048 typep
= builtin_type_int
;
1058 decode_subscr_data -- decode array subscript and element type data
1062 static struct type *decode_subscr_data (char *scan, char *end)
1066 The array subscripts and the data type of the elements of an
1067 array are described by a list of data items, stored as a block
1068 of contiguous bytes. There is a data item describing each array
1069 dimension, and a final data item describing the element type.
1070 The data items are ordered the same as their appearance in the
1071 source (I.E. leftmost dimension first, next to leftmost second,
1074 We are passed a pointer to the start of the block of bytes
1075 containing the data items, and a pointer to the first byte past
1076 the data. This function decodes the data and returns a type.
1079 FIXME: This code only implements the forms currently used
1080 by the AT&T and GNU C compilers.
1082 The end pointer is supplied for error checking, maybe we should
1086 static struct type
*
1087 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1089 struct type
*typep
= NULL
;
1090 struct type
*nexttype
;
1100 typep
= decode_array_element_type (scan
, end
);
1103 (void) memcpy (&fundtype
, scan
, sizeof (short));
1104 scan
+= sizeof (short);
1105 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1106 && fundtype
!= FT_unsigned_integer
)
1108 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1113 (void) memcpy (&lowbound
, scan
, sizeof (long));
1114 scan
+= sizeof (long);
1115 (void) memcpy (&highbound
, scan
, sizeof (long));
1116 scan
+= sizeof (long);
1117 nexttype
= decode_subscr_data (scan
, end
);
1118 if (nexttype
!= NULL
)
1120 typep
= (struct type
*)
1121 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1122 (void) memset (typep
, 0, sizeof (struct type
));
1123 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1124 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1125 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1126 TYPE_TARGET_TYPE (typep
) = nexttype
;
1137 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1140 SQUAWK (("unknown array subscript format %x", format
));
1150 dwarf_read_array_type -- read TAG_array_type DIE
1154 static void dwarf_read_array_type (struct dieinfo *dip)
1158 Extract all information from a TAG_array_type DIE and add to
1159 the user defined type vector.
1163 DEFUN(dwarf_read_array_type
, (dip
), struct dieinfo
*dip
)
1170 if (dip
-> at_ordering
!= ORD_row_major
)
1172 /* FIXME: Can gdb even handle column major arrays? */
1173 SQUAWK (("array not row major; not handled correctly"));
1175 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1177 (void) memcpy (&temp
, sub
, sizeof (short));
1178 subend
= sub
+ sizeof (short) + temp
;
1179 sub
+= sizeof (short);
1180 type
= decode_subscr_data (sub
, subend
);
1183 type
= alloc_utype (dip
-> dieref
, NULL
);
1184 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1185 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1186 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1190 type
= alloc_utype (dip
-> dieref
, type
);
1199 read_subroutine_type -- process TAG_subroutine_type dies
1203 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1208 Handle DIES due to C code like:
1211 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1217 The parameter DIES are currently ignored. See if gdb has a way to
1218 include this info in it's type system, and decode them if so. Is
1219 this what the type structure's "arg_types" field is for? (FIXME)
1223 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1224 struct dieinfo
*dip AND
1230 type
= decode_die_type (dip
);
1231 type
= lookup_function_type (type
);
1232 type
= alloc_utype (dip
-> dieref
, type
);
1239 read_enumeration -- process dies which define an enumeration
1243 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1248 Given a pointer to a die which begins an enumeration, process all
1249 the dies that define the members of the enumeration.
1253 Note that we need to call enum_type regardless of whether or not we
1254 have a symbol, since we might have an enum without a tag name (thus
1255 no symbol for the tagname).
1259 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1260 struct dieinfo
*dip AND
1267 type
= enum_type (dip
);
1268 if ((sym
= new_symbol (dip
)) != NULL
)
1270 SYMBOL_TYPE (sym
) = type
;
1278 enum_type -- decode and return a type for an enumeration
1282 static type *enum_type (struct dieinfo *dip)
1286 Given a pointer to a die information structure for the die which
1287 starts an enumeration, process all the dies that define the members
1288 of the enumeration and return a type pointer for the enumeration.
1290 At the same time, for each member of the enumeration, create a
1291 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1292 and give it the type of the enumeration itself.
1296 Note that the DWARF specification explicitly mandates that enum
1297 constants occur in reverse order from the source program order,
1298 for "consistency" and because this ordering is easier for many
1299 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1300 Entries). Because gdb wants to see the enum members in program
1301 source order, we have to ensure that the order gets reversed while
1302 we are processing them.
1305 static struct type
*
1306 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1310 struct nextfield
*next
;
1313 struct nextfield
*list
= NULL
;
1314 struct nextfield
*new;
1323 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1325 /* No forward references created an empty type, so install one now */
1326 type
= alloc_utype (dip
-> dieref
, NULL
);
1328 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1329 /* Some compilers try to be helpful by inventing "fake" names for
1330 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1331 Thanks, but no thanks... */
1332 if (dip
-> at_name
!= NULL
1333 && *dip
-> at_name
!= '~'
1334 && *dip
-> at_name
!= '.')
1336 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1338 if (dip
-> at_byte_size
!= 0)
1340 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1342 if ((scan
= dip
-> at_element_list
) != NULL
)
1344 if (dip
-> short_element_list
)
1346 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1347 listend
= scan
+ stemp
+ sizeof (stemp
);
1348 scan
+= sizeof (stemp
);
1352 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1353 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1354 scan
+= sizeof (ltemp
);
1356 while (scan
< listend
)
1358 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1361 list
-> field
.type
= NULL
;
1362 list
-> field
.bitsize
= 0;
1363 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1364 scan
+= sizeof (long);
1365 list
-> field
.name
= savestring (scan
, strlen (scan
));
1366 scan
+= strlen (scan
) + 1;
1368 /* Handcraft a new symbol for this enum member. */
1369 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1370 sizeof (struct symbol
));
1371 (void) memset (sym
, 0, sizeof (struct symbol
));
1372 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, symbol_obstack
);
1373 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1374 SYMBOL_CLASS (sym
) = LOC_CONST
;
1375 SYMBOL_TYPE (sym
) = type
;
1376 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1377 add_symbol_to_list (sym
, list_in_scope
);
1379 /* Now create the vector of fields, and record how big it is. This is
1380 where we reverse the order, by pulling the members of the list in
1381 reverse order from how they were inserted. If we have no fields
1382 (this is apparently possible in C++) then skip building a field
1386 TYPE_NFIELDS (type
) = nfields
;
1387 TYPE_FIELDS (type
) = (struct field
*)
1388 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1389 /* Copy the saved-up fields into the field vector. */
1390 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1392 TYPE_FIELD (type
, n
++) = list
-> field
;
1403 read_func_scope -- process all dies within a function scope
1407 Process all dies within a given function scope. We are passed
1408 a die information structure pointer DIP for the die which
1409 starts the function scope, and pointers into the raw die data
1410 that define the dies within the function scope.
1412 For now, we ignore lexical block scopes within the function.
1413 The problem is that AT&T cc does not define a DWARF lexical
1414 block scope for the function itself, while gcc defines a
1415 lexical block scope for the function. We need to think about
1416 how to handle this difference, or if it is even a problem.
1421 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1422 struct dieinfo
*dip AND
1425 struct objfile
*objfile
)
1427 register struct context_stack
*new;
1429 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1431 entry_scope_lowpc
= dip
-> at_low_pc
;
1432 entry_scope_highpc
= dip
-> at_high_pc
;
1434 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1436 main_scope_lowpc
= dip
-> at_low_pc
;
1437 main_scope_highpc
= dip
-> at_high_pc
;
1439 new = push_context (0, dip
-> at_low_pc
);
1440 new -> name
= new_symbol (dip
);
1441 list_in_scope
= &local_symbols
;
1442 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1443 new = pop_context ();
1444 /* Make a block for the local symbols within. */
1445 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1446 new -> start_addr
, dip
-> at_high_pc
);
1447 list_in_scope
= &file_symbols
;
1454 read_file_scope -- process all dies within a file scope
1458 Process all dies within a given file scope. We are passed a
1459 pointer to the die information structure for the die which
1460 starts the file scope, and pointers into the raw die data which
1461 mark the range of dies within the file scope.
1463 When the partial symbol table is built, the file offset for the line
1464 number table for each compilation unit is saved in the partial symbol
1465 table entry for that compilation unit. As the symbols for each
1466 compilation unit are read, the line number table is read into memory
1467 and the variable lnbase is set to point to it. Thus all we have to
1468 do is use lnbase to access the line number table for the current
1473 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1474 struct dieinfo
*dip AND
1477 struct objfile
*objfile
)
1479 struct cleanup
*back_to
;
1480 struct symtab
*symtab
;
1482 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1484 startup_file_start
= dip
-> at_low_pc
;
1485 startup_file_end
= dip
-> at_high_pc
;
1487 if (dip
-> at_producer
!= NULL
)
1489 processing_gcc_compilation
=
1490 STREQN (dip
-> at_producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1492 numutypes
= (enddie
- thisdie
) / 4;
1493 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1494 back_to
= make_cleanup (free
, utypes
);
1495 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1496 start_symtab (dip
-> at_name
, NULL
, dip
-> at_low_pc
);
1497 decode_line_numbers (lnbase
);
1498 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1499 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1500 /* FIXME: The following may need to be expanded for other languages */
1501 switch (dip
-> at_language
)
1505 symtab
-> language
= language_c
;
1507 case LANG_C_PLUS_PLUS
:
1508 symtab
-> language
= language_cplus
;
1513 do_cleanups (back_to
);
1522 process_dies -- process a range of DWARF Information Entries
1526 static void process_dies (char *thisdie, char *enddie,
1527 struct objfile *objfile)
1531 Process all DIE's in a specified range. May be (and almost
1532 certainly will be) called recursively.
1536 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1537 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1542 while (thisdie
< enddie
)
1544 basicdieinfo (&di
, thisdie
);
1545 if (di
.dielength
< sizeof (long))
1549 else if (di
.dietag
== TAG_padding
)
1551 nextdie
= thisdie
+ di
.dielength
;
1555 completedieinfo (&di
);
1556 if (di
.at_sibling
!= 0)
1558 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1562 nextdie
= thisdie
+ di
.dielength
;
1566 case TAG_compile_unit
:
1567 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1569 case TAG_global_subroutine
:
1570 case TAG_subroutine
:
1571 if (di
.has_at_low_pc
)
1573 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1576 case TAG_lexical_block
:
1577 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1579 case TAG_structure_type
:
1580 case TAG_union_type
:
1581 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1583 case TAG_enumeration_type
:
1584 read_enumeration (&di
, thisdie
, nextdie
);
1586 case TAG_subroutine_type
:
1587 read_subroutine_type (&di
, thisdie
, nextdie
);
1589 case TAG_array_type
:
1590 dwarf_read_array_type (&di
);
1593 (void) new_symbol (&di
);
1605 decode_line_numbers -- decode a line number table fragment
1609 static void decode_line_numbers (char *tblscan, char *tblend,
1610 long length, long base, long line, long pc)
1614 Translate the DWARF line number information to gdb form.
1616 The ".line" section contains one or more line number tables, one for
1617 each ".line" section from the objects that were linked.
1619 The AT_stmt_list attribute for each TAG_source_file entry in the
1620 ".debug" section contains the offset into the ".line" section for the
1621 start of the table for that file.
1623 The table itself has the following structure:
1625 <table length><base address><source statement entry>
1626 4 bytes 4 bytes 10 bytes
1628 The table length is the total size of the table, including the 4 bytes
1629 for the length information.
1631 The base address is the address of the first instruction generated
1632 for the source file.
1634 Each source statement entry has the following structure:
1636 <line number><statement position><address delta>
1637 4 bytes 2 bytes 4 bytes
1639 The line number is relative to the start of the file, starting with
1642 The statement position either -1 (0xFFFF) or the number of characters
1643 from the beginning of the line to the beginning of the statement.
1645 The address delta is the difference between the base address and
1646 the address of the first instruction for the statement.
1648 Note that we must copy the bytes from the packed table to our local
1649 variables before attempting to use them, to avoid alignment problems
1650 on some machines, particularly RISC processors.
1654 Does gdb expect the line numbers to be sorted? They are now by
1655 chance/luck, but are not required to be. (FIXME)
1657 The line with number 0 is unused, gdb apparently can discover the
1658 span of the last line some other way. How? (FIXME)
1662 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
1671 if (linetable
!= NULL
)
1673 tblscan
= tblend
= linetable
;
1674 (void) memcpy (&length
, tblscan
, sizeof (long));
1675 tblscan
+= sizeof (long);
1677 (void) memcpy (&base
, tblscan
, sizeof (long));
1679 tblscan
+= sizeof (long);
1680 while (tblscan
< tblend
)
1682 (void) memcpy (&line
, tblscan
, sizeof (long));
1683 tblscan
+= sizeof (long) + sizeof (short);
1684 (void) memcpy (&pc
, tblscan
, sizeof (long));
1685 tblscan
+= sizeof (long);
1689 record_line (current_subfile
, line
, pc
);
1699 locval -- compute the value of a location attribute
1703 static int locval (char *loc)
1707 Given pointer to a string of bytes that define a location, compute
1708 the location and return the value.
1710 When computing values involving the current value of the frame pointer,
1711 the value zero is used, which results in a value relative to the frame
1712 pointer, rather than the absolute value. This is what GDB wants
1715 When the result is a register number, the global isreg flag is set,
1716 otherwise it is cleared. This is a kludge until we figure out a better
1717 way to handle the problem. Gdb's design does not mesh well with the
1718 DWARF notion of a location computing interpreter, which is a shame
1719 because the flexibility goes unused.
1723 Note that stack[0] is unused except as a default error return.
1724 Note that stack overflow is not yet handled.
1728 DEFUN(locval
, (loc
), char *loc
)
1730 unsigned short nbytes
;
1736 (void) memcpy (&nbytes
, loc
, sizeof (short));
1737 end
= loc
+ sizeof (short) + nbytes
;
1742 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
1750 /* push register (number) */
1751 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1755 /* push value of register (number) */
1756 /* Actually, we compute the value as if register has 0 */
1758 (void) memcpy (®no
, loc
, sizeof (long));
1761 stack
[++stacki
] = 0;
1765 stack
[++stacki
] = 0;
1766 SQUAWK (("BASEREG %d not handled!", regno
));
1770 /* push address (relocated address) */
1771 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1774 /* push constant (number) */
1775 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
1778 /* pop, deref and push 2 bytes (as a long) */
1779 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
1781 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1782 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
1784 case OP_ADD
: /* pop top 2 items, add, push result */
1785 stack
[stacki
- 1] += stack
[stacki
];
1790 return (stack
[stacki
]);
1797 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1801 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1807 static struct symtab
*
1808 DEFUN(read_ofile_symtab
, (pst
),
1809 struct partial_symtab
*pst
)
1811 struct cleanup
*back_to
;
1814 bfd
*abfd
= pst
->objfile
->obfd
;
1816 /* Allocate a buffer for the entire chunk of DIE's for this compilation
1817 unit, seek to the location in the file, and read in all the DIE's. */
1820 dbbase
= xmalloc (DBLENGTH(pst
));
1821 dbroff
= DBROFF(pst
);
1822 foffset
= DBFOFF(pst
) + dbroff
;
1823 baseaddr
= pst
-> addr
;
1824 if (bfd_seek (abfd
, foffset
, 0) ||
1825 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
1828 error ("can't read DWARF data");
1830 back_to
= make_cleanup (free
, dbbase
);
1832 /* If there is a line number table associated with this compilation unit
1833 then read the first long word from the line number table fragment, which
1834 contains the size of the fragment in bytes (including the long word
1835 itself). Allocate a buffer for the fragment and read it in for future
1841 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1842 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
1844 error ("can't read DWARF line number table size");
1846 lnbase
= xmalloc (lnsize
);
1847 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
1848 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
1851 error ("can't read DWARF line numbers");
1853 make_cleanup (free
, lnbase
);
1856 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
1857 do_cleanups (back_to
);
1858 return (symtab_list
);
1865 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
1869 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
1873 Called once for each partial symbol table entry that needs to be
1874 expanded into a full symbol table entry.
1879 DEFUN(psymtab_to_symtab_1
,
1881 struct partial_symtab
*pst
)
1891 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1896 /* Read in all partial symtabs on which this one is dependent */
1897 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
1898 if (!pst
-> dependencies
[i
] -> readin
)
1900 /* Inform about additional files that need to be read in. */
1903 fputs_filtered (" ", stdout
);
1905 fputs_filtered ("and ", stdout
);
1907 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
1908 wrap_here (""); /* Flush output */
1911 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
1914 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
1916 pst
-> symtab
= read_ofile_symtab (pst
);
1919 printf_filtered ("%d DIE's, sorting...", diecount
);
1922 sort_symtab_syms (pst
-> symtab
);
1931 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
1935 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
1939 This is the DWARF support entry point for building a full symbol
1940 table entry from a partial symbol table entry. We are passed a
1941 pointer to the partial symbol table entry that needs to be expanded.
1946 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
1955 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1960 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
1962 /* Print the message now, before starting serious work, to avoid
1963 disconcerting pauses. */
1966 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
1970 psymtab_to_symtab_1 (pst
);
1972 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
1973 we need to do an equivalent or is this something peculiar to
1974 stabs/a.out format. */
1975 /* Match with global symbols. This only needs to be done once,
1976 after all of the symtabs and dependencies have been read in. */
1977 scan_file_globals ();
1980 /* Finish up the debug error message. */
1983 printf_filtered ("done.\n");
1992 init_psymbol_list -- initialize storage for partial symbols
1996 static void init_psymbol_list (int total_symbols)
2000 Initializes storage for all of the partial symbols that will be
2001 created by dwarf_build_psymtabs and subsidiaries.
2005 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2007 /* Free any previously allocated psymbol lists. */
2009 if (global_psymbols
.list
)
2011 free (global_psymbols
.list
);
2013 if (static_psymbols
.list
)
2015 free (static_psymbols
.list
);
2018 /* Current best guess is that there are approximately a twentieth
2019 of the total symbols (in a debugging file) are global or static
2022 global_psymbols
.size
= total_symbols
/ 10;
2023 static_psymbols
.size
= total_symbols
/ 10;
2024 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2025 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2026 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2027 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2034 dwarf_start_psymtab -- allocate and fill a partial symtab entry
2038 Allocate and partially fill a partial symtab. It will be completely
2039 filled at the end of the symbol list.
2041 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2042 ADDR is the address relative to which its symbols are (incremental)
2043 or 0 (normal). FILENAME is the name of the compilation unit that
2044 these symbols were defined in, and they appear starting a address
2045 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2046 the full symbols can be read for compilation unit FILENAME.
2047 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2052 static struct partial_symtab
*
2053 DEFUN(dwarf_start_psymtab
,
2054 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2055 culength
, lnfoff
, global_syms
, static_syms
),
2056 struct objfile
*objfile AND
2059 CORE_ADDR textlow AND
2060 CORE_ADDR texthigh AND
2065 struct partial_symbol
*global_syms AND
2066 struct partial_symbol
*static_syms
)
2068 struct partial_symtab
*result
;
2070 result
= (struct partial_symtab
*)
2071 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2072 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2073 result
-> addr
= addr
;
2074 result
-> objfile
= objfile
;
2075 result
-> filename
= create_name (filename
, psymbol_obstack
);
2076 result
-> textlow
= textlow
;
2077 result
-> texthigh
= texthigh
;
2078 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2079 sizeof (struct dwfinfo
));
2080 DBFOFF (result
) = dbfoff
;
2081 DBROFF (result
) = curoff
;
2082 DBLENGTH (result
) = culength
;
2083 LNFOFF (result
) = lnfoff
;
2084 result
-> readin
= 0;
2085 result
-> symtab
= NULL
;
2086 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2087 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2088 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2090 result
->n_global_syms
= 0;
2091 result
->n_static_syms
= 0;
2100 add_enum_psymbol -- add enumeration members to partial symbol table
2104 Given pointer to a DIE that is known to be for an enumeration,
2105 extract the symbolic names of the enumeration members and add
2106 partial symbols for them.
2110 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2117 if ((scan
= dip
-> at_element_list
) != NULL
)
2119 if (dip
-> short_element_list
)
2121 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2122 listend
= scan
+ stemp
+ sizeof (stemp
);
2123 scan
+= sizeof (stemp
);
2127 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2128 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2129 scan
+= sizeof (ltemp
);
2131 while (scan
< listend
)
2133 scan
+= sizeof (long);
2134 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2135 static_psymbols
, 0);
2136 scan
+= strlen (scan
) + 1;
2145 add_partial_symbol -- add symbol to partial symbol table
2149 Given a DIE, if it is one of the types that we want to
2150 add to a partial symbol table, finish filling in the die info
2151 and then add a partial symbol table entry for it.
2156 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2158 switch (dip
-> dietag
)
2160 case TAG_global_subroutine
:
2161 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2162 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2163 VAR_NAMESPACE
, LOC_BLOCK
, global_psymbols
,
2166 case TAG_global_variable
:
2167 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2169 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2170 VAR_NAMESPACE
, LOC_STATIC
, global_psymbols
,
2173 case TAG_subroutine
:
2174 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2175 VAR_NAMESPACE
, LOC_BLOCK
, static_psymbols
,
2178 case TAG_local_variable
:
2179 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2180 VAR_NAMESPACE
, LOC_STATIC
, static_psymbols
,
2184 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2185 VAR_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2188 case TAG_structure_type
:
2189 case TAG_union_type
:
2190 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2191 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2194 case TAG_enumeration_type
:
2197 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2198 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2201 add_enum_psymbol (dip
);
2210 scan_partial_symbols -- scan DIE's within a single compilation unit
2214 Process the DIE's within a single compilation unit, looking for
2215 interesting DIE's that contribute to the partial symbol table entry
2216 for this compilation unit. Since we cannot follow any sibling
2217 chains without reading the complete DIE info for every DIE,
2218 it is probably faster to just sequentially check each one to
2219 see if it is one of the types we are interested in, and if so,
2220 then extract all the attributes info and generate a partial
2225 Don't attempt to add anonymous structures or unions since they have
2226 no name. Anonymous enumerations however are processed, because we
2227 want to extract their member names (the check for a tag name is
2230 Also, for variables and subroutines, check that this is the place
2231 where the actual definition occurs, rather than just a reference
2236 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2241 while (thisdie
< enddie
)
2243 basicdieinfo (&di
, thisdie
);
2244 if (di
.dielength
< sizeof (long))
2250 nextdie
= thisdie
+ di
.dielength
;
2251 /* To avoid getting complete die information for every die, we
2252 only do it (below) for the cases we are interested in. */
2255 case TAG_global_subroutine
:
2256 case TAG_subroutine
:
2257 case TAG_global_variable
:
2258 case TAG_local_variable
:
2259 completedieinfo (&di
);
2260 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2262 add_partial_symbol (&di
);
2266 case TAG_structure_type
:
2267 case TAG_union_type
:
2268 completedieinfo (&di
);
2271 add_partial_symbol (&di
);
2274 case TAG_enumeration_type
:
2275 completedieinfo (&di
);
2276 add_partial_symbol (&di
);
2288 scan_compilation_units -- build a psymtab entry for each compilation
2292 This is the top level dwarf parsing routine for building partial
2295 It scans from the beginning of the DWARF table looking for the first
2296 TAG_compile_unit DIE, and then follows the sibling chain to locate
2297 each additional TAG_compile_unit DIE.
2299 For each TAG_compile_unit DIE it creates a partial symtab structure,
2300 calls a subordinate routine to collect all the compilation unit's
2301 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2302 new partial symtab structure into the partial symbol table. It also
2303 records the appropriate information in the partial symbol table entry
2304 to allow the chunk of DIE's and line number table for this compilation
2305 unit to be located and re-read later, to generate a complete symbol
2306 table entry for the compilation unit.
2308 Thus it effectively partitions up a chunk of DIE's for multiple
2309 compilation units into smaller DIE chunks and line number tables,
2310 and associates them with a partial symbol table entry.
2314 If any compilation unit has no line number table associated with
2315 it for some reason (a missing at_stmt_list attribute, rather than
2316 just one with a value of zero, which is valid) then we ensure that
2317 the recorded file offset is zero so that the routine which later
2318 reads line number table fragments knows that there is no fragment
2328 DEFUN(scan_compilation_units
,
2329 (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2333 unsigned int dbfoff AND
2334 unsigned int lnoffset AND
2335 struct objfile
*objfile
)
2339 struct partial_symtab
*pst
;
2344 while (thisdie
< enddie
)
2346 basicdieinfo (&di
, thisdie
);
2347 if (di
.dielength
< sizeof (long))
2351 else if (di
.dietag
!= TAG_compile_unit
)
2353 nextdie
= thisdie
+ di
.dielength
;
2357 completedieinfo (&di
);
2358 if (di
.at_sibling
!= 0)
2360 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2364 nextdie
= thisdie
+ di
.dielength
;
2366 curoff
= thisdie
- dbbase
;
2367 culength
= nextdie
- thisdie
;
2368 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2369 pst
= dwarf_start_psymtab (objfile
, baseaddr
, di
.at_name
,
2372 dbfoff
, curoff
, culength
, curlnoffset
,
2373 global_psymbols
.next
,
2374 static_psymbols
.next
);
2375 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2376 pst
-> n_global_syms
= global_psymbols
.next
-
2377 (global_psymbols
.list
+ pst
-> globals_offset
);
2378 pst
-> n_static_syms
= static_psymbols
.next
-
2379 (static_psymbols
.list
+ pst
-> statics_offset
);
2380 /* Sort the global list; don't sort the static list */
2381 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2382 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2384 /* If there is already a psymtab or symtab for a file of this name,
2385 remove it. (If there is a symtab, more drastic things also
2386 happen.) This happens in VxWorks. */
2387 free_named_symtabs (pst
-> filename
);
2388 /* Place the partial symtab on the partial symtab list */
2389 pst
-> next
= partial_symtab_list
;
2390 partial_symtab_list
= pst
;
2400 new_symbol -- make a symbol table entry for a new symbol
2404 static struct symbol *new_symbol (struct dieinfo *dip)
2408 Given a pointer to a DWARF information entry, figure out if we need
2409 to make a symbol table entry for it, and if so, create a new entry
2410 and return a pointer to it.
2413 static struct symbol
*
2414 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2416 struct symbol
*sym
= NULL
;
2418 if (dip
-> at_name
!= NULL
)
2420 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2421 sizeof (struct symbol
));
2422 (void) memset (sym
, 0, sizeof (struct symbol
));
2423 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2424 /* default assumptions */
2425 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2426 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2427 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2428 switch (dip
-> dietag
)
2431 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2432 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2434 case TAG_global_subroutine
:
2435 case TAG_subroutine
:
2436 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2437 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2438 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2439 if (dip
-> dietag
== TAG_global_subroutine
)
2441 add_symbol_to_list (sym
, &global_symbols
);
2445 add_symbol_to_list (sym
, list_in_scope
);
2448 case TAG_global_variable
:
2449 if (dip
-> at_location
!= NULL
)
2451 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2452 add_symbol_to_list (sym
, &global_symbols
);
2453 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2454 SYMBOL_VALUE (sym
) += baseaddr
;
2457 case TAG_local_variable
:
2458 if (dip
-> at_location
!= NULL
)
2460 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2461 add_symbol_to_list (sym
, list_in_scope
);
2464 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2468 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2472 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2473 SYMBOL_VALUE (sym
) += baseaddr
;
2477 case TAG_formal_parameter
:
2478 if (dip
-> at_location
!= NULL
)
2480 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2482 add_symbol_to_list (sym
, list_in_scope
);
2485 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2489 SYMBOL_CLASS (sym
) = LOC_ARG
;
2492 case TAG_unspecified_parameters
:
2493 /* From varargs functions; gdb doesn't seem to have any interest in
2494 this information, so just ignore it for now. (FIXME?) */
2496 case TAG_structure_type
:
2497 case TAG_union_type
:
2498 case TAG_enumeration_type
:
2499 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2500 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2501 add_symbol_to_list (sym
, list_in_scope
);
2504 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2505 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2506 add_symbol_to_list (sym
, list_in_scope
);
2509 /* Not a tag we recognize. Hopefully we aren't processing trash
2510 data, but since we must specifically ignore things we don't
2511 recognize, there is nothing else we should do at this point. */
2522 decode_mod_fund_type -- decode a modified fundamental type
2526 static struct type *decode_mod_fund_type (char *typedata)
2530 Decode a block of data containing a modified fundamental
2531 type specification. TYPEDATA is a pointer to the block,
2532 which consists of a two byte length, containing the size
2533 of the rest of the block. At the end of the block is a
2534 two byte value that gives the fundamental type. Everything
2535 in between are type modifiers.
2537 We simply compute the number of modifiers and call the general
2538 function decode_modified_type to do the actual work.
2541 static struct type
*
2542 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
2544 struct type
*typep
= NULL
;
2545 unsigned short modcount
;
2546 unsigned char *modifiers
;
2548 /* Get the total size of the block, exclusive of the size itself */
2549 (void) memcpy (&modcount
, typedata
, sizeof (short));
2550 /* Deduct the size of the fundamental type bytes at the end of the block. */
2551 modcount
-= sizeof (short);
2552 /* Skip over the two size bytes at the beginning of the block. */
2553 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2554 /* Now do the actual decoding */
2555 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
2563 decode_mod_u_d_type -- decode a modified user defined type
2567 static struct type *decode_mod_u_d_type (char *typedata)
2571 Decode a block of data containing a modified user defined
2572 type specification. TYPEDATA is a pointer to the block,
2573 which consists of a two byte length, containing the size
2574 of the rest of the block. At the end of the block is a
2575 four byte value that gives a reference to a user defined type.
2576 Everything in between are type modifiers.
2578 We simply compute the number of modifiers and call the general
2579 function decode_modified_type to do the actual work.
2582 static struct type
*
2583 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
2585 struct type
*typep
= NULL
;
2586 unsigned short modcount
;
2587 unsigned char *modifiers
;
2589 /* Get the total size of the block, exclusive of the size itself */
2590 (void) memcpy (&modcount
, typedata
, sizeof (short));
2591 /* Deduct the size of the reference type bytes at the end of the block. */
2592 modcount
-= sizeof (long);
2593 /* Skip over the two size bytes at the beginning of the block. */
2594 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2595 /* Now do the actual decoding */
2596 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
2604 decode_modified_type -- decode modified user or fundamental type
2608 static struct type *decode_modified_type (unsigned char *modifiers,
2609 unsigned short modcount, int mtype)
2613 Decode a modified type, either a modified fundamental type or
2614 a modified user defined type. MODIFIERS is a pointer to the
2615 block of bytes that define MODCOUNT modifiers. Immediately
2616 following the last modifier is a short containing the fundamental
2617 type or a long containing the reference to the user defined
2618 type. Which one is determined by MTYPE, which is either
2619 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2620 type we are generating.
2622 We call ourself recursively to generate each modified type,`
2623 until MODCOUNT reaches zero, at which point we have consumed
2624 all the modifiers and generate either the fundamental type or
2625 user defined type. When the recursion unwinds, each modifier
2626 is applied in turn to generate the full modified type.
2630 If we find a modifier that we don't recognize, and it is not one
2631 of those reserved for application specific use, then we issue a
2632 warning and simply ignore the modifier.
2636 We currently ignore MOD_const and MOD_volatile. (FIXME)
2640 static struct type
*
2641 DEFUN(decode_modified_type
,
2642 (modifiers
, modcount
, mtype
),
2643 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
2645 struct type
*typep
= NULL
;
2646 unsigned short fundtype
;
2648 unsigned char modifier
;
2654 case AT_mod_fund_type
:
2655 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
2656 typep
= decode_fund_type (fundtype
);
2658 case AT_mod_u_d_type
:
2659 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
2660 if ((typep
= lookup_utype (dieref
)) == NULL
)
2662 typep
= alloc_utype (dieref
, NULL
);
2666 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2667 typep
= builtin_type_int
;
2673 modifier
= *modifiers
++;
2674 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2677 case MOD_pointer_to
:
2678 typep
= lookup_pointer_type (typep
);
2680 case MOD_reference_to
:
2681 typep
= lookup_reference_type (typep
);
2684 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2687 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2690 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
2692 SQUAWK (("unknown type modifier %u", modifier
));
2704 decode_fund_type -- translate basic DWARF type to gdb base type
2708 Given an integer that is one of the fundamental DWARF types,
2709 translate it to one of the basic internal gdb types and return
2710 a pointer to the appropriate gdb type (a "struct type *").
2714 If we encounter a fundamental type that we are unprepared to
2715 deal with, and it is not in the range of those types defined
2716 as application specific types, then we issue a warning and
2717 treat the type as builtin_type_int.
2720 static struct type
*
2721 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
2723 struct type
*typep
= NULL
;
2729 typep
= builtin_type_void
;
2732 case FT_pointer
: /* (void *) */
2733 typep
= lookup_pointer_type (builtin_type_void
);
2737 case FT_signed_char
:
2738 typep
= builtin_type_char
;
2742 case FT_signed_short
:
2743 typep
= builtin_type_short
;
2747 case FT_signed_integer
:
2748 case FT_boolean
: /* Was FT_set in AT&T version */
2749 typep
= builtin_type_int
;
2753 case FT_signed_long
:
2754 typep
= builtin_type_long
;
2758 typep
= builtin_type_float
;
2761 case FT_dbl_prec_float
:
2762 typep
= builtin_type_double
;
2765 case FT_unsigned_char
:
2766 typep
= builtin_type_unsigned_char
;
2769 case FT_unsigned_short
:
2770 typep
= builtin_type_unsigned_short
;
2773 case FT_unsigned_integer
:
2774 typep
= builtin_type_unsigned_int
;
2777 case FT_unsigned_long
:
2778 typep
= builtin_type_unsigned_long
;
2781 case FT_ext_prec_float
:
2782 typep
= builtin_type_long_double
;
2786 typep
= builtin_type_complex
;
2789 case FT_dbl_prec_complex
:
2790 typep
= builtin_type_double_complex
;
2794 case FT_signed_long_long
:
2795 typep
= builtin_type_long_long
;
2798 case FT_unsigned_long_long
:
2799 typep
= builtin_type_unsigned_long_long
;
2804 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
2806 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
2807 typep
= builtin_type_void
;
2817 create_name -- allocate a fresh copy of a string on an obstack
2821 Given a pointer to a string and a pointer to an obstack, allocates
2822 a fresh copy of the string on the specified obstack.
2827 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
2832 length
= strlen (name
) + 1;
2833 newname
= (char *) obstack_alloc (obstackp
, length
);
2834 (void) strcpy (newname
, name
);
2842 basicdieinfo -- extract the minimal die info from raw die data
2846 void basicdieinfo (char *diep, struct dieinfo *dip)
2850 Given a pointer to raw DIE data, and a pointer to an instance of a
2851 die info structure, this function extracts the basic information
2852 from the DIE data required to continue processing this DIE, along
2853 with some bookkeeping information about the DIE.
2855 The information we absolutely must have includes the DIE tag,
2856 and the DIE length. If we need the sibling reference, then we
2857 will have to call completedieinfo() to process all the remaining
2860 Note that since there is no guarantee that the data is properly
2861 aligned in memory for the type of access required (indirection
2862 through anything other than a char pointer), we use memcpy to
2863 shuffle data items larger than a char. Possibly inefficient, but
2866 We also take care of some other basic things at this point, such
2867 as ensuring that the instance of the die info structure starts
2868 out completely zero'd and that curdie is initialized for use
2869 in error reporting if we have a problem with the current die.
2873 All DIE's must have at least a valid length, thus the minimum
2874 DIE size is sizeof (long). In order to have a valid tag, the
2875 DIE size must be at least sizeof (short) larger, otherwise they
2876 are forced to be TAG_padding DIES.
2878 Padding DIES must be at least sizeof(long) in length, implying that
2879 if a padding DIE is used for alignment and the amount needed is less
2880 than sizeof(long) then the padding DIE has to be big enough to align
2881 to the next alignment boundry.
2885 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
2888 (void) memset (dip
, 0, sizeof (struct dieinfo
));
2890 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
2891 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
2892 if (dip
-> dielength
< sizeof (long))
2894 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
2896 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
2898 dip
-> dietag
= TAG_padding
;
2902 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
2910 completedieinfo -- finish reading the information for a given DIE
2914 void completedieinfo (struct dieinfo *dip)
2918 Given a pointer to an already partially initialized die info structure,
2919 scan the raw DIE data and finish filling in the die info structure
2920 from the various attributes found.
2922 Note that since there is no guarantee that the data is properly
2923 aligned in memory for the type of access required (indirection
2924 through anything other than a char pointer), we use memcpy to
2925 shuffle data items larger than a char. Possibly inefficient, but
2930 Each time we are called, we increment the diecount variable, which
2931 keeps an approximate count of the number of dies processed for
2932 each compilation unit. This information is presented to the user
2933 if the info_verbose flag is set.
2938 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
2940 char *diep
; /* Current pointer into raw DIE data */
2941 char *end
; /* Terminate DIE scan here */
2942 unsigned short attr
; /* Current attribute being scanned */
2943 unsigned short form
; /* Form of the attribute */
2944 short block2sz
; /* Size of a block2 attribute field */
2945 long block4sz
; /* Size of a block4 attribute field */
2949 end
= diep
+ dip
-> dielength
;
2950 diep
+= sizeof (long) + sizeof (short);
2953 (void) memcpy (&attr
, diep
, sizeof (short));
2954 diep
+= sizeof (short);
2958 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
2961 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
2964 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
2967 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
2970 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
2973 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
2974 dip
-> has_at_stmt_list
= 1;
2977 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
2978 dip
-> at_low_pc
+= baseaddr
;
2979 dip
-> has_at_low_pc
= 1;
2982 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
2983 dip
-> at_high_pc
+= baseaddr
;
2986 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
2988 case AT_user_def_type
:
2989 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
2992 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
2995 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
2998 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3001 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3004 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3007 dip
-> at_location
= diep
;
3009 case AT_mod_fund_type
:
3010 dip
-> at_mod_fund_type
= diep
;
3012 case AT_subscr_data
:
3013 dip
-> at_subscr_data
= diep
;
3015 case AT_mod_u_d_type
:
3016 dip
-> at_mod_u_d_type
= diep
;
3018 case AT_element_list
:
3019 dip
-> at_element_list
= diep
;
3020 dip
-> short_element_list
= 0;
3022 case AT_short_element_list
:
3023 dip
-> at_element_list
= diep
;
3024 dip
-> short_element_list
= 1;
3026 case AT_discr_value
:
3027 dip
-> at_discr_value
= diep
;
3029 case AT_string_length
:
3030 dip
-> at_string_length
= diep
;
3033 dip
-> at_name
= diep
;
3036 dip
-> at_comp_dir
= diep
;
3039 dip
-> at_producer
= diep
;
3042 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3044 case AT_start_scope
:
3045 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3047 case AT_stride_size
:
3048 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3051 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3054 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3057 /* Found an attribute that we are unprepared to handle. However
3058 it is specifically one of the design goals of DWARF that
3059 consumers should ignore unknown attributes. As long as the
3060 form is one that we recognize (so we know how to skip it),
3061 we can just ignore the unknown attribute. */
3068 diep
+= sizeof (short);
3071 diep
+= sizeof (long);
3074 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3078 diep
+= sizeof (long);
3081 (void) memcpy (&block2sz
, diep
, sizeof (short));
3082 block2sz
+= sizeof (short);
3086 (void) memcpy (&block4sz
, diep
, sizeof (long));
3087 block4sz
+= sizeof (long);
3091 diep
+= strlen (diep
) + 1;
3094 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));