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: Change forward declarations of static functions to allow for compilers
42 FIXME: Figure out a better way to tell gdb (all the debug reading routines)
43 the names of the gccX_compiled flags.
45 FIXME: Figure out a better way to tell gdb about the name of the function
46 contain the user's entry point (I.E. main())
48 FIXME: The current DWARF specification has a very strong bias towards
49 machines with 32-bit integers, as it assumes that many attributes of the
50 program (such as an address) will fit in such an integer. There are many
51 references in the spec to things that are 2, 4, or 8 bytes long. Given that
52 we will probably run into problems on machines where some of these assumptions
53 are invalid (64-bit ints for example), we don't bother at this time to try to
54 make this code more flexible and just use shorts, ints, and longs (and their
55 sizes) where it seems appropriate. I.E. we use a short int to hold DWARF
56 tags, and assume that the tag size in the file is the same as sizeof(short).
58 FIXME: Figure out how to get the name of the symbol indicating that a module
59 has been compiled with gcc (gcc_compiledXX) in a more portable way than
60 hardcoding it into the object file readers.
62 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
63 other things to work on, if you get bored. :-)
78 #include "elf/dwarf.h"
81 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
82 #define SQUAWK(stuff) dwarfwarn stuff
87 #ifndef R_FP /* FIXME */
88 #define R_FP 14 /* Kludge to get frame pointer register number */
91 typedef unsigned int DIEREF
; /* Reference to a DIE */
93 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
94 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
96 #define STREQ(a,b) (strcmp(a,b)==0)
98 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
99 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
100 However, the Issue 2 DWARF specification from AT&T defines it as
101 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
102 For backwards compatibility with the AT&T compiler produced executables
103 we define AT_short_element_list for this variant. */
105 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
107 /* External variables referenced. */
109 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
110 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
111 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
112 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
113 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
114 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
115 extern int info_verbose
; /* From main.c; nonzero => verbose */
118 /* The DWARF debugging information consists of two major pieces,
119 one is a block of DWARF Information Entries (DIE's) and the other
120 is a line number table. The "struct dieinfo" structure contains
121 the information for a single DIE, the one currently being processed.
123 In order to make it easier to randomly access the attribute fields
124 of the current DIE, which are specifically unordered within the DIE
125 each DIE is scanned and an instance of the "struct dieinfo"
126 structure is initialized.
128 Initialization is done in two levels. The first, done by basicdieinfo(),
129 just initializes those fields that are vital to deciding whether or not
130 to use this DIE, how to skip past it, etc. The second, done by the
131 function completedieinfo(), fills in the rest of the information.
133 Attributes which have block forms are not interpreted at the time
134 the DIE is scanned, instead we just save pointers to the start
135 of their value fields.
137 Some fields have a flag <name>_p that is set when the value of the
138 field is valid (I.E. we found a matching attribute in the DIE). Since
139 we may want to test for the presence of some attributes in the DIE,
140 such as AT_low_pc, without restricting the values of the field,
141 we need someway to note that we found such an attribute.
148 char * die
; /* Pointer to the raw DIE data */
149 long dielength
; /* Length of the raw DIE data */
150 DIEREF dieref
; /* Offset of this DIE */
151 short dietag
; /* Tag for this DIE */
156 unsigned short at_fund_type
;
157 BLOCK
* at_mod_fund_type
;
158 long at_user_def_type
;
159 BLOCK
* at_mod_u_d_type
;
161 BLOCK
* at_subscr_data
;
165 BLOCK
* at_element_list
;
172 BLOCK
* at_discr_value
;
175 BLOCK
* at_string_length
;
183 unsigned int has_at_low_pc
:1;
184 unsigned int has_at_stmt_list
:1;
185 unsigned int short_element_list
:1;
188 static int diecount
; /* Approximate count of dies for compilation unit */
189 static struct dieinfo
*curdie
; /* For warnings and such */
191 static char *dbbase
; /* Base pointer to dwarf info */
192 static int dbroff
; /* Relative offset from start of .debug section */
193 static char *lnbase
; /* Base pointer to line section */
194 static int isreg
; /* Kludge to identify register variables */
196 static CORE_ADDR baseaddr
; /* Add to each symbol value */
198 /* Each partial symbol table entry contains a pointer to private data for the
199 read_symtab() function to use when expanding a partial symbol table entry
200 to a full symbol table entry. For DWARF debugging info, this data is
201 contained in the following structure and macros are provided for easy
202 access to the members given a pointer to a partial symbol table entry.
204 dbfoff Always the absolute file offset to the start of the ".debug"
205 section for the file containing the DIE's being accessed.
207 dbroff Relative offset from the start of the ".debug" access to the
208 first DIE to be accessed. When building the partial symbol
209 table, this value will be zero since we are accessing the
210 entire ".debug" section. When expanding a partial symbol
211 table entry, this value will be the offset to the first
212 DIE for the compilation unit containing the symbol that
213 triggers the expansion.
215 dblength The size of the chunk of DIE's being examined, in bytes.
217 lnfoff The absolute file offset to the line table fragment. Ignored
218 when building partial symbol tables, but used when expanding
219 them, and contains the absolute file offset to the fragment
220 of the ".line" section containing the line numbers for the
221 current compilation unit.
225 int dbfoff
; /* Absolute file offset to start of .debug section */
226 int dbroff
; /* Relative offset from start of .debug section */
227 int dblength
; /* Size of the chunk of DIE's being examined */
228 int lnfoff
; /* Absolute file offset to line table fragment */
231 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
232 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
233 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
234 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
236 /* Record the symbols defined for each context in a linked list. We don't
237 create a struct block for the context until we know how long to make it.
238 Global symbols for each file are maintained in the global_symbols list. */
240 struct pending_symbol
{
241 struct pending_symbol
*next
; /* Next pending symbol */
242 struct symbol
*symbol
; /* The actual symbol */
245 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
246 static struct block
*global_symbol_block
;
248 /* Line number entries are read into a dynamically expandable vector before
249 being added to the symbol table section. Once we know how many there are
252 static struct linetable
*line_vector
; /* Vector of line numbers. */
253 static int line_vector_index
; /* Index of next entry. */
254 static int line_vector_length
; /* Current allocation limit */
256 /* Scope information is kept in a scope tree, one node per scope. Each time
257 a new scope is started, a child node is created under the current node
258 and set to the current scope. Each time a scope is closed, the current
259 scope moves back up the tree to the parent of the current scope.
261 Each scope contains a pointer to the list of symbols defined in the scope,
262 a pointer to the block vector for the scope, a pointer to the symbol
263 that names the scope (if any), and the range of PC values that mark
264 the start and end of the scope. */
267 struct scopenode
*parent
;
268 struct scopenode
*child
;
269 struct scopenode
*sibling
;
270 struct pending_symbol
*symbols
;
272 struct symbol
*namesym
;
277 static struct scopenode
*scopetree
;
278 static struct scopenode
*scope
;
280 /* DIES which have user defined types or modified user defined types refer to
281 other DIES for the type information. Thus we need to associate the offset
282 of a DIE for a user defined type with a pointer to the type information.
284 Originally this was done using a simple but expensive algorithm, with an
285 array of unsorted structures, each containing an offset/type-pointer pair.
286 This array was scanned linearly each time a lookup was done. The result
287 was that gdb was spending over half it's startup time munging through this
288 array of pointers looking for a structure that had the right offset member.
290 The second attempt used the same array of structures, but the array was
291 sorted using qsort each time a new offset/type was recorded, and a binary
292 search was used to find the type pointer for a given DIE offset. This was
293 even slower, due to the overhead of sorting the array each time a new
294 offset/type pair was entered.
296 The third attempt uses a fixed size array of type pointers, indexed by a
297 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
298 we can divide any DIE offset by 4 to obtain a unique index into this fixed
299 size array. Since each element is a 4 byte pointer, it takes exactly as
300 much memory to hold this array as to hold the DWARF info for a given
301 compilation unit. But it gets freed as soon as we are done with it. */
303 static struct type
**utypes
; /* Pointer to array of user type pointers */
304 static int numutypes
; /* Max number of user type pointers */
306 /* Forward declarations of static functions so we don't have to worry
307 about ordering within this file. The EXFUN macro may be slightly
308 misleading. Should probably be called DCLFUN instead, or something
309 more intuitive, since it can be used for both static and external
313 EXFUN (dwarfwarn
, (char *fmt DOTS
));
316 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
319 EXFUN (scan_compilation_units
,
320 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
321 AND
unsigned int dbfoff AND
unsigned int lnoffset
322 AND
struct objfile
*objfile
));
324 static struct partial_symtab
*
325 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
326 AND
char *filename AND CORE_ADDR textlow
327 AND CORE_ADDR texthigh AND
int dbfoff
328 AND
int curoff AND
int culength AND
int lnfoff
329 AND
struct partial_symbol
*global_syms
330 AND
struct partial_symbol
*static_syms
));
332 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
335 EXFUN(add_psymbol_to_list
,
336 (struct psymbol_allocation_list
*listp AND
char *name
337 AND
enum namespace space AND
enum address_class
class
338 AND CORE_ADDR value
));
341 EXFUN(init_psymbol_list
, (int total_symbols
));
344 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
347 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
350 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
353 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
355 static struct symtab
*
356 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
360 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
363 EXFUN(read_structure_scope
,
364 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
365 struct objfile
*objfile
));
368 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
371 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
374 EXFUN(read_array_type
, (struct dieinfo
*dip
));
377 EXFUN(read_subroutine_type
,
378 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
381 EXFUN(read_enumeration
,
382 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
386 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
387 struct objfile
*objfile
));
390 EXFUN(enum_type
, (struct dieinfo
*dip
));
393 EXFUN(start_symtab
, (void));
397 (char *filename AND
long language AND
struct objfile
*objfile
));
400 EXFUN(scopecount
, (struct scopenode
*node
));
404 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
407 EXFUN(freescope
, (struct scopenode
*node
));
409 static struct block
*
410 EXFUN(buildblock
, (struct pending_symbol
*syms
));
413 EXFUN(closescope
, (void));
416 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
419 EXFUN(decode_line_numbers
, (char *linetable
));
422 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
425 EXFUN(decode_mod_fund_type
, (char *typedata
));
428 EXFUN(decode_mod_u_d_type
, (char *typedata
));
431 EXFUN(decode_modified_type
,
432 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
435 EXFUN(decode_fund_type
, (unsigned short fundtype
));
438 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
441 EXFUN(add_symbol_to_list
,
442 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
444 static struct block
**
445 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
447 static struct blockvector
*
448 EXFUN(make_blockvector
, (void));
451 EXFUN(lookup_utype
, (DIEREF dieref
));
454 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
456 static struct symbol
*
457 EXFUN(new_symbol
, (struct dieinfo
*dip
));
460 EXFUN(locval
, (char *loc
));
463 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
464 enum misc_function_type
));
467 EXFUN(compare_psymbols
,
468 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
475 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
479 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
480 int mainline, unsigned int dbfoff, unsigned int dbsize,
481 unsigned int lnoffset, unsigned int lnsize,
482 struct objfile *objfile)
486 This function is called upon to build partial symtabs from files
487 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
489 It is passed a file descriptor for an open file containing the DIES
490 and line number information, the corresponding filename for that
491 file, a base address for relocating the symbols, a flag indicating
492 whether or not this debugging information is from a "main symbol
493 table" rather than a shared library or dynamically linked file,
494 and file offset/size pairs for the DIE information and line number
504 DEFUN(dwarf_build_psymtabs
,
505 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
511 unsigned int dbfoff AND
512 unsigned int dbsize AND
513 unsigned int lnoffset AND
514 unsigned int lnsize AND
515 struct objfile
*objfile
)
517 struct cleanup
*back_to
;
519 dbbase
= xmalloc (dbsize
);
521 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
522 (read (desc
, dbbase
, dbsize
) != dbsize
))
525 error ("can't read DWARF data from '%s'", filename
);
527 back_to
= make_cleanup (free
, dbbase
);
529 /* If we are reinitializing, or if we have never loaded syms yet, init.
530 Since we have no idea how many DIES we are looking at, we just guess
531 some arbitrary value. */
533 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
535 init_psymbol_list (1024);
538 /* Follow the compilation unit sibling chain, building a partial symbol
539 table entry for each one. Save enough information about each compilation
540 unit to locate the full DWARF information later. */
542 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
543 dbfoff
, lnoffset
, objfile
);
545 do_cleanups (back_to
);
553 record_misc_function -- add entry to miscellaneous function vector
557 static void record_misc_function (char *name, CORE_ADDR address,
558 enum misc_function_type mf_type)
562 Given a pointer to the name of a symbol that should be added to the
563 miscellaneous function vector, and the address associated with that
564 symbol, records this information for later use in building the
565 miscellaneous function vector.
570 DEFUN(record_misc_function
, (name
, address
, mf_type
),
571 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
573 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
581 dwarfwarn -- issue a DWARF related warning
585 Issue warnings about DWARF related things that aren't serious enough
586 to warrant aborting with an error, but should not be ignored either.
587 This includes things like detectable corruption in DIE's, missing
588 DIE's, unimplemented features, etc.
590 In general, running across tags or attributes that we don't recognize
591 is not considered to be a problem and we should not issue warnings
596 We mostly follow the example of the error() routine, but without
597 returning to command level. It is arguable about whether warnings
598 should be issued at all, and if so, where they should go (stdout or
601 We assume that curdie is valid and contains at least the basic
602 information for the DIE where the problem was noticed.
607 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
613 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
614 if (curdie
-> at_name
)
616 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
618 vfprintf (stderr
, fmt
, ap
);
619 fprintf (stderr
, "\n");
633 fmt
= va_arg (ap
, char *);
635 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
636 if (curdie
-> at_name
)
638 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
640 vfprintf (stderr
, fmt
, ap
);
641 fprintf (stderr
, "\n");
650 compare_psymbols -- compare two partial symbols by name
654 Given pointer to two partial symbol table entries, compare
655 them by name and return -N, 0, or +N (ala strcmp). Typically
656 used by sorting routines like qsort().
660 This is a copy from dbxread.c. It should be moved to a generic
661 gdb file and made available for all psymtab builders (FIXME).
663 Does direct compare of first two characters before punting
664 and passing to strcmp for longer compares. Note that the
665 original version had a bug whereby two null strings or two
666 identically named one character strings would return the
667 comparison of memory following the null byte.
672 DEFUN(compare_psymbols
, (s1
, s2
),
673 struct partial_symbol
*s1 AND
674 struct partial_symbol
*s2
)
676 register char *st1
= SYMBOL_NAME (s1
);
677 register char *st2
= SYMBOL_NAME (s2
);
679 if ((st1
[0] - st2
[0]) || !st1
[0])
681 return (st1
[0] - st2
[0]);
683 else if ((st1
[1] - st2
[1]) || !st1
[1])
685 return (st1
[1] - st2
[1]);
689 return (strcmp (st1
+ 2, st2
+ 2));
697 read_lexical_block_scope -- process all dies in a lexical block
701 static void read_lexical_block_scope (struct dieinfo *dip,
702 char *thisdie, char *enddie)
706 Process all the DIES contained within a lexical block scope.
707 Start a new scope, process the dies, and then close the scope.
712 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
713 struct dieinfo
*dip AND
716 struct objfile
*objfile
)
718 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
719 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
727 lookup_utype -- look up a user defined type from die reference
731 static type *lookup_utype (DIEREF dieref)
735 Given a DIE reference, lookup the user defined type associated with
736 that DIE, if it has been registered already. If not registered, then
737 return NULL. Alloc_utype() can be called to register an empty
738 type for this reference, which will be filled in later when the
739 actual referenced DIE is processed.
743 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
745 struct type
*type
= NULL
;
748 utypeidx
= (dieref
- dbroff
) / 4;
749 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
751 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
755 type
= *(utypes
+ utypeidx
);
765 alloc_utype -- add a user defined type for die reference
769 static type *alloc_utype (DIEREF dieref, struct type *utypep)
773 Given a die reference DIEREF, and a possible pointer to a user
774 defined type UTYPEP, register that this reference has a user
775 defined type and either use the specified type in UTYPEP or
776 make a new empty type that will be filled in later.
778 We should only be called after calling lookup_utype() to verify that
779 there is not currently a type registered for DIEREF.
783 DEFUN(alloc_utype
, (dieref
, utypep
),
790 utypeidx
= (dieref
- dbroff
) / 4;
791 typep
= utypes
+ utypeidx
;
792 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
794 utypep
= builtin_type_int
;
795 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
797 else if (*typep
!= NULL
)
800 SQUAWK (("internal error: dup user type allocation"));
806 utypep
= (struct type
*)
807 obstack_alloc (symbol_obstack
, sizeof (struct type
));
808 (void) memset (utypep
, 0, sizeof (struct type
));
819 decode_die_type -- return a type for a specified die
823 static struct type *decode_die_type (struct dieinfo *dip)
827 Given a pointer to a die information structure DIP, decode the
828 type of the die and return a pointer to the decoded type. All
829 dies without specific types default to type int.
833 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
835 struct type
*type
= NULL
;
837 if (dip
-> at_fund_type
!= 0)
839 type
= decode_fund_type (dip
-> at_fund_type
);
841 else if (dip
-> at_mod_fund_type
!= NULL
)
843 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
845 else if (dip
-> at_user_def_type
)
847 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
849 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
852 else if (dip
-> at_mod_u_d_type
)
854 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
858 type
= builtin_type_int
;
867 struct_type -- compute and return the type for a struct or union
871 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
872 char *enddie, struct objfile *objfile)
876 Given pointer to a die information structure for a die which
877 defines a union or structure (and MUST define one or the other),
878 and pointers to the raw die data that define the range of dies which
879 define the members, compute and return the user defined type for the
884 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
885 struct dieinfo
*dip AND
888 struct objfile
*objfile
)
892 struct nextfield
*next
;
895 struct nextfield
*list
= NULL
;
896 struct nextfield
*new;
903 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
905 /* No forward references created an empty type, so install one now */
906 type
= alloc_utype (dip
-> dieref
, NULL
);
908 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
909 obstack_alloc (symbol_obstack
, sizeof (struct cplus_struct_type
));
910 (void) memset (TYPE_CPLUS_SPECIFIC (type
), 0,
911 sizeof (struct cplus_struct_type
));
912 switch (dip
-> dietag
)
914 case TAG_structure_type
:
915 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
919 TYPE_CODE (type
) = TYPE_CODE_UNION
;
923 /* Should never happen */
924 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
926 SQUAWK (("missing structure or union tag"));
929 /* Some compilers try to be helpful by inventing "fake" names for
930 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
931 Thanks, but no thanks... */
932 if (dip
-> at_name
!= NULL
933 && *dip
-> at_name
!= '~'
934 && *dip
-> at_name
!= '.')
936 TYPE_NAME (type
) = obconcat (tpart1
, " ", dip
-> at_name
);
938 if (dip
-> at_byte_size
!= 0)
940 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
942 thisdie
+= dip
-> dielength
;
943 while (thisdie
< enddie
)
945 basicdieinfo (&mbr
, thisdie
);
946 completedieinfo (&mbr
);
947 if (mbr
.dielength
<= sizeof (long))
951 else if (mbr
.at_sibling
!= 0)
953 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
957 nextdie
= thisdie
+ mbr
.dielength
;
962 /* Get space to record the next field's data. */
963 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
967 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
968 list
-> field
.type
= decode_die_type (&mbr
);
969 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
970 list
-> field
.bitsize
= 0;
974 process_dies (thisdie
, nextdie
, objfile
);
979 /* Now create the vector of fields, and record how big it is. We may
980 not even have any fields, if this DIE was generated due to a reference
981 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
982 set, which clues gdb in to the fact that it needs to search elsewhere
983 for the full structure definition. */
986 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
990 TYPE_NFIELDS (type
) = nfields
;
991 TYPE_FIELDS (type
) = (struct field
*)
992 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
993 /* Copy the saved-up fields into the field vector. */
994 for (n
= nfields
; list
; list
= list
-> next
)
996 TYPE_FIELD (type
, --n
) = list
-> field
;
1006 read_structure_scope -- process all dies within struct or union
1010 static void read_structure_scope (struct dieinfo *dip,
1011 char *thisdie, char *enddie, struct objfile *objfile)
1015 Called when we find the DIE that starts a structure or union
1016 scope (definition) to process all dies that define the members
1017 of the structure or union. DIP is a pointer to the die info
1018 struct for the DIE that names the structure or union.
1022 Note that we need to call struct_type regardless of whether or not
1023 the DIE has an at_name attribute, since it might be an anonymous
1024 structure or union. This gets the type entered into our set of
1027 However, if the structure is incomplete (an opaque struct/union)
1028 then suppress creating a symbol table entry for it since gdb only
1029 wants to find the one with the complete definition. Note that if
1030 it is complete, we just call new_symbol, which does it's own
1031 checking about whether the struct/union is anonymous or not (and
1032 suppresses creating a symbol table entry itself).
1037 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
1038 struct dieinfo
*dip AND
1041 struct objfile
*objfile
)
1046 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1047 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1049 if ((sym
= new_symbol (dip
)) != NULL
)
1051 SYMBOL_TYPE (sym
) = type
;
1060 decode_array_element_type -- decode type of the array elements
1064 static struct type *decode_array_element_type (char *scan, char *end)
1068 As the last step in decoding the array subscript information for an
1069 array DIE, we need to decode the type of the array elements. We are
1070 passed a pointer to this last part of the subscript information and
1071 must return the appropriate type. If the type attribute is not
1072 recognized, just warn about the problem and return type int.
1075 static struct type
*
1076 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1081 unsigned short fundtype
;
1083 (void) memcpy (&attribute
, scan
, sizeof (short));
1084 scan
+= sizeof (short);
1088 (void) memcpy (&fundtype
, scan
, sizeof (short));
1089 typep
= decode_fund_type (fundtype
);
1091 case AT_mod_fund_type
:
1092 typep
= decode_mod_fund_type (scan
);
1094 case AT_user_def_type
:
1095 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1096 if ((typep
= lookup_utype (dieref
)) == NULL
)
1098 typep
= alloc_utype (dieref
, NULL
);
1101 case AT_mod_u_d_type
:
1102 typep
= decode_mod_u_d_type (scan
);
1105 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1106 typep
= builtin_type_int
;
1116 decode_subscr_data -- decode array subscript and element type data
1120 static struct type *decode_subscr_data (char *scan, char *end)
1124 The array subscripts and the data type of the elements of an
1125 array are described by a list of data items, stored as a block
1126 of contiguous bytes. There is a data item describing each array
1127 dimension, and a final data item describing the element type.
1128 The data items are ordered the same as their appearance in the
1129 source (I.E. leftmost dimension first, next to leftmost second,
1132 We are passed a pointer to the start of the block of bytes
1133 containing the data items, and a pointer to the first byte past
1134 the data. This function decodes the data and returns a type.
1137 FIXME: This code only implements the forms currently used
1138 by the AT&T and GNU C compilers.
1140 The end pointer is supplied for error checking, maybe we should
1144 static struct type
*
1145 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1147 struct type
*typep
= NULL
;
1148 struct type
*nexttype
;
1158 typep
= decode_array_element_type (scan
, end
);
1161 (void) memcpy (&fundtype
, scan
, sizeof (short));
1162 scan
+= sizeof (short);
1163 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1164 && fundtype
!= FT_unsigned_integer
)
1166 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1171 (void) memcpy (&lowbound
, scan
, sizeof (long));
1172 scan
+= sizeof (long);
1173 (void) memcpy (&highbound
, scan
, sizeof (long));
1174 scan
+= sizeof (long);
1175 nexttype
= decode_subscr_data (scan
, end
);
1176 if (nexttype
!= NULL
)
1178 typep
= (struct type
*)
1179 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1180 (void) memset (typep
, 0, sizeof (struct type
));
1181 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1182 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1183 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1184 TYPE_TARGET_TYPE (typep
) = nexttype
;
1195 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1198 SQUAWK (("unknown array subscript format %x", format
));
1208 read_array_type -- read TAG_array_type DIE
1212 static void read_array_type (struct dieinfo *dip)
1216 Extract all information from a TAG_array_type DIE and add to
1217 the user defined type vector.
1221 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1228 if (dip
-> at_ordering
!= ORD_row_major
)
1230 /* FIXME: Can gdb even handle column major arrays? */
1231 SQUAWK (("array not row major; not handled correctly"));
1233 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1235 (void) memcpy (&temp
, sub
, sizeof (short));
1236 subend
= sub
+ sizeof (short) + temp
;
1237 sub
+= sizeof (short);
1238 type
= decode_subscr_data (sub
, subend
);
1241 type
= alloc_utype (dip
-> dieref
, NULL
);
1242 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1243 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1244 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1248 type
= alloc_utype (dip
-> dieref
, type
);
1257 read_subroutine_type -- process TAG_subroutine_type dies
1261 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1266 Handle DIES due to C code like:
1269 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1275 The parameter DIES are currently ignored. See if gdb has a way to
1276 include this info in it's type system, and decode them if so. Is
1277 this what the type structure's "arg_types" field is for? (FIXME)
1281 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1282 struct dieinfo
*dip AND
1288 type
= decode_die_type (dip
);
1289 type
= lookup_function_type (type
);
1290 type
= alloc_utype (dip
-> dieref
, type
);
1297 read_enumeration -- process dies which define an enumeration
1301 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1306 Given a pointer to a die which begins an enumeration, process all
1307 the dies that define the members of the enumeration.
1311 Note that we need to call enum_type regardless of whether or not we
1312 have a symbol, since we might have an enum without a tag name (thus
1313 no symbol for the tagname).
1317 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1318 struct dieinfo
*dip AND
1325 type
= enum_type (dip
);
1326 if ((sym
= new_symbol (dip
)) != NULL
)
1328 SYMBOL_TYPE (sym
) = type
;
1336 enum_type -- decode and return a type for an enumeration
1340 static type *enum_type (struct dieinfo *dip)
1344 Given a pointer to a die information structure for the die which
1345 starts an enumeration, process all the dies that define the members
1346 of the enumeration and return a type pointer for the enumeration.
1348 At the same time, for each member of the enumeration, create a
1349 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1350 and give it the type of the enumeration itself.
1354 Note that the DWARF specification explicitly mandates that enum
1355 constants occur in reverse order from the source program order,
1356 for "consistency" and because this ordering is easier for many
1357 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1358 Entries). Because gdb wants to see the enum members in program
1359 source order, we have to ensure that the order gets reversed while
1360 we are processing them.
1363 static struct type
*
1364 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1368 struct nextfield
*next
;
1371 struct nextfield
*list
= NULL
;
1372 struct nextfield
*new;
1381 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1383 /* No forward references created an empty type, so install one now */
1384 type
= alloc_utype (dip
-> dieref
, NULL
);
1386 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1387 /* Some compilers try to be helpful by inventing "fake" names for
1388 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1389 Thanks, but no thanks... */
1390 if (dip
-> at_name
!= NULL
1391 && *dip
-> at_name
!= '~'
1392 && *dip
-> at_name
!= '.')
1394 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1396 if (dip
-> at_byte_size
!= 0)
1398 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1400 if ((scan
= dip
-> at_element_list
) != NULL
)
1402 if (dip
-> short_element_list
)
1404 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1405 listend
= scan
+ stemp
+ sizeof (stemp
);
1406 scan
+= sizeof (stemp
);
1410 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1411 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1412 scan
+= sizeof (ltemp
);
1414 while (scan
< listend
)
1416 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1419 list
-> field
.type
= NULL
;
1420 list
-> field
.bitsize
= 0;
1421 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1422 scan
+= sizeof (long);
1423 list
-> field
.name
= savestring (scan
, strlen (scan
));
1424 scan
+= strlen (scan
) + 1;
1426 /* Handcraft a new symbol for this enum member. */
1427 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1428 sizeof (struct symbol
));
1429 (void) memset (sym
, 0, sizeof (struct symbol
));
1430 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, symbol_obstack
);
1431 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1432 SYMBOL_CLASS (sym
) = LOC_CONST
;
1433 SYMBOL_TYPE (sym
) = type
;
1434 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1435 add_symbol_to_list (sym
, &scope
-> symbols
);
1437 /* Now create the vector of fields, and record how big it is. This is
1438 where we reverse the order, by pulling the members of the list in
1439 reverse order from how they were inserted. If we have no fields
1440 (this is apparently possible in C++) then skip building a field
1444 TYPE_NFIELDS (type
) = nfields
;
1445 TYPE_FIELDS (type
) = (struct field
*)
1446 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1447 /* Copy the saved-up fields into the field vector. */
1448 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1450 TYPE_FIELD (type
, n
++) = list
-> field
;
1461 read_func_scope -- process all dies within a function scope
1465 Process all dies within a given function scope. We are passed
1466 a die information structure pointer DIP for the die which
1467 starts the function scope, and pointers into the raw die data
1468 that define the dies within the function scope.
1470 For now, we ignore lexical block scopes within the function.
1471 The problem is that AT&T cc does not define a DWARF lexical
1472 block scope for the function itself, while gcc defines a
1473 lexical block scope for the function. We need to think about
1474 how to handle this difference, or if it is even a problem.
1479 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1480 struct dieinfo
*dip AND
1483 struct objfile
*objfile
)
1487 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1489 entry_scope_lowpc
= dip
-> at_low_pc
;
1490 entry_scope_highpc
= dip
-> at_high_pc
;
1492 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1494 main_scope_lowpc
= dip
-> at_low_pc
;
1495 main_scope_highpc
= dip
-> at_high_pc
;
1497 sym
= new_symbol (dip
);
1498 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1499 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1507 read_file_scope -- process all dies within a file scope
1511 Process all dies within a given file scope. We are passed a
1512 pointer to the die information structure for the die which
1513 starts the file scope, and pointers into the raw die data which
1514 mark the range of dies within the file scope.
1516 When the partial symbol table is built, the file offset for the line
1517 number table for each compilation unit is saved in the partial symbol
1518 table entry for that compilation unit. As the symbols for each
1519 compilation unit are read, the line number table is read into memory
1520 and the variable lnbase is set to point to it. Thus all we have to
1521 do is use lnbase to access the line number table for the current
1526 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1527 struct dieinfo
*dip AND
1530 struct objfile
*objfile
)
1532 struct cleanup
*back_to
;
1534 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1536 startup_file_start
= dip
-> at_low_pc
;
1537 startup_file_end
= dip
-> at_high_pc
;
1539 numutypes
= (enddie
- thisdie
) / 4;
1540 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1541 back_to
= make_cleanup (free
, utypes
);
1542 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1544 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1545 decode_line_numbers (lnbase
);
1546 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1548 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1549 do_cleanups (back_to
);
1558 start_symtab -- do initialization for starting new symbol table
1562 static void start_symtab (void)
1566 Called whenever we are starting to process dies for a new
1567 compilation unit, to perform initializations. Right now
1568 the only thing we really have to do is initialize storage
1569 space for the line number vector.
1574 DEFUN_VOID (start_symtab
)
1578 line_vector_index
= 0;
1579 line_vector_length
= 1000;
1580 nbytes
= sizeof (struct linetable
);
1581 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1582 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1589 process_dies -- process a range of DWARF Information Entries
1593 static void process_dies (char *thisdie, char *enddie,
1594 struct objfile *objfile)
1598 Process all DIE's in a specified range. May be (and almost
1599 certainly will be) called recursively.
1603 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1604 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1609 while (thisdie
< enddie
)
1611 basicdieinfo (&di
, thisdie
);
1612 if (di
.dielength
< sizeof (long))
1616 else if (di
.dietag
== TAG_padding
)
1618 nextdie
= thisdie
+ di
.dielength
;
1622 completedieinfo (&di
);
1623 if (di
.at_sibling
!= 0)
1625 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1629 nextdie
= thisdie
+ di
.dielength
;
1633 case TAG_compile_unit
:
1634 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1636 case TAG_global_subroutine
:
1637 case TAG_subroutine
:
1638 if (di
.has_at_low_pc
)
1640 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1643 case TAG_lexical_block
:
1644 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1646 case TAG_structure_type
:
1647 case TAG_union_type
:
1648 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1650 case TAG_enumeration_type
:
1651 read_enumeration (&di
, thisdie
, nextdie
);
1653 case TAG_subroutine_type
:
1654 read_subroutine_type (&di
, thisdie
, nextdie
);
1656 case TAG_array_type
:
1657 read_array_type (&di
);
1660 (void) new_symbol (&di
);
1672 end_symtab -- finish processing for a compilation unit
1676 static void end_symtab (char *filename, long language)
1680 Complete the symbol table entry for the current compilation
1681 unit. Make the struct symtab and put it on the list of all
1687 DEFUN(end_symtab
, (filename
, language
, objfile
),
1688 char *filename AND
long language AND
struct objfile
*objfile
)
1690 struct symtab
*symtab
;
1691 struct blockvector
*blockvector
;
1694 /* Ignore a file that has no functions with real debugging info. */
1695 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1699 line_vector_length
= -1;
1700 freescope (scopetree
);
1701 scope
= scopetree
= NULL
;
1704 /* Create the blockvector that points to all the file's blocks. */
1706 blockvector
= make_blockvector ();
1708 /* Now create the symtab object for this source file. */
1710 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1713 symtab
-> free_ptr
= 0;
1715 /* Fill in its components. */
1716 symtab
-> blockvector
= blockvector
;
1717 symtab
-> free_code
= free_linetable
;
1719 /* Save the line number information. */
1721 line_vector
-> nitems
= line_vector_index
;
1722 nbytes
= sizeof (struct linetable
);
1723 if (line_vector_index
> 1)
1725 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1727 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1729 /* FIXME: The following may need to be expanded for other languages */
1734 symtab
-> language
= language_c
;
1736 case LANG_C_PLUS_PLUS
:
1737 symtab
-> language
= language_cplus
;
1743 /* Link the new symtab into the list of such. */
1744 symtab
-> next
= symtab_list
;
1745 symtab_list
= symtab
;
1747 /* Recursively free the scope tree */
1748 freescope (scopetree
);
1749 scope
= scopetree
= NULL
;
1751 /* Reinitialize for beginning of new file. */
1753 line_vector_length
= -1;
1760 scopecount -- count the number of enclosed scopes
1764 static int scopecount (struct scopenode *node)
1768 Given pointer to a node, compute the size of the subtree which is
1769 rooted in this node, which also happens to be the number of scopes
1774 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1780 count
+= scopecount (node
-> child
);
1781 count
+= scopecount (node
-> sibling
);
1791 openscope -- start a new lexical block scope
1795 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1800 Start a new scope by allocating a new scopenode, adding it as the
1801 next child of the current scope (if any) or as the root of the
1802 scope tree, and then making the new node the current scope node.
1806 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1807 struct symbol
*namesym AND
1811 struct scopenode
*new;
1812 struct scopenode
*child
;
1814 new = (struct scopenode
*) xmalloc (sizeof (*new));
1815 (void) memset (new, 0, sizeof (*new));
1816 new -> namesym
= namesym
;
1817 new -> lowpc
= lowpc
;
1818 new -> highpc
= highpc
;
1823 else if ((child
= scope
-> child
) == NULL
)
1825 scope
-> child
= new;
1826 new -> parent
= scope
;
1830 while (child
-> sibling
!= NULL
)
1832 child
= child
-> sibling
;
1834 child
-> sibling
= new;
1835 new -> parent
= scope
;
1844 freescope -- free a scope tree rooted at the given node
1848 static void freescope (struct scopenode *node)
1852 Given a pointer to a node in the scope tree, free the subtree
1853 rooted at that node. First free all the children and sibling
1854 nodes, and then the node itself. Used primarily for cleaning
1855 up after ourselves and returning memory to the system.
1859 DEFUN(freescope
, (node
), struct scopenode
*node
)
1863 freescope (node
-> child
);
1864 freescope (node
-> sibling
);
1873 buildblock -- build a new block from pending symbols list
1877 static struct block *buildblock (struct pending_symbol *syms)
1881 Given a pointer to a list of symbols, build a new block and free
1882 the symbol list structure. Also check each symbol to see if it
1883 is the special symbol that flags that this block was compiled by
1884 gcc, and if so, mark the block appropriately.
1887 static struct block
*
1888 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1890 struct pending_symbol
*next
, *next1
;
1892 struct block
*newblock
;
1895 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1897 /* Allocate a new block */
1899 nbytes
= sizeof (struct block
);
1902 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1904 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1905 (void) memset (newblock
, 0, nbytes
);
1907 /* Copy the symbols into the block. */
1909 BLOCK_NSYMS (newblock
) = i
;
1910 for (next
= syms
; next
; next
= next
-> next
)
1912 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1913 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1914 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1916 BLOCK_GCC_COMPILED (newblock
) = 1;
1920 /* Now free the links of the list, and empty the list. */
1922 for (next
= syms
; next
; next
= next1
)
1924 next1
= next
-> next
;
1935 closescope -- close a lexical block scope
1939 static void closescope (void)
1943 Close the current lexical block scope. Closing the current scope
1944 is as simple as moving the current scope pointer up to the parent
1945 of the current scope pointer. But we also take this opportunity
1946 to build the block for the current scope first, since we now have
1947 all of it's symbols.
1951 DEFUN_VOID(closescope
)
1953 struct scopenode
*child
;
1957 error ("DWARF parse error, too many close scopes");
1961 if (scope
-> parent
== NULL
)
1963 global_symbol_block
= buildblock (global_symbols
);
1964 global_symbols
= NULL
;
1965 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1966 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1968 scope
-> block
= buildblock (scope
-> symbols
);
1969 scope
-> symbols
= NULL
;
1970 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1971 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1973 /* Put the local block in as the value of the symbol that names it. */
1975 if (scope
-> namesym
)
1977 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1978 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1981 /* Install this scope's local block as the superblock of all child
1984 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1986 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1989 scope
= scope
-> parent
;
1997 record_line -- record a line number entry in the line vector
2001 static void record_line (int line, CORE_ADDR pc)
2005 Given a line number and the corresponding pc value, record
2006 this pair in the line number vector, expanding the vector as
2011 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
2013 struct linetable_entry
*e
;
2016 /* Make sure line vector is big enough. */
2018 if (line_vector_index
+ 2 >= line_vector_length
)
2020 line_vector_length
*= 2;
2021 nbytes
= sizeof (struct linetable
);
2022 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
2023 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
2025 e
= line_vector
-> item
+ line_vector_index
++;
2034 decode_line_numbers -- decode a line number table fragment
2038 static void decode_line_numbers (char *tblscan, char *tblend,
2039 long length, long base, long line, long pc)
2043 Translate the DWARF line number information to gdb form.
2045 The ".line" section contains one or more line number tables, one for
2046 each ".line" section from the objects that were linked.
2048 The AT_stmt_list attribute for each TAG_source_file entry in the
2049 ".debug" section contains the offset into the ".line" section for the
2050 start of the table for that file.
2052 The table itself has the following structure:
2054 <table length><base address><source statement entry>
2055 4 bytes 4 bytes 10 bytes
2057 The table length is the total size of the table, including the 4 bytes
2058 for the length information.
2060 The base address is the address of the first instruction generated
2061 for the source file.
2063 Each source statement entry has the following structure:
2065 <line number><statement position><address delta>
2066 4 bytes 2 bytes 4 bytes
2068 The line number is relative to the start of the file, starting with
2071 The statement position either -1 (0xFFFF) or the number of characters
2072 from the beginning of the line to the beginning of the statement.
2074 The address delta is the difference between the base address and
2075 the address of the first instruction for the statement.
2077 Note that we must copy the bytes from the packed table to our local
2078 variables before attempting to use them, to avoid alignment problems
2079 on some machines, particularly RISC processors.
2083 Does gdb expect the line numbers to be sorted? They are now by
2084 chance/luck, but are not required to be. (FIXME)
2086 The line with number 0 is unused, gdb apparently can discover the
2087 span of the last line some other way. How? (FIXME)
2091 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2100 if (linetable
!= NULL
)
2102 tblscan
= tblend
= linetable
;
2103 (void) memcpy (&length
, tblscan
, sizeof (long));
2104 tblscan
+= sizeof (long);
2106 (void) memcpy (&base
, tblscan
, sizeof (long));
2108 tblscan
+= sizeof (long);
2109 while (tblscan
< tblend
)
2111 (void) memcpy (&line
, tblscan
, sizeof (long));
2112 tblscan
+= sizeof (long) + sizeof (short);
2113 (void) memcpy (&pc
, tblscan
, sizeof (long));
2114 tblscan
+= sizeof (long);
2118 record_line (line
, pc
);
2128 add_symbol_to_list -- add a symbol to head of current symbol list
2132 static void add_symbol_to_list (struct symbol *symbol, struct
2133 pending_symbol **listhead)
2137 Given a pointer to a symbol and a pointer to a pointer to a
2138 list of symbols, add this symbol as the current head of the
2139 list. Typically used for example to add a symbol to the
2140 symbol list for the current scope.
2145 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2146 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2148 struct pending_symbol
*link
;
2152 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2153 link
-> next
= *listhead
;
2154 link
-> symbol
= symbol
;
2163 gatherblocks -- walk a scope tree and build block vectors
2167 static struct block **gatherblocks (struct block **dest,
2168 struct scopenode *node)
2172 Recursively walk a scope tree rooted in the given node, adding blocks
2173 to the array pointed to by DEST, in preorder. I.E., first we add the
2174 block for the current scope, then all the blocks for child scopes,
2175 and finally all the blocks for sibling scopes.
2178 static struct block
**
2179 DEFUN(gatherblocks
, (dest
, node
),
2180 struct block
**dest AND
struct scopenode
*node
)
2184 *dest
++ = node
-> block
;
2185 dest
= gatherblocks (dest
, node
-> child
);
2186 dest
= gatherblocks (dest
, node
-> sibling
);
2195 make_blockvector -- make a block vector from current scope tree
2199 static struct blockvector *make_blockvector (void)
2203 Make a blockvector from all the blocks in the current scope tree.
2204 The first block is always the global symbol block, followed by the
2205 block for the root of the scope tree which is the local symbol block,
2206 followed by all the remaining blocks in the scope tree, which are all
2211 Note that since the root node of the scope tree is created at the time
2212 each file scope is entered, there are always at least two blocks,
2213 neither of which may have any symbols, but always contribute a block
2214 to the block vector. So the test for number of blocks greater than 1
2215 below is unnecessary given bug free code.
2217 The resulting block structure varies slightly from that produced
2218 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2219 with dbxread.c, block 1 is a child of block 0. This does not
2220 seem to cause any problems, but probably should be fixed. (FIXME)
2223 static struct blockvector
*
2224 DEFUN_VOID(make_blockvector
)
2226 struct blockvector
*blockvector
= NULL
;
2230 /* Recursively walk down the tree, counting the number of blocks.
2231 Then add one to account for the global's symbol block */
2233 i
= scopecount (scopetree
) + 1;
2234 nbytes
= sizeof (struct blockvector
);
2237 nbytes
+= (i
- 1) * sizeof (struct block
*);
2239 blockvector
= (struct blockvector
*)
2240 obstack_alloc (symbol_obstack
, nbytes
);
2242 /* Copy the blocks into the blockvector. */
2244 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2245 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2246 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2248 return (blockvector
);
2255 locval -- compute the value of a location attribute
2259 static int locval (char *loc)
2263 Given pointer to a string of bytes that define a location, compute
2264 the location and return the value.
2266 When computing values involving the current value of the frame pointer,
2267 the value zero is used, which results in a value relative to the frame
2268 pointer, rather than the absolute value. This is what GDB wants
2271 When the result is a register number, the global isreg flag is set,
2272 otherwise it is cleared. This is a kludge until we figure out a better
2273 way to handle the problem. Gdb's design does not mesh well with the
2274 DWARF notion of a location computing interpreter, which is a shame
2275 because the flexibility goes unused.
2279 Note that stack[0] is unused except as a default error return.
2280 Note that stack overflow is not yet handled.
2284 DEFUN(locval
, (loc
), char *loc
)
2286 unsigned short nbytes
;
2292 (void) memcpy (&nbytes
, loc
, sizeof (short));
2293 end
= loc
+ sizeof (short) + nbytes
;
2297 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2305 /* push register (number) */
2306 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2310 /* push value of register (number) */
2311 /* Actually, we compute the value as if register has 0 */
2312 (void) memcpy (®no
, loc
, sizeof (long));
2315 stack
[++stacki
] = 0;
2319 stack
[++stacki
] = 0;
2320 SQUAWK (("BASEREG %d not handled!", regno
));
2324 /* push address (relocated address) */
2325 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2328 /* push constant (number) */
2329 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2332 /* pop, deref and push 2 bytes (as a long) */
2333 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2335 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2336 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2338 case OP_ADD
: /* pop top 2 items, add, push result */
2339 stack
[stacki
- 1] += stack
[stacki
];
2344 return (stack
[stacki
]);
2351 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2355 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2359 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2362 static struct symtab
*
2363 DEFUN(read_ofile_symtab
, (pst
),
2364 struct partial_symtab
*pst
)
2366 struct cleanup
*back_to
;
2369 bfd
*abfd
= pst
->objfile
->obfd
;
2371 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2372 unit, seek to the location in the file, and read in all the DIE's. */
2375 dbbase
= xmalloc (DBLENGTH(pst
));
2376 dbroff
= DBROFF(pst
);
2377 foffset
= DBFOFF(pst
) + dbroff
;
2378 if (bfd_seek (abfd
, foffset
, 0) ||
2379 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2382 error ("can't read DWARF data");
2384 back_to
= make_cleanup (free
, dbbase
);
2386 /* If there is a line number table associated with this compilation unit
2387 then read the first long word from the line number table fragment, which
2388 contains the size of the fragment in bytes (including the long word
2389 itself). Allocate a buffer for the fragment and read it in for future
2395 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2396 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2398 error ("can't read DWARF line number table size");
2400 lnbase
= xmalloc (lnsize
);
2401 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2402 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2405 error ("can't read DWARF line numbers");
2407 make_cleanup (free
, lnbase
);
2410 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2411 do_cleanups (back_to
);
2412 return (symtab_list
);
2419 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2423 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2427 Called once for each partial symbol table entry that needs to be
2428 expanded into a full symbol table entry.
2433 DEFUN(psymtab_to_symtab_1
,
2435 struct partial_symtab
*pst
)
2445 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2450 /* Read in all partial symtabs on which this one is dependent */
2451 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2452 if (!pst
-> dependencies
[i
] -> readin
)
2454 /* Inform about additional files that need to be read in. */
2457 fputs_filtered (" ", stdout
);
2459 fputs_filtered ("and ", stdout
);
2461 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2462 wrap_here (""); /* Flush output */
2465 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2468 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2470 /* Init stuff necessary for reading in symbols */
2471 pst
-> symtab
= read_ofile_symtab (pst
);
2474 printf_filtered ("%d DIE's, sorting...", diecount
);
2477 sort_symtab_syms (pst
-> symtab
);
2486 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2490 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2494 This is the DWARF support entry point for building a full symbol
2495 table entry from a partial symbol table entry. We are passed a
2496 pointer to the partial symbol table entry that needs to be expanded.
2501 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2510 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2515 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2517 /* Print the message now, before starting serious work, to avoid
2518 disconcerting pauses. */
2521 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2525 psymtab_to_symtab_1 (pst
);
2527 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2528 we need to do an equivalent or is this something peculiar to
2529 stabs/a.out format. */
2530 /* Match with global symbols. This only needs to be done once,
2531 after all of the symtabs and dependencies have been read in. */
2532 scan_file_globals ();
2535 /* Finish up the debug error message. */
2538 printf_filtered ("done.\n");
2547 init_psymbol_list -- initialize storage for partial symbols
2551 static void init_psymbol_list (int total_symbols)
2555 Initializes storage for all of the partial symbols that will be
2556 created by dwarf_build_psymtabs and subsidiaries.
2560 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2562 /* Free any previously allocated psymbol lists. */
2564 if (global_psymbols
.list
)
2566 free (global_psymbols
.list
);
2568 if (static_psymbols
.list
)
2570 free (static_psymbols
.list
);
2573 /* Current best guess is that there are approximately a twentieth
2574 of the total symbols (in a debugging file) are global or static
2577 global_psymbols
.size
= total_symbols
/ 10;
2578 static_psymbols
.size
= total_symbols
/ 10;
2579 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2580 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2581 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2582 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2589 start_psymtab -- allocate and partially fill a partial symtab entry
2593 Allocate and partially fill a partial symtab. It will be completely
2594 filled at the end of the symbol list.
2596 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2597 ADDR is the address relative to which its symbols are (incremental)
2598 or 0 (normal). FILENAME is the name of the compilation unit that
2599 these symbols were defined in, and they appear starting a address
2600 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2601 the full symbols can be read for compilation unit FILENAME.
2602 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2607 static struct partial_symtab
*
2608 DEFUN(start_psymtab
,
2609 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2610 culength
, lnfoff
, global_syms
, static_syms
),
2611 struct objfile
*objfile AND
2614 CORE_ADDR textlow AND
2615 CORE_ADDR texthigh AND
2620 struct partial_symbol
*global_syms AND
2621 struct partial_symbol
*static_syms
)
2623 struct partial_symtab
*result
;
2625 result
= (struct partial_symtab
*)
2626 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2627 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2628 result
-> addr
= addr
;
2629 result
-> objfile
= objfile
;
2630 result
-> filename
= create_name (filename
, psymbol_obstack
);
2631 result
-> textlow
= textlow
;
2632 result
-> texthigh
= texthigh
;
2633 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2634 sizeof (struct dwfinfo
));
2635 DBFOFF (result
) = dbfoff
;
2636 DBROFF (result
) = curoff
;
2637 DBLENGTH (result
) = culength
;
2638 LNFOFF (result
) = lnfoff
;
2639 result
-> readin
= 0;
2640 result
-> symtab
= NULL
;
2641 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2642 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2643 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2645 result
->n_global_syms
= 0;
2646 result
->n_static_syms
= 0;
2655 add_psymbol_to_list -- add a partial symbol to given list
2659 Add a partial symbol to one of the partial symbol vectors (pointed to
2660 by listp). The vector is grown as necessary.
2665 DEFUN(add_psymbol_to_list
,
2666 (listp
, name
, space
, class, value
),
2667 struct psymbol_allocation_list
*listp AND
2669 enum namespace space AND
2670 enum address_class
class AND
2673 struct partial_symbol
*psym
;
2676 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2678 newsize
= listp
-> size
* 2;
2679 listp
-> list
= (struct partial_symbol
*)
2680 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2681 /* Next assumes we only went one over. Should be good if program works
2683 listp
-> next
= listp
-> list
+ listp
-> size
;
2684 listp
-> size
= newsize
;
2686 psym
= listp
-> next
++;
2687 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2688 SYMBOL_NAMESPACE (psym
) = space
;
2689 SYMBOL_CLASS (psym
) = class;
2690 SYMBOL_VALUE (psym
) = value
;
2697 add_enum_psymbol -- add enumeration members to partial symbol table
2701 Given pointer to a DIE that is known to be for an enumeration,
2702 extract the symbolic names of the enumeration members and add
2703 partial symbols for them.
2707 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2714 if ((scan
= dip
-> at_element_list
) != NULL
)
2716 if (dip
-> short_element_list
)
2718 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2719 listend
= scan
+ stemp
+ sizeof (stemp
);
2720 scan
+= sizeof (stemp
);
2724 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2725 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2726 scan
+= sizeof (ltemp
);
2728 while (scan
< listend
)
2730 scan
+= sizeof (long);
2731 add_psymbol_to_list (&static_psymbols
, scan
, VAR_NAMESPACE
,
2733 scan
+= strlen (scan
) + 1;
2742 add_partial_symbol -- add symbol to partial symbol table
2746 Given a DIE, if it is one of the types that we want to
2747 add to a partial symbol table, finish filling in the die info
2748 and then add a partial symbol table entry for it.
2753 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2755 switch (dip
-> dietag
)
2757 case TAG_global_subroutine
:
2758 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2759 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2760 LOC_BLOCK
, dip
-> at_low_pc
);
2762 case TAG_global_variable
:
2763 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2765 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2768 case TAG_subroutine
:
2769 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2770 LOC_BLOCK
, dip
-> at_low_pc
);
2772 case TAG_local_variable
:
2773 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2777 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2780 case TAG_structure_type
:
2781 case TAG_union_type
:
2782 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2785 case TAG_enumeration_type
:
2788 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
,
2789 STRUCT_NAMESPACE
, LOC_TYPEDEF
, 0);
2791 add_enum_psymbol (dip
);
2800 scan_partial_symbols -- scan DIE's within a single compilation unit
2804 Process the DIE's within a single compilation unit, looking for
2805 interesting DIE's that contribute to the partial symbol table entry
2806 for this compilation unit. Since we cannot follow any sibling
2807 chains without reading the complete DIE info for every DIE,
2808 it is probably faster to just sequentially check each one to
2809 see if it is one of the types we are interested in, and if so,
2810 then extract all the attributes info and generate a partial
2815 Don't attempt to add anonymous structures or unions since they have
2816 no name. Anonymous enumerations however are processed, because we
2817 want to extract their member names (the check for a tag name is
2820 Also, for variables and subroutines, check that this is the place
2821 where the actual definition occurs, rather than just a reference
2826 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2831 while (thisdie
< enddie
)
2833 basicdieinfo (&di
, thisdie
);
2834 if (di
.dielength
< sizeof (long))
2840 nextdie
= thisdie
+ di
.dielength
;
2841 /* To avoid getting complete die information for every die, we
2842 only do it (below) for the cases we are interested in. */
2845 case TAG_global_subroutine
:
2846 case TAG_subroutine
:
2847 case TAG_global_variable
:
2848 case TAG_local_variable
:
2849 completedieinfo (&di
);
2850 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2852 add_partial_symbol (&di
);
2856 case TAG_structure_type
:
2857 case TAG_union_type
:
2858 completedieinfo (&di
);
2861 add_partial_symbol (&di
);
2864 case TAG_enumeration_type
:
2865 completedieinfo (&di
);
2866 add_partial_symbol (&di
);
2878 scan_compilation_units -- build a psymtab entry for each compilation
2882 This is the top level dwarf parsing routine for building partial
2885 It scans from the beginning of the DWARF table looking for the first
2886 TAG_compile_unit DIE, and then follows the sibling chain to locate
2887 each additional TAG_compile_unit DIE.
2889 For each TAG_compile_unit DIE it creates a partial symtab structure,
2890 calls a subordinate routine to collect all the compilation unit's
2891 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2892 new partial symtab structure into the partial symbol table. It also
2893 records the appropriate information in the partial symbol table entry
2894 to allow the chunk of DIE's and line number table for this compilation
2895 unit to be located and re-read later, to generate a complete symbol
2896 table entry for the compilation unit.
2898 Thus it effectively partitions up a chunk of DIE's for multiple
2899 compilation units into smaller DIE chunks and line number tables,
2900 and associates them with a partial symbol table entry.
2904 If any compilation unit has no line number table associated with
2905 it for some reason (a missing at_stmt_list attribute, rather than
2906 just one with a value of zero, which is valid) then we ensure that
2907 the recorded file offset is zero so that the routine which later
2908 reads line number table fragments knows that there is no fragment
2918 DEFUN(scan_compilation_units
,
2919 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2924 unsigned int dbfoff AND
2925 unsigned int lnoffset AND
2926 struct objfile
*objfile
)
2930 struct partial_symtab
*pst
;
2935 while (thisdie
< enddie
)
2937 basicdieinfo (&di
, thisdie
);
2938 if (di
.dielength
< sizeof (long))
2942 else if (di
.dietag
!= TAG_compile_unit
)
2944 nextdie
= thisdie
+ di
.dielength
;
2948 completedieinfo (&di
);
2949 if (di
.at_sibling
!= 0)
2951 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2955 nextdie
= thisdie
+ di
.dielength
;
2957 curoff
= thisdie
- dbbase
;
2958 culength
= nextdie
- thisdie
;
2959 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2960 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2961 di
.at_low_pc
, di
.at_high_pc
,
2962 dbfoff
, curoff
, culength
, curlnoffset
,
2963 global_psymbols
.next
,
2964 static_psymbols
.next
);
2965 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2966 pst
-> n_global_syms
= global_psymbols
.next
-
2967 (global_psymbols
.list
+ pst
-> globals_offset
);
2968 pst
-> n_static_syms
= static_psymbols
.next
-
2969 (static_psymbols
.list
+ pst
-> statics_offset
);
2970 /* Sort the global list; don't sort the static list */
2971 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2972 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2974 /* If there is already a psymtab or symtab for a file of this name,
2975 remove it. (If there is a symtab, more drastic things also
2976 happen.) This happens in VxWorks. */
2977 free_named_symtabs (pst
-> filename
);
2978 /* Place the partial symtab on the partial symtab list */
2979 pst
-> next
= partial_symtab_list
;
2980 partial_symtab_list
= pst
;
2990 new_symbol -- make a symbol table entry for a new symbol
2994 static struct symbol *new_symbol (struct dieinfo *dip)
2998 Given a pointer to a DWARF information entry, figure out if we need
2999 to make a symbol table entry for it, and if so, create a new entry
3000 and return a pointer to it.
3003 static struct symbol
*
3004 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
3006 struct symbol
*sym
= NULL
;
3008 if (dip
-> at_name
!= NULL
)
3010 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
3011 sizeof (struct symbol
));
3012 (void) memset (sym
, 0, sizeof (struct symbol
));
3013 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
3014 /* default assumptions */
3015 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3016 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3017 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
3018 switch (dip
-> dietag
)
3021 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
3022 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3024 case TAG_global_subroutine
:
3025 case TAG_subroutine
:
3026 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
3027 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
3028 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3029 if (dip
-> dietag
== TAG_global_subroutine
)
3031 add_symbol_to_list (sym
, &global_symbols
);
3035 add_symbol_to_list (sym
, &scope
-> symbols
);
3038 case TAG_global_variable
:
3039 case TAG_local_variable
:
3040 if (dip
-> at_location
!= NULL
)
3042 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3044 if (dip
-> dietag
== TAG_global_variable
)
3046 add_symbol_to_list (sym
, &global_symbols
);
3047 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3048 SYMBOL_VALUE (sym
) += baseaddr
;
3052 add_symbol_to_list (sym
, &scope
-> symbols
);
3053 if (scope
-> parent
!= NULL
)
3057 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3061 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3066 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3067 SYMBOL_VALUE (sym
) += baseaddr
;
3071 case TAG_formal_parameter
:
3072 if (dip
-> at_location
!= NULL
)
3074 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3076 add_symbol_to_list (sym
, &scope
-> symbols
);
3079 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3083 SYMBOL_CLASS (sym
) = LOC_ARG
;
3086 case TAG_unspecified_parameters
:
3087 /* From varargs functions; gdb doesn't seem to have any interest in
3088 this information, so just ignore it for now. (FIXME?) */
3090 case TAG_structure_type
:
3091 case TAG_union_type
:
3092 case TAG_enumeration_type
:
3093 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3094 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3095 add_symbol_to_list (sym
, &scope
-> symbols
);
3098 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3099 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3100 add_symbol_to_list (sym
, &scope
-> symbols
);
3103 /* Not a tag we recognize. Hopefully we aren't processing trash
3104 data, but since we must specifically ignore things we don't
3105 recognize, there is nothing else we should do at this point. */
3116 decode_mod_fund_type -- decode a modified fundamental type
3120 static struct type *decode_mod_fund_type (char *typedata)
3124 Decode a block of data containing a modified fundamental
3125 type specification. TYPEDATA is a pointer to the block,
3126 which consists of a two byte length, containing the size
3127 of the rest of the block. At the end of the block is a
3128 two byte value that gives the fundamental type. Everything
3129 in between are type modifiers.
3131 We simply compute the number of modifiers and call the general
3132 function decode_modified_type to do the actual work.
3135 static struct type
*
3136 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3138 struct type
*typep
= NULL
;
3139 unsigned short modcount
;
3140 unsigned char *modifiers
;
3142 /* Get the total size of the block, exclusive of the size itself */
3143 (void) memcpy (&modcount
, typedata
, sizeof (short));
3144 /* Deduct the size of the fundamental type bytes at the end of the block. */
3145 modcount
-= sizeof (short);
3146 /* Skip over the two size bytes at the beginning of the block. */
3147 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3148 /* Now do the actual decoding */
3149 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3157 decode_mod_u_d_type -- decode a modified user defined type
3161 static struct type *decode_mod_u_d_type (char *typedata)
3165 Decode a block of data containing a modified user defined
3166 type specification. TYPEDATA is a pointer to the block,
3167 which consists of a two byte length, containing the size
3168 of the rest of the block. At the end of the block is a
3169 four byte value that gives a reference to a user defined type.
3170 Everything in between are type modifiers.
3172 We simply compute the number of modifiers and call the general
3173 function decode_modified_type to do the actual work.
3176 static struct type
*
3177 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3179 struct type
*typep
= NULL
;
3180 unsigned short modcount
;
3181 unsigned char *modifiers
;
3183 /* Get the total size of the block, exclusive of the size itself */
3184 (void) memcpy (&modcount
, typedata
, sizeof (short));
3185 /* Deduct the size of the reference type bytes at the end of the block. */
3186 modcount
-= sizeof (long);
3187 /* Skip over the two size bytes at the beginning of the block. */
3188 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3189 /* Now do the actual decoding */
3190 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3198 decode_modified_type -- decode modified user or fundamental type
3202 static struct type *decode_modified_type (unsigned char *modifiers,
3203 unsigned short modcount, int mtype)
3207 Decode a modified type, either a modified fundamental type or
3208 a modified user defined type. MODIFIERS is a pointer to the
3209 block of bytes that define MODCOUNT modifiers. Immediately
3210 following the last modifier is a short containing the fundamental
3211 type or a long containing the reference to the user defined
3212 type. Which one is determined by MTYPE, which is either
3213 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3214 type we are generating.
3216 We call ourself recursively to generate each modified type,`
3217 until MODCOUNT reaches zero, at which point we have consumed
3218 all the modifiers and generate either the fundamental type or
3219 user defined type. When the recursion unwinds, each modifier
3220 is applied in turn to generate the full modified type.
3224 If we find a modifier that we don't recognize, and it is not one
3225 of those reserved for application specific use, then we issue a
3226 warning and simply ignore the modifier.
3230 We currently ignore MOD_const and MOD_volatile. (FIXME)
3234 static struct type
*
3235 DEFUN(decode_modified_type
,
3236 (modifiers
, modcount
, mtype
),
3237 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3239 struct type
*typep
= NULL
;
3240 unsigned short fundtype
;
3242 unsigned char modifier
;
3248 case AT_mod_fund_type
:
3249 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3250 typep
= decode_fund_type (fundtype
);
3252 case AT_mod_u_d_type
:
3253 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3254 if ((typep
= lookup_utype (dieref
)) == NULL
)
3256 typep
= alloc_utype (dieref
, NULL
);
3260 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3261 typep
= builtin_type_int
;
3267 modifier
= *modifiers
++;
3268 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3271 case MOD_pointer_to
:
3272 typep
= lookup_pointer_type (typep
);
3274 case MOD_reference_to
:
3275 typep
= lookup_reference_type (typep
);
3278 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3281 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3284 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3286 SQUAWK (("unknown type modifier %u", modifier
));
3298 decode_fund_type -- translate basic DWARF type to gdb base type
3302 Given an integer that is one of the fundamental DWARF types,
3303 translate it to one of the basic internal gdb types and return
3304 a pointer to the appropriate gdb type (a "struct type *").
3308 If we encounter a fundamental type that we are unprepared to
3309 deal with, and it is not in the range of those types defined
3310 as application specific types, then we issue a warning and
3311 treat the type as builtin_type_int.
3314 static struct type
*
3315 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3317 struct type
*typep
= NULL
;
3323 typep
= builtin_type_void
;
3326 case FT_pointer
: /* (void *) */
3327 typep
= lookup_pointer_type (builtin_type_void
);
3331 case FT_signed_char
:
3332 typep
= builtin_type_char
;
3336 case FT_signed_short
:
3337 typep
= builtin_type_short
;
3341 case FT_signed_integer
:
3342 case FT_boolean
: /* Was FT_set in AT&T version */
3343 typep
= builtin_type_int
;
3347 case FT_signed_long
:
3348 typep
= builtin_type_long
;
3352 typep
= builtin_type_float
;
3355 case FT_dbl_prec_float
:
3356 typep
= builtin_type_double
;
3359 case FT_unsigned_char
:
3360 typep
= builtin_type_unsigned_char
;
3363 case FT_unsigned_short
:
3364 typep
= builtin_type_unsigned_short
;
3367 case FT_unsigned_integer
:
3368 typep
= builtin_type_unsigned_int
;
3371 case FT_unsigned_long
:
3372 typep
= builtin_type_unsigned_long
;
3375 case FT_ext_prec_float
:
3376 typep
= builtin_type_long_double
;
3380 typep
= builtin_type_complex
;
3383 case FT_dbl_prec_complex
:
3384 typep
= builtin_type_double_complex
;
3388 case FT_signed_long_long
:
3389 typep
= builtin_type_long_long
;
3392 case FT_unsigned_long_long
:
3393 typep
= builtin_type_unsigned_long_long
;
3398 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3400 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3401 typep
= builtin_type_void
;
3411 create_name -- allocate a fresh copy of a string on an obstack
3415 Given a pointer to a string and a pointer to an obstack, allocates
3416 a fresh copy of the string on the specified obstack.
3421 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3426 length
= strlen (name
) + 1;
3427 newname
= (char *) obstack_alloc (obstackp
, length
);
3428 (void) strcpy (newname
, name
);
3436 basicdieinfo -- extract the minimal die info from raw die data
3440 void basicdieinfo (char *diep, struct dieinfo *dip)
3444 Given a pointer to raw DIE data, and a pointer to an instance of a
3445 die info structure, this function extracts the basic information
3446 from the DIE data required to continue processing this DIE, along
3447 with some bookkeeping information about the DIE.
3449 The information we absolutely must have includes the DIE tag,
3450 and the DIE length. If we need the sibling reference, then we
3451 will have to call completedieinfo() to process all the remaining
3454 Note that since there is no guarantee that the data is properly
3455 aligned in memory for the type of access required (indirection
3456 through anything other than a char pointer), we use memcpy to
3457 shuffle data items larger than a char. Possibly inefficient, but
3460 We also take care of some other basic things at this point, such
3461 as ensuring that the instance of the die info structure starts
3462 out completely zero'd and that curdie is initialized for use
3463 in error reporting if we have a problem with the current die.
3467 All DIE's must have at least a valid length, thus the minimum
3468 DIE size is sizeof (long). In order to have a valid tag, the
3469 DIE size must be at least sizeof (short) larger, otherwise they
3470 are forced to be TAG_padding DIES.
3472 Padding DIES must be at least sizeof(long) in length, implying that
3473 if a padding DIE is used for alignment and the amount needed is less
3474 than sizeof(long) then the padding DIE has to be big enough to align
3475 to the next alignment boundry.
3479 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3482 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3484 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3485 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3486 if (dip
-> dielength
< sizeof (long))
3488 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3490 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3492 dip
-> dietag
= TAG_padding
;
3496 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3504 completedieinfo -- finish reading the information for a given DIE
3508 void completedieinfo (struct dieinfo *dip)
3512 Given a pointer to an already partially initialized die info structure,
3513 scan the raw DIE data and finish filling in the die info structure
3514 from the various attributes found.
3516 Note that since there is no guarantee that the data is properly
3517 aligned in memory for the type of access required (indirection
3518 through anything other than a char pointer), we use memcpy to
3519 shuffle data items larger than a char. Possibly inefficient, but
3524 Each time we are called, we increment the diecount variable, which
3525 keeps an approximate count of the number of dies processed for
3526 each compilation unit. This information is presented to the user
3527 if the info_verbose flag is set.
3532 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3534 char *diep
; /* Current pointer into raw DIE data */
3535 char *end
; /* Terminate DIE scan here */
3536 unsigned short attr
; /* Current attribute being scanned */
3537 unsigned short form
; /* Form of the attribute */
3538 short block2sz
; /* Size of a block2 attribute field */
3539 long block4sz
; /* Size of a block4 attribute field */
3543 end
= diep
+ dip
-> dielength
;
3544 diep
+= sizeof (long) + sizeof (short);
3547 (void) memcpy (&attr
, diep
, sizeof (short));
3548 diep
+= sizeof (short);
3552 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3555 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3558 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3561 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3564 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3567 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3568 dip
-> has_at_stmt_list
= 1;
3571 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3572 dip
-> has_at_low_pc
= 1;
3575 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3578 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3580 case AT_user_def_type
:
3581 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3584 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3587 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3590 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3593 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3596 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3599 dip
-> at_location
= diep
;
3601 case AT_mod_fund_type
:
3602 dip
-> at_mod_fund_type
= diep
;
3604 case AT_subscr_data
:
3605 dip
-> at_subscr_data
= diep
;
3607 case AT_mod_u_d_type
:
3608 dip
-> at_mod_u_d_type
= diep
;
3610 case AT_element_list
:
3611 dip
-> at_element_list
= diep
;
3612 dip
-> short_element_list
= 0;
3614 case AT_short_element_list
:
3615 dip
-> at_element_list
= diep
;
3616 dip
-> short_element_list
= 1;
3618 case AT_discr_value
:
3619 dip
-> at_discr_value
= diep
;
3621 case AT_string_length
:
3622 dip
-> at_string_length
= diep
;
3625 dip
-> at_name
= diep
;
3628 dip
-> at_comp_dir
= diep
;
3631 dip
-> at_producer
= diep
;
3634 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3636 case AT_start_scope
:
3637 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3639 case AT_stride_size
:
3640 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3643 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3646 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3649 /* Found an attribute that we are unprepared to handle. However
3650 it is specifically one of the design goals of DWARF that
3651 consumers should ignore unknown attributes. As long as the
3652 form is one that we recognize (so we know how to skip it),
3653 we can just ignore the unknown attribute. */
3660 diep
+= sizeof (short);
3663 diep
+= sizeof (long);
3666 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3670 diep
+= sizeof (long);
3673 (void) memcpy (&block2sz
, diep
, sizeof (short));
3674 block2sz
+= sizeof (short);
3678 (void) memcpy (&block4sz
, diep
, sizeof (long));
3679 block4sz
+= sizeof (long);
3683 diep
+= strlen (diep
) + 1;
3686 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));