2 /* DWARF debugging format support for GDB.
3 Copyright (C) 1991 Free Software Foundation, Inc.
4 Written by Fred Fish at Cygnus Support, portions based on dbxread.c,
5 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 FIXME: Figure out how to get the frame pointer register number in the
26 execution environment of the target. Remove R_FP kludge
28 FIXME: Add generation of dependencies list to partial symtab code.
30 FIXME: Currently we ignore host/target byte ordering and integer size
31 differences. Should remap data from external form to an internal form
32 before trying to use it.
34 FIXME: Resolve minor differences between what information we put in the
35 partial symbol table and what dbxread puts in. For example, we don't yet
36 put enum constants there. And dbxread seems to invent a lot of typedefs
37 we never see. Use the new printpsym command to see the partial symbol table
40 FIXME: Change forward declarations of static functions to allow for compilers
43 FIXME: Figure out a better way to tell gdb (all the debug reading routines)
44 the names of the gccX_compiled flags.
46 FIXME: Figure out a better way to tell gdb about the name of the function
47 contain the user's entry point (I.E. main())
49 FIXME: The current DWARF specification has a very strong bias towards
50 machines with 32-bit integers, as it assumes that many attributes of the
51 program (such as an address) will fit in such an integer. There are many
52 references in the spec to things that are 2, 4, or 8 bytes long. Given that
53 we will probably run into problems on machines where some of these assumptions
54 are invalid (64-bit ints for example), we don't bother at this time to try to
55 make this code more flexible and just use shorts, ints, and longs (and their
56 sizes) where it seems appropriate. I.E. we use a short int to hold DWARF
57 tags, and assume that the tag size in the file is the same as sizeof(short).
59 FIXME: Figure out how to get the name of the symbol indicating that a module
60 has been compiled with gcc (gcc_compiledXX) in a more portable way than
61 hardcoding it into the object file readers.
63 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
64 other things to work on, if you get bored. :-)
79 #include "elf/dwarf.h"
82 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
83 #define SQUAWK(stuff) dwarfwarn stuff
88 #ifndef R_FP /* FIXME */
89 #define R_FP 14 /* Kludge to get frame pointer register number */
92 typedef unsigned int DIEREF
; /* Reference to a DIE */
94 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
95 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
97 #define STREQ(a,b) (strcmp(a,b)==0)
99 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
100 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
101 However, the Issue 2 DWARF specification from AT&T defines it as
102 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
103 For backwards compatibility with the AT&T compiler produced executables
104 we define AT_short_element_list for this variant. */
106 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
108 /* External variables referenced. */
110 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
111 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
112 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
113 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
114 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
115 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
116 extern int info_verbose
; /* From main.c; nonzero => verbose */
119 /* The DWARF debugging information consists of two major pieces,
120 one is a block of DWARF Information Entries (DIE's) and the other
121 is a line number table. The "struct dieinfo" structure contains
122 the information for a single DIE, the one currently being processed.
124 In order to make it easier to randomly access the attribute fields
125 of the current DIE, which are specifically unordered within the DIE
126 each DIE is scanned and an instance of the "struct dieinfo"
127 structure is initialized.
129 Initialization is done in two levels. The first, done by basicdieinfo(),
130 just initializes those fields that are vital to deciding whether or not
131 to use this DIE, how to skip past it, etc. The second, done by the
132 function completedieinfo(), fills in the rest of the information.
134 Attributes which have block forms are not interpreted at the time
135 the DIE is scanned, instead we just save pointers to the start
136 of their value fields.
138 Some fields have a flag <name>_p that is set when the value of the
139 field is valid (I.E. we found a matching attribute in the DIE). Since
140 we may want to test for the presence of some attributes in the DIE,
141 such as AT_low_pc, without restricting the values of the field,
142 we need someway to note that we found such an attribute.
149 char * die
; /* Pointer to the raw DIE data */
150 long dielength
; /* Length of the raw DIE data */
151 DIEREF dieref
; /* Offset of this DIE */
152 short dietag
; /* Tag for this DIE */
157 unsigned short at_fund_type
;
158 BLOCK
* at_mod_fund_type
;
159 long at_user_def_type
;
160 BLOCK
* at_mod_u_d_type
;
162 BLOCK
* at_subscr_data
;
166 BLOCK
* at_element_list
;
173 BLOCK
* at_discr_value
;
176 BLOCK
* at_string_length
;
184 unsigned int has_at_low_pc
:1;
185 unsigned int has_at_stmt_list
:1;
186 unsigned int short_element_list
:1;
189 static int diecount
; /* Approximate count of dies for compilation unit */
190 static struct dieinfo
*curdie
; /* For warnings and such */
192 static char *dbbase
; /* Base pointer to dwarf info */
193 static int dbroff
; /* Relative offset from start of .debug section */
194 static char *lnbase
; /* Base pointer to line section */
195 static int isreg
; /* Kludge to identify register variables */
197 static CORE_ADDR baseaddr
; /* Add to each symbol value */
199 /* Each partial symbol table entry contains a pointer to private data for the
200 read_symtab() function to use when expanding a partial symbol table entry
201 to a full symbol table entry. For DWARF debugging info, this data is
202 contained in the following structure and macros are provided for easy
203 access to the members given a pointer to a partial symbol table entry.
205 dbfoff Always the absolute file offset to the start of the ".debug"
206 section for the file containing the DIE's being accessed.
208 dbroff Relative offset from the start of the ".debug" access to the
209 first DIE to be accessed. When building the partial symbol
210 table, this value will be zero since we are accessing the
211 entire ".debug" section. When expanding a partial symbol
212 table entry, this value will be the offset to the first
213 DIE for the compilation unit containing the symbol that
214 triggers the expansion.
216 dblength The size of the chunk of DIE's being examined, in bytes.
218 lnfoff The absolute file offset to the line table fragment. Ignored
219 when building partial symbol tables, but used when expanding
220 them, and contains the absolute file offset to the fragment
221 of the ".line" section containing the line numbers for the
222 current compilation unit.
226 int dbfoff
; /* Absolute file offset to start of .debug section */
227 int dbroff
; /* Relative offset from start of .debug section */
228 int dblength
; /* Size of the chunk of DIE's being examined */
229 int lnfoff
; /* Absolute file offset to line table fragment */
232 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
233 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
234 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
235 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
237 /* Record the symbols defined for each context in a linked list. We don't
238 create a struct block for the context until we know how long to make it.
239 Global symbols for each file are maintained in the global_symbols list. */
241 struct pending_symbol
{
242 struct pending_symbol
*next
; /* Next pending symbol */
243 struct symbol
*symbol
; /* The actual symbol */
246 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
247 static struct block
*global_symbol_block
;
249 /* Line number entries are read into a dynamically expandable vector before
250 being added to the symbol table section. Once we know how many there are
253 static struct linetable
*line_vector
; /* Vector of line numbers. */
254 static int line_vector_index
; /* Index of next entry. */
255 static int line_vector_length
; /* Current allocation limit */
257 /* Scope information is kept in a scope tree, one node per scope. Each time
258 a new scope is started, a child node is created under the current node
259 and set to the current scope. Each time a scope is closed, the current
260 scope moves back up the tree to the parent of the current scope.
262 Each scope contains a pointer to the list of symbols defined in the scope,
263 a pointer to the block vector for the scope, a pointer to the symbol
264 that names the scope (if any), and the range of PC values that mark
265 the start and end of the scope. */
268 struct scopenode
*parent
;
269 struct scopenode
*child
;
270 struct scopenode
*sibling
;
271 struct pending_symbol
*symbols
;
273 struct symbol
*namesym
;
278 static struct scopenode
*scopetree
;
279 static struct scopenode
*scope
;
281 /* DIES which have user defined types or modified user defined types refer to
282 other DIES for the type information. Thus we need to associate the offset
283 of a DIE for a user defined type with a pointer to the type information.
285 Originally this was done using a simple but expensive algorithm, with an
286 array of unsorted structures, each containing an offset/type-pointer pair.
287 This array was scanned linearly each time a lookup was done. The result
288 was that gdb was spending over half it's startup time munging through this
289 array of pointers looking for a structure that had the right offset member.
291 The second attempt used the same array of structures, but the array was
292 sorted using qsort each time a new offset/type was recorded, and a binary
293 search was used to find the type pointer for a given DIE offset. This was
294 even slower, due to the overhead of sorting the array each time a new
295 offset/type pair was entered.
297 The third attempt uses a fixed size array of type pointers, indexed by a
298 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
299 we can divide any DIE offset by 4 to obtain a unique index into this fixed
300 size array. Since each element is a 4 byte pointer, it takes exactly as
301 much memory to hold this array as to hold the DWARF info for a given
302 compilation unit. But it gets freed as soon as we are done with it. */
304 static struct type
**utypes
; /* Pointer to array of user type pointers */
305 static int numutypes
; /* Max number of user type pointers */
307 /* Forward declarations of static functions so we don't have to worry
308 about ordering within this file. The EXFUN macro may be slightly
309 misleading. Should probably be called DCLFUN instead, or something
310 more intuitive, since it can be used for both static and external
314 EXFUN (dwarfwarn
, (char *fmt DOTS
));
317 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
320 EXFUN (scan_compilation_units
,
321 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
322 AND
unsigned int dbfoff AND
unsigned int lnoffset
323 AND
struct objfile
*objfile
));
325 static struct partial_symtab
*
326 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
327 AND
char *filename AND CORE_ADDR textlow
328 AND CORE_ADDR texthigh AND
int dbfoff
329 AND
int curoff AND
int culength AND
int lnfoff
330 AND
struct partial_symbol
*global_syms
331 AND
struct partial_symbol
*static_syms
));
333 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
336 EXFUN(add_psymbol_to_list
,
337 (struct psymbol_allocation_list
*listp AND
char *name
338 AND
enum namespace space AND
enum address_class
class
339 AND CORE_ADDR value
));
342 EXFUN(init_psymbol_list
, (int total_symbols
));
345 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
348 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
351 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
354 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
356 static struct symtab
*
357 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
361 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
364 EXFUN(read_structure_scope
,
365 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
366 struct objfile
*objfile
));
369 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
372 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
375 EXFUN(read_array_type
, (struct dieinfo
*dip
));
378 EXFUN(read_subroutine_type
,
379 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
382 EXFUN(read_enumeration
,
383 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
387 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
388 struct objfile
*objfile
));
391 EXFUN(enum_type
, (struct dieinfo
*dip
));
394 EXFUN(start_symtab
, (void));
398 (char *filename AND
long language AND
struct objfile
*objfile
));
401 EXFUN(scopecount
, (struct scopenode
*node
));
405 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
408 EXFUN(freescope
, (struct scopenode
*node
));
410 static struct block
*
411 EXFUN(buildblock
, (struct pending_symbol
*syms
));
414 EXFUN(closescope
, (void));
417 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
420 EXFUN(decode_line_numbers
, (char *linetable
));
423 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
426 EXFUN(decode_mod_fund_type
, (char *typedata
));
429 EXFUN(decode_mod_u_d_type
, (char *typedata
));
432 EXFUN(decode_modified_type
,
433 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
436 EXFUN(decode_fund_type
, (unsigned short fundtype
));
439 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
442 EXFUN(add_symbol_to_list
,
443 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
445 static struct block
**
446 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
448 static struct blockvector
*
449 EXFUN(make_blockvector
, (void));
452 EXFUN(lookup_utype
, (DIEREF dieref
));
455 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
457 static struct symbol
*
458 EXFUN(new_symbol
, (struct dieinfo
*dip
));
461 EXFUN(locval
, (char *loc
));
464 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
465 enum misc_function_type
));
468 EXFUN(compare_psymbols
,
469 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
476 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
480 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
481 int mainline, unsigned int dbfoff, unsigned int dbsize,
482 unsigned int lnoffset, unsigned int lnsize,
483 struct objfile *objfile)
487 This function is called upon to build partial symtabs from files
488 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
490 It is passed a file descriptor for an open file containing the DIES
491 and line number information, the corresponding filename for that
492 file, a base address for relocating the symbols, a flag indicating
493 whether or not this debugging information is from a "main symbol
494 table" rather than a shared library or dynamically linked file,
495 and file offset/size pairs for the DIE information and line number
505 DEFUN(dwarf_build_psymtabs
,
506 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
512 unsigned int dbfoff AND
513 unsigned int dbsize AND
514 unsigned int lnoffset AND
515 unsigned int lnsize AND
516 struct objfile
*objfile
)
518 struct cleanup
*back_to
;
520 dbbase
= xmalloc (dbsize
);
522 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
523 (read (desc
, dbbase
, dbsize
) != dbsize
))
526 error ("can't read DWARF data from '%s'", filename
);
528 back_to
= make_cleanup (free
, dbbase
);
530 /* If we are reinitializing, or if we have never loaded syms yet, init.
531 Since we have no idea how many DIES we are looking at, we just guess
532 some arbitrary value. */
534 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
536 init_psymbol_list (1024);
539 /* Follow the compilation unit sibling chain, building a partial symbol
540 table entry for each one. Save enough information about each compilation
541 unit to locate the full DWARF information later. */
543 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
544 dbfoff
, lnoffset
, objfile
);
546 do_cleanups (back_to
);
554 record_misc_function -- add entry to miscellaneous function vector
558 static void record_misc_function (char *name, CORE_ADDR address,
559 enum misc_function_type mf_type)
563 Given a pointer to the name of a symbol that should be added to the
564 miscellaneous function vector, and the address associated with that
565 symbol, records this information for later use in building the
566 miscellaneous function vector.
571 DEFUN(record_misc_function
, (name
, address
, mf_type
),
572 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
574 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
582 dwarfwarn -- issue a DWARF related warning
586 Issue warnings about DWARF related things that aren't serious enough
587 to warrant aborting with an error, but should not be ignored either.
588 This includes things like detectable corruption in DIE's, missing
589 DIE's, unimplemented features, etc.
591 In general, running across tags or attributes that we don't recognize
592 is not considered to be a problem and we should not issue warnings
597 We mostly follow the example of the error() routine, but without
598 returning to command level. It is arguable about whether warnings
599 should be issued at all, and if so, where they should go (stdout or
602 We assume that curdie is valid and contains at least the basic
603 information for the DIE where the problem was noticed.
608 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
614 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
615 if (curdie
-> at_name
)
617 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
619 vfprintf (stderr
, fmt
, ap
);
620 fprintf (stderr
, "\n");
634 fmt
= va_arg (ap
, char *);
636 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
637 if (curdie
-> at_name
)
639 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
641 vfprintf (stderr
, fmt
, ap
);
642 fprintf (stderr
, "\n");
651 compare_psymbols -- compare two partial symbols by name
655 Given pointer to two partial symbol table entries, compare
656 them by name and return -N, 0, or +N (ala strcmp). Typically
657 used by sorting routines like qsort().
661 This is a copy from dbxread.c. It should be moved to a generic
662 gdb file and made available for all psymtab builders (FIXME).
664 Does direct compare of first two characters before punting
665 and passing to strcmp for longer compares. Note that the
666 original version had a bug whereby two null strings or two
667 identically named one character strings would return the
668 comparison of memory following the null byte.
673 DEFUN(compare_psymbols
, (s1
, s2
),
674 struct partial_symbol
*s1 AND
675 struct partial_symbol
*s2
)
677 register char *st1
= SYMBOL_NAME (s1
);
678 register char *st2
= SYMBOL_NAME (s2
);
680 if ((st1
[0] - st2
[0]) || !st1
[0])
682 return (st1
[0] - st2
[0]);
684 else if ((st1
[1] - st2
[1]) || !st1
[1])
686 return (st1
[1] - st2
[1]);
690 return (strcmp (st1
+ 2, st2
+ 2));
698 read_lexical_block_scope -- process all dies in a lexical block
702 static void read_lexical_block_scope (struct dieinfo *dip,
703 char *thisdie, char *enddie)
707 Process all the DIES contained within a lexical block scope.
708 Start a new scope, process the dies, and then close the scope.
713 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
714 struct dieinfo
*dip AND
717 struct objfile
*objfile
)
719 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
720 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
728 lookup_utype -- look up a user defined type from die reference
732 static type *lookup_utype (DIEREF dieref)
736 Given a DIE reference, lookup the user defined type associated with
737 that DIE, if it has been registered already. If not registered, then
738 return NULL. Alloc_utype() can be called to register an empty
739 type for this reference, which will be filled in later when the
740 actual referenced DIE is processed.
744 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
746 struct type
*type
= NULL
;
749 utypeidx
= (dieref
- dbroff
) / 4;
750 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
752 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
756 type
= *(utypes
+ utypeidx
);
766 alloc_utype -- add a user defined type for die reference
770 static type *alloc_utype (DIEREF dieref, struct type *utypep)
774 Given a die reference DIEREF, and a possible pointer to a user
775 defined type UTYPEP, register that this reference has a user
776 defined type and either use the specified type in UTYPEP or
777 make a new empty type that will be filled in later.
779 We should only be called after calling lookup_utype() to verify that
780 there is not currently a type registered for DIEREF.
784 DEFUN(alloc_utype
, (dieref
, utypep
),
791 utypeidx
= (dieref
- dbroff
) / 4;
792 typep
= utypes
+ utypeidx
;
793 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
795 utypep
= builtin_type_int
;
796 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
798 else if (*typep
!= NULL
)
801 SQUAWK (("internal error: dup user type allocation"));
807 utypep
= (struct type
*)
808 obstack_alloc (symbol_obstack
, sizeof (struct type
));
809 (void) memset (utypep
, 0, sizeof (struct type
));
820 decode_die_type -- return a type for a specified die
824 static struct type *decode_die_type (struct dieinfo *dip)
828 Given a pointer to a die information structure DIP, decode the
829 type of the die and return a pointer to the decoded type. All
830 dies without specific types default to type int.
834 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
836 struct type
*type
= NULL
;
838 if (dip
-> at_fund_type
!= 0)
840 type
= decode_fund_type (dip
-> at_fund_type
);
842 else if (dip
-> at_mod_fund_type
!= NULL
)
844 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
846 else if (dip
-> at_user_def_type
)
848 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
850 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
853 else if (dip
-> at_mod_u_d_type
)
855 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
859 type
= builtin_type_int
;
868 struct_type -- compute and return the type for a struct or union
872 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
873 char *enddie, struct objfile *objfile)
877 Given pointer to a die information structure for a die which
878 defines a union or structure (and MUST define one or the other),
879 and pointers to the raw die data that define the range of dies which
880 define the members, compute and return the user defined type for the
885 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
886 struct dieinfo
*dip AND
889 struct objfile
*objfile
)
893 struct nextfield
*next
;
896 struct nextfield
*list
= NULL
;
897 struct nextfield
*new;
904 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
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 anonymous
930 enums, structures, and unions, like "~0fake" or ".0fake". Thanks, but
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. */
980 TYPE_NFIELDS (type
) = nfields
;
981 TYPE_FIELDS (type
) = (struct field
*)
982 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
983 /* Copy the saved-up fields into the field vector. */
984 for (n
= nfields
; list
; list
= list
-> next
)
986 TYPE_FIELD (type
, --n
) = list
-> field
;
995 read_structure_scope -- process all dies within struct or union
999 static void read_structure_scope (struct dieinfo *dip,
1000 char *thisdie, char *enddie, struct objfile *objfile)
1004 Called when we find the DIE that starts a structure or union
1005 scope (definition) to process all dies that define the members
1006 of the structure or union. DIP is a pointer to the die info
1007 struct for the DIE that names the structure or union.
1011 Note that we need to call struct_type regardless of whether or not
1012 we have a symbol, since we might have a structure or union without
1013 a tag name (thus no symbol for the tagname).
1017 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
1018 struct dieinfo
*dip AND
1021 struct objfile
*objfile
)
1026 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1027 if ((sym
= new_symbol (dip
)) != NULL
)
1029 SYMBOL_TYPE (sym
) = type
;
1037 decode_array_element_type -- decode type of the array elements
1041 static struct type *decode_array_element_type (char *scan, char *end)
1045 As the last step in decoding the array subscript information for an
1046 array DIE, we need to decode the type of the array elements. We are
1047 passed a pointer to this last part of the subscript information and
1048 must return the appropriate type. If the type attribute is not
1049 recognized, just warn about the problem and return type int.
1052 static struct type
*
1053 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1058 unsigned short fundtype
;
1060 (void) memcpy (&attribute
, scan
, sizeof (short));
1061 scan
+= sizeof (short);
1065 (void) memcpy (&fundtype
, scan
, sizeof (short));
1066 typep
= decode_fund_type (fundtype
);
1068 case AT_mod_fund_type
:
1069 typep
= decode_mod_fund_type (scan
);
1071 case AT_user_def_type
:
1072 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1073 if ((typep
= lookup_utype (dieref
)) == NULL
)
1075 typep
= alloc_utype (dieref
, NULL
);
1078 case AT_mod_u_d_type
:
1079 typep
= decode_mod_u_d_type (scan
);
1082 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1083 typep
= builtin_type_int
;
1093 decode_subscr_data -- decode array subscript and element type data
1097 static struct type *decode_subscr_data (char *scan, char *end)
1101 The array subscripts and the data type of the elements of an
1102 array are described by a list of data items, stored as a block
1103 of contiguous bytes. There is a data item describing each array
1104 dimension, and a final data item describing the element type.
1105 The data items are ordered the same as their appearance in the
1106 source (I.E. leftmost dimension first, next to leftmost second,
1109 We are passed a pointer to the start of the block of bytes
1110 containing the data items, and a pointer to the first byte past
1111 the data. This function decodes the data and returns a type.
1114 FIXME: This code only implements the forms currently used
1115 by the AT&T and GNU C compilers.
1117 The end pointer is supplied for error checking, maybe we should
1121 static struct type
*
1122 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1124 struct type
*typep
= NULL
;
1125 struct type
*nexttype
;
1135 typep
= decode_array_element_type (scan
, end
);
1138 (void) memcpy (&fundtype
, scan
, sizeof (short));
1139 scan
+= sizeof (short);
1140 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1141 && fundtype
!= FT_unsigned_integer
)
1143 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1148 (void) memcpy (&lowbound
, scan
, sizeof (long));
1149 scan
+= sizeof (long);
1150 (void) memcpy (&highbound
, scan
, sizeof (long));
1151 scan
+= sizeof (long);
1152 nexttype
= decode_subscr_data (scan
, end
);
1153 if (nexttype
!= NULL
)
1155 typep
= (struct type
*)
1156 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1157 (void) memset (typep
, 0, sizeof (struct type
));
1158 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1159 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1160 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1161 TYPE_TARGET_TYPE (typep
) = nexttype
;
1172 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1175 SQUAWK (("unknown array subscript format %x", format
));
1185 read_array_type -- read TAG_array_type DIE
1189 static void read_array_type (struct dieinfo *dip)
1193 Extract all information from a TAG_array_type DIE and add to
1194 the user defined type vector.
1198 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1205 if (dip
-> at_ordering
!= ORD_row_major
)
1207 /* FIXME: Can gdb even handle column major arrays? */
1208 SQUAWK (("array not row major; not handled correctly"));
1210 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1212 (void) memcpy (&temp
, sub
, sizeof (short));
1213 subend
= sub
+ sizeof (short) + temp
;
1214 sub
+= sizeof (short);
1215 type
= decode_subscr_data (sub
, subend
);
1218 type
= alloc_utype (dip
-> dieref
, NULL
);
1219 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1220 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1221 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1225 type
= alloc_utype (dip
-> dieref
, type
);
1234 read_subroutine_type -- process TAG_subroutine_type dies
1238 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1243 Handle DIES due to C code like:
1246 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1252 The parameter DIES are currently ignored. See if gdb has a way to
1253 include this info in it's type system, and decode them if so. Is
1254 this what the type structure's "arg_types" field is for? (FIXME)
1258 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1259 struct dieinfo
*dip AND
1265 type
= decode_die_type (dip
);
1266 type
= lookup_function_type (type
);
1267 type
= alloc_utype (dip
-> dieref
, type
);
1274 read_enumeration -- process dies which define an enumeration
1278 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1283 Given a pointer to a die which begins an enumeration, process all
1284 the dies that define the members of the enumeration.
1288 Note that we need to call enum_type regardless of whether or not we
1289 have a symbol, since we might have an enum without a tag name (thus
1290 no symbol for the tagname).
1294 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1295 struct dieinfo
*dip AND
1302 type
= enum_type (dip
);
1303 if ((sym
= new_symbol (dip
)) != NULL
)
1305 SYMBOL_TYPE (sym
) = type
;
1313 enum_type -- decode and return a type for an enumeration
1317 static type *enum_type (struct dieinfo *dip)
1321 Given a pointer to a die information structure for the die which
1322 starts an enumeration, process all the dies that define the members
1323 of the enumeration and return a type pointer for the enumeration.
1325 At the same time, for each member of the enumeration, create a
1326 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1327 and give it the type of the enumeration itself.
1331 Note that the DWARF specification explicitly mandates that enum
1332 constants occur in reverse order from the source program order,
1333 for "consistency" and because this ordering is easier for many
1334 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1335 Entries). Because gdb wants to see the enum members in program
1336 source order, we have to ensure that the order gets reversed while
1337 we are processing them.
1340 static struct type
*
1341 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1345 struct nextfield
*next
;
1348 struct nextfield
*list
= NULL
;
1349 struct nextfield
*new;
1358 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1360 type
= alloc_utype (dip
-> dieref
, NULL
);
1362 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1363 /* Some compilers try to be helpful by inventing "fake" names for anonymous
1364 enums, structures, and unions, like "~0fake" or ".0fake". Thanks, but
1366 if (dip
-> at_name
!= NULL
1367 && *dip
-> at_name
!= '~'
1368 && *dip
-> at_name
!= '.')
1370 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1372 if (dip
-> at_byte_size
!= 0)
1374 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1376 if ((scan
= dip
-> at_element_list
) != NULL
)
1378 if (dip
-> short_element_list
)
1380 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1381 listend
= scan
+ stemp
+ sizeof (stemp
);
1382 scan
+= sizeof (stemp
);
1386 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1387 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1388 scan
+= sizeof (ltemp
);
1390 while (scan
< listend
)
1392 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1395 list
-> field
.type
= NULL
;
1396 list
-> field
.bitsize
= 0;
1397 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1398 scan
+= sizeof (long);
1399 list
-> field
.name
= savestring (scan
, strlen (scan
));
1400 scan
+= strlen (scan
) + 1;
1402 /* Handcraft a new symbol for this enum member. */
1403 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1404 sizeof (struct symbol
));
1405 (void) memset (sym
, 0, sizeof (struct symbol
));
1406 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, symbol_obstack
);
1407 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1408 SYMBOL_CLASS (sym
) = LOC_CONST
;
1409 SYMBOL_TYPE (sym
) = type
;
1410 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1411 add_symbol_to_list (sym
, &scope
-> symbols
);
1414 /* Now create the vector of fields, and record how big it is. This is where
1415 we reverse the order, by pulling the members of the list in reverse order
1416 from how they were inserted. */
1417 TYPE_NFIELDS (type
) = nfields
;
1418 TYPE_FIELDS (type
) = (struct field
*)
1419 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1420 /* Copy the saved-up fields into the field vector. */
1421 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1423 TYPE_FIELD (type
, n
++) = list
-> field
;
1432 read_func_scope -- process all dies within a function scope
1436 Process all dies within a given function scope. We are passed
1437 a die information structure pointer DIP for the die which
1438 starts the function scope, and pointers into the raw die data
1439 that define the dies within the function scope.
1441 For now, we ignore lexical block scopes within the function.
1442 The problem is that AT&T cc does not define a DWARF lexical
1443 block scope for the function itself, while gcc defines a
1444 lexical block scope for the function. We need to think about
1445 how to handle this difference, or if it is even a problem.
1450 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1451 struct dieinfo
*dip AND
1454 struct objfile
*objfile
)
1458 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1460 entry_scope_lowpc
= dip
-> at_low_pc
;
1461 entry_scope_highpc
= dip
-> at_high_pc
;
1463 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1465 main_scope_lowpc
= dip
-> at_low_pc
;
1466 main_scope_highpc
= dip
-> at_high_pc
;
1468 sym
= new_symbol (dip
);
1469 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1470 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1478 read_file_scope -- process all dies within a file scope
1482 Process all dies within a given file scope. We are passed a
1483 pointer to the die information structure for the die which
1484 starts the file scope, and pointers into the raw die data which
1485 mark the range of dies within the file scope.
1487 When the partial symbol table is built, the file offset for the line
1488 number table for each compilation unit is saved in the partial symbol
1489 table entry for that compilation unit. As the symbols for each
1490 compilation unit are read, the line number table is read into memory
1491 and the variable lnbase is set to point to it. Thus all we have to
1492 do is use lnbase to access the line number table for the current
1497 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1498 struct dieinfo
*dip AND
1501 struct objfile
*objfile
)
1503 struct cleanup
*back_to
;
1505 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1507 startup_file_start
= dip
-> at_low_pc
;
1508 startup_file_end
= dip
-> at_high_pc
;
1510 numutypes
= (enddie
- thisdie
) / 4;
1511 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1512 back_to
= make_cleanup (free
, utypes
);
1513 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1515 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1516 decode_line_numbers (lnbase
);
1517 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1519 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1520 do_cleanups (back_to
);
1529 start_symtab -- do initialization for starting new symbol table
1533 static void start_symtab (void)
1537 Called whenever we are starting to process dies for a new
1538 compilation unit, to perform initializations. Right now
1539 the only thing we really have to do is initialize storage
1540 space for the line number vector.
1545 DEFUN_VOID (start_symtab
)
1549 line_vector_index
= 0;
1550 line_vector_length
= 1000;
1551 nbytes
= sizeof (struct linetable
);
1552 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1553 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1560 process_dies -- process a range of DWARF Information Entries
1564 static void process_dies (char *thisdie, char *enddie,
1565 struct objfile *objfile)
1569 Process all DIE's in a specified range. May be (and almost
1570 certainly will be) called recursively.
1574 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1575 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1580 while (thisdie
< enddie
)
1582 basicdieinfo (&di
, thisdie
);
1583 if (di
.dielength
< sizeof (long))
1587 else if (di
.dietag
== TAG_padding
)
1589 nextdie
= thisdie
+ di
.dielength
;
1593 completedieinfo (&di
);
1594 if (di
.at_sibling
!= 0)
1596 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1600 nextdie
= thisdie
+ di
.dielength
;
1604 case TAG_compile_unit
:
1605 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1607 case TAG_global_subroutine
:
1608 case TAG_subroutine
:
1609 if (di
.has_at_low_pc
)
1611 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1614 case TAG_lexical_block
:
1615 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1617 case TAG_structure_type
:
1618 case TAG_union_type
:
1619 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1621 case TAG_enumeration_type
:
1622 read_enumeration (&di
, thisdie
, nextdie
);
1624 case TAG_subroutine_type
:
1625 read_subroutine_type (&di
, thisdie
, nextdie
);
1627 case TAG_array_type
:
1628 read_array_type (&di
);
1631 (void) new_symbol (&di
);
1643 end_symtab -- finish processing for a compilation unit
1647 static void end_symtab (char *filename, long language)
1651 Complete the symbol table entry for the current compilation
1652 unit. Make the struct symtab and put it on the list of all
1658 DEFUN(end_symtab
, (filename
, language
, objfile
),
1659 char *filename AND
long language AND
struct objfile
*objfile
)
1661 struct symtab
*symtab
;
1662 struct blockvector
*blockvector
;
1665 /* Ignore a file that has no functions with real debugging info. */
1666 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1670 line_vector_length
= -1;
1671 freescope (scopetree
);
1672 scope
= scopetree
= NULL
;
1675 /* Create the blockvector that points to all the file's blocks. */
1677 blockvector
= make_blockvector ();
1679 /* Now create the symtab object for this source file. */
1681 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1684 symtab
-> free_ptr
= 0;
1686 /* Fill in its components. */
1687 symtab
-> blockvector
= blockvector
;
1688 symtab
-> free_code
= free_linetable
;
1690 /* Save the line number information. */
1692 line_vector
-> nitems
= line_vector_index
;
1693 nbytes
= sizeof (struct linetable
);
1694 if (line_vector_index
> 1)
1696 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1698 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1700 /* FIXME: The following may need to be expanded for other languages */
1705 symtab
-> language
= language_c
;
1707 case LANG_C_PLUS_PLUS
:
1708 symtab
-> language
= language_cplus
;
1714 /* Link the new symtab into the list of such. */
1715 symtab
-> next
= symtab_list
;
1716 symtab_list
= symtab
;
1718 /* Recursively free the scope tree */
1719 freescope (scopetree
);
1720 scope
= scopetree
= NULL
;
1722 /* Reinitialize for beginning of new file. */
1724 line_vector_length
= -1;
1731 scopecount -- count the number of enclosed scopes
1735 static int scopecount (struct scopenode *node)
1739 Given pointer to a node, compute the size of the subtree which is
1740 rooted in this node, which also happens to be the number of scopes
1745 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1751 count
+= scopecount (node
-> child
);
1752 count
+= scopecount (node
-> sibling
);
1762 openscope -- start a new lexical block scope
1766 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1771 Start a new scope by allocating a new scopenode, adding it as the
1772 next child of the current scope (if any) or as the root of the
1773 scope tree, and then making the new node the current scope node.
1777 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1778 struct symbol
*namesym AND
1782 struct scopenode
*new;
1783 struct scopenode
*child
;
1785 new = (struct scopenode
*) xmalloc (sizeof (*new));
1786 (void) memset (new, 0, sizeof (*new));
1787 new -> namesym
= namesym
;
1788 new -> lowpc
= lowpc
;
1789 new -> highpc
= highpc
;
1794 else if ((child
= scope
-> child
) == NULL
)
1796 scope
-> child
= new;
1797 new -> parent
= scope
;
1801 while (child
-> sibling
!= NULL
)
1803 child
= child
-> sibling
;
1805 child
-> sibling
= new;
1806 new -> parent
= scope
;
1815 freescope -- free a scope tree rooted at the given node
1819 static void freescope (struct scopenode *node)
1823 Given a pointer to a node in the scope tree, free the subtree
1824 rooted at that node. First free all the children and sibling
1825 nodes, and then the node itself. Used primarily for cleaning
1826 up after ourselves and returning memory to the system.
1830 DEFUN(freescope
, (node
), struct scopenode
*node
)
1834 freescope (node
-> child
);
1835 freescope (node
-> sibling
);
1844 buildblock -- build a new block from pending symbols list
1848 static struct block *buildblock (struct pending_symbol *syms)
1852 Given a pointer to a list of symbols, build a new block and free
1853 the symbol list structure. Also check each symbol to see if it
1854 is the special symbol that flags that this block was compiled by
1855 gcc, and if so, mark the block appropriately.
1858 static struct block
*
1859 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1861 struct pending_symbol
*next
, *next1
;
1863 struct block
*newblock
;
1866 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1868 /* Allocate a new block */
1870 nbytes
= sizeof (struct block
);
1873 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1875 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1876 (void) memset (newblock
, 0, nbytes
);
1878 /* Copy the symbols into the block. */
1880 BLOCK_NSYMS (newblock
) = i
;
1881 for (next
= syms
; next
; next
= next
-> next
)
1883 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1884 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1885 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1887 BLOCK_GCC_COMPILED (newblock
) = 1;
1891 /* Now free the links of the list, and empty the list. */
1893 for (next
= syms
; next
; next
= next1
)
1895 next1
= next
-> next
;
1906 closescope -- close a lexical block scope
1910 static void closescope (void)
1914 Close the current lexical block scope. Closing the current scope
1915 is as simple as moving the current scope pointer up to the parent
1916 of the current scope pointer. But we also take this opportunity
1917 to build the block for the current scope first, since we now have
1918 all of it's symbols.
1922 DEFUN_VOID(closescope
)
1924 struct scopenode
*child
;
1928 error ("DWARF parse error, too many close scopes");
1932 if (scope
-> parent
== NULL
)
1934 global_symbol_block
= buildblock (global_symbols
);
1935 global_symbols
= NULL
;
1936 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1937 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1939 scope
-> block
= buildblock (scope
-> symbols
);
1940 scope
-> symbols
= NULL
;
1941 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1942 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1944 /* Put the local block in as the value of the symbol that names it. */
1946 if (scope
-> namesym
)
1948 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1949 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1952 /* Install this scope's local block as the superblock of all child
1955 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1957 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1960 scope
= scope
-> parent
;
1968 record_line -- record a line number entry in the line vector
1972 static void record_line (int line, CORE_ADDR pc)
1976 Given a line number and the corresponding pc value, record
1977 this pair in the line number vector, expanding the vector as
1982 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1984 struct linetable_entry
*e
;
1987 /* Make sure line vector is big enough. */
1989 if (line_vector_index
+ 2 >= line_vector_length
)
1991 line_vector_length
*= 2;
1992 nbytes
= sizeof (struct linetable
);
1993 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1994 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1996 e
= line_vector
-> item
+ line_vector_index
++;
2005 decode_line_numbers -- decode a line number table fragment
2009 static void decode_line_numbers (char *tblscan, char *tblend,
2010 long length, long base, long line, long pc)
2014 Translate the DWARF line number information to gdb form.
2016 The ".line" section contains one or more line number tables, one for
2017 each ".line" section from the objects that were linked.
2019 The AT_stmt_list attribute for each TAG_source_file entry in the
2020 ".debug" section contains the offset into the ".line" section for the
2021 start of the table for that file.
2023 The table itself has the following structure:
2025 <table length><base address><source statement entry>
2026 4 bytes 4 bytes 10 bytes
2028 The table length is the total size of the table, including the 4 bytes
2029 for the length information.
2031 The base address is the address of the first instruction generated
2032 for the source file.
2034 Each source statement entry has the following structure:
2036 <line number><statement position><address delta>
2037 4 bytes 2 bytes 4 bytes
2039 The line number is relative to the start of the file, starting with
2042 The statement position either -1 (0xFFFF) or the number of characters
2043 from the beginning of the line to the beginning of the statement.
2045 The address delta is the difference between the base address and
2046 the address of the first instruction for the statement.
2048 Note that we must copy the bytes from the packed table to our local
2049 variables before attempting to use them, to avoid alignment problems
2050 on some machines, particularly RISC processors.
2054 Does gdb expect the line numbers to be sorted? They are now by
2055 chance/luck, but are not required to be. (FIXME)
2057 The line with number 0 is unused, gdb apparently can discover the
2058 span of the last line some other way. How? (FIXME)
2062 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2071 if (linetable
!= NULL
)
2073 tblscan
= tblend
= linetable
;
2074 (void) memcpy (&length
, tblscan
, sizeof (long));
2075 tblscan
+= sizeof (long);
2077 (void) memcpy (&base
, tblscan
, sizeof (long));
2079 tblscan
+= sizeof (long);
2080 while (tblscan
< tblend
)
2082 (void) memcpy (&line
, tblscan
, sizeof (long));
2083 tblscan
+= sizeof (long) + sizeof (short);
2084 (void) memcpy (&pc
, tblscan
, sizeof (long));
2085 tblscan
+= sizeof (long);
2089 record_line (line
, pc
);
2099 add_symbol_to_list -- add a symbol to head of current symbol list
2103 static void add_symbol_to_list (struct symbol *symbol, struct
2104 pending_symbol **listhead)
2108 Given a pointer to a symbol and a pointer to a pointer to a
2109 list of symbols, add this symbol as the current head of the
2110 list. Typically used for example to add a symbol to the
2111 symbol list for the current scope.
2116 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2117 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2119 struct pending_symbol
*link
;
2123 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2124 link
-> next
= *listhead
;
2125 link
-> symbol
= symbol
;
2134 gatherblocks -- walk a scope tree and build block vectors
2138 static struct block **gatherblocks (struct block **dest,
2139 struct scopenode *node)
2143 Recursively walk a scope tree rooted in the given node, adding blocks
2144 to the array pointed to by DEST, in preorder. I.E., first we add the
2145 block for the current scope, then all the blocks for child scopes,
2146 and finally all the blocks for sibling scopes.
2149 static struct block
**
2150 DEFUN(gatherblocks
, (dest
, node
),
2151 struct block
**dest AND
struct scopenode
*node
)
2155 *dest
++ = node
-> block
;
2156 dest
= gatherblocks (dest
, node
-> child
);
2157 dest
= gatherblocks (dest
, node
-> sibling
);
2166 make_blockvector -- make a block vector from current scope tree
2170 static struct blockvector *make_blockvector (void)
2174 Make a blockvector from all the blocks in the current scope tree.
2175 The first block is always the global symbol block, followed by the
2176 block for the root of the scope tree which is the local symbol block,
2177 followed by all the remaining blocks in the scope tree, which are all
2182 Note that since the root node of the scope tree is created at the time
2183 each file scope is entered, there are always at least two blocks,
2184 neither of which may have any symbols, but always contribute a block
2185 to the block vector. So the test for number of blocks greater than 1
2186 below is unnecessary given bug free code.
2188 The resulting block structure varies slightly from that produced
2189 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2190 with dbxread.c, block 1 is a child of block 0. This does not
2191 seem to cause any problems, but probably should be fixed. (FIXME)
2194 static struct blockvector
*
2195 DEFUN_VOID(make_blockvector
)
2197 struct blockvector
*blockvector
= NULL
;
2201 /* Recursively walk down the tree, counting the number of blocks.
2202 Then add one to account for the global's symbol block */
2204 i
= scopecount (scopetree
) + 1;
2205 nbytes
= sizeof (struct blockvector
);
2208 nbytes
+= (i
- 1) * sizeof (struct block
*);
2210 blockvector
= (struct blockvector
*)
2211 obstack_alloc (symbol_obstack
, nbytes
);
2213 /* Copy the blocks into the blockvector. */
2215 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2216 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2217 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2219 return (blockvector
);
2226 locval -- compute the value of a location attribute
2230 static int locval (char *loc)
2234 Given pointer to a string of bytes that define a location, compute
2235 the location and return the value.
2237 When computing values involving the current value of the frame pointer,
2238 the value zero is used, which results in a value relative to the frame
2239 pointer, rather than the absolute value. This is what GDB wants
2242 When the result is a register number, the global isreg flag is set,
2243 otherwise it is cleared. This is a kludge until we figure out a better
2244 way to handle the problem. Gdb's design does not mesh well with the
2245 DWARF notion of a location computing interpreter, which is a shame
2246 because the flexibility goes unused.
2250 Note that stack[0] is unused except as a default error return.
2251 Note that stack overflow is not yet handled.
2255 DEFUN(locval
, (loc
), char *loc
)
2257 unsigned short nbytes
;
2263 (void) memcpy (&nbytes
, loc
, sizeof (short));
2264 end
= loc
+ sizeof (short) + nbytes
;
2268 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2276 /* push register (number) */
2277 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2281 /* push value of register (number) */
2282 /* Actually, we compute the value as if register has 0 */
2283 (void) memcpy (®no
, loc
, sizeof (long));
2286 stack
[++stacki
] = 0;
2290 stack
[++stacki
] = 0;
2291 SQUAWK (("BASEREG %d not handled!", regno
));
2295 /* push address (relocated address) */
2296 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2299 /* push constant (number) */
2300 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2303 /* pop, deref and push 2 bytes (as a long) */
2304 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2306 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2307 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2309 case OP_ADD
: /* pop top 2 items, add, push result */
2310 stack
[stacki
- 1] += stack
[stacki
];
2315 return (stack
[stacki
]);
2322 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2326 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2330 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2333 static struct symtab
*
2334 DEFUN(read_ofile_symtab
, (pst
),
2335 struct partial_symtab
*pst
)
2337 struct cleanup
*back_to
;
2340 bfd
*abfd
= pst
->objfile
->obfd
;
2342 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2343 unit, seek to the location in the file, and read in all the DIE's. */
2346 dbbase
= xmalloc (DBLENGTH(pst
));
2347 dbroff
= DBROFF(pst
);
2348 foffset
= DBFOFF(pst
) + dbroff
;
2349 if (bfd_seek (abfd
, foffset
, 0) ||
2350 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2353 error ("can't read DWARF data");
2355 back_to
= make_cleanup (free
, dbbase
);
2357 /* If there is a line number table associated with this compilation unit
2358 then read the first long word from the line number table fragment, which
2359 contains the size of the fragment in bytes (including the long word
2360 itself). Allocate a buffer for the fragment and read it in for future
2366 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2367 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2369 error ("can't read DWARF line number table size");
2371 lnbase
= xmalloc (lnsize
);
2372 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2373 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2376 error ("can't read DWARF line numbers");
2378 make_cleanup (free
, lnbase
);
2381 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2382 do_cleanups (back_to
);
2383 return (symtab_list
);
2390 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2394 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2398 Called once for each partial symbol table entry that needs to be
2399 expanded into a full symbol table entry.
2404 DEFUN(psymtab_to_symtab_1
,
2406 struct partial_symtab
*pst
)
2416 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2421 /* Read in all partial symtabs on which this one is dependent */
2422 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2423 if (!pst
-> dependencies
[i
] -> readin
)
2425 /* Inform about additional files that need to be read in. */
2428 fputs_filtered (" ", stdout
);
2430 fputs_filtered ("and ", stdout
);
2432 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2433 wrap_here (""); /* Flush output */
2436 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2439 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2441 /* Init stuff necessary for reading in symbols */
2442 pst
-> symtab
= read_ofile_symtab (pst
);
2445 printf_filtered ("%d DIE's, sorting...", diecount
);
2448 sort_symtab_syms (pst
-> symtab
);
2457 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2461 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2465 This is the DWARF support entry point for building a full symbol
2466 table entry from a partial symbol table entry. We are passed a
2467 pointer to the partial symbol table entry that needs to be expanded.
2472 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2481 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2486 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2488 /* Print the message now, before starting serious work, to avoid
2489 disconcerting pauses. */
2492 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2496 psymtab_to_symtab_1 (pst
);
2498 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2499 we need to do an equivalent or is this something peculiar to
2500 stabs/a.out format. */
2501 /* Match with global symbols. This only needs to be done once,
2502 after all of the symtabs and dependencies have been read in. */
2503 scan_file_globals ();
2506 /* Finish up the debug error message. */
2509 printf_filtered ("done.\n");
2518 init_psymbol_list -- initialize storage for partial symbols
2522 static void init_psymbol_list (int total_symbols)
2526 Initializes storage for all of the partial symbols that will be
2527 created by dwarf_build_psymtabs and subsidiaries.
2531 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2533 /* Free any previously allocated psymbol lists. */
2535 if (global_psymbols
.list
)
2537 free (global_psymbols
.list
);
2539 if (static_psymbols
.list
)
2541 free (static_psymbols
.list
);
2544 /* Current best guess is that there are approximately a twentieth
2545 of the total symbols (in a debugging file) are global or static
2548 global_psymbols
.size
= total_symbols
/ 10;
2549 static_psymbols
.size
= total_symbols
/ 10;
2550 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2551 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2552 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2553 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2560 start_psymtab -- allocate and partially fill a partial symtab entry
2564 Allocate and partially fill a partial symtab. It will be completely
2565 filled at the end of the symbol list.
2567 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2568 ADDR is the address relative to which its symbols are (incremental)
2569 or 0 (normal). FILENAME is the name of the compilation unit that
2570 these symbols were defined in, and they appear starting a address
2571 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2572 the full symbols can be read for compilation unit FILENAME.
2573 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2578 static struct partial_symtab
*
2579 DEFUN(start_psymtab
,
2580 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2581 culength
, lnfoff
, global_syms
, static_syms
),
2582 struct objfile
*objfile AND
2585 CORE_ADDR textlow AND
2586 CORE_ADDR texthigh AND
2591 struct partial_symbol
*global_syms AND
2592 struct partial_symbol
*static_syms
)
2594 struct partial_symtab
*result
;
2596 result
= (struct partial_symtab
*)
2597 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2598 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2599 result
-> addr
= addr
;
2600 result
-> objfile
= objfile
;
2601 result
-> filename
= create_name (filename
, psymbol_obstack
);
2602 result
-> textlow
= textlow
;
2603 result
-> texthigh
= texthigh
;
2604 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2605 sizeof (struct dwfinfo
));
2606 DBFOFF (result
) = dbfoff
;
2607 DBROFF (result
) = curoff
;
2608 DBLENGTH (result
) = culength
;
2609 LNFOFF (result
) = lnfoff
;
2610 result
-> readin
= 0;
2611 result
-> symtab
= NULL
;
2612 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2613 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2614 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2616 result
->n_global_syms
= 0;
2617 result
->n_static_syms
= 0;
2626 add_psymbol_to_list -- add a partial symbol to given list
2630 Add a partial symbol to one of the partial symbol vectors (pointed to
2631 by listp). The vector is grown as necessary.
2636 DEFUN(add_psymbol_to_list
,
2637 (listp
, name
, space
, class, value
),
2638 struct psymbol_allocation_list
*listp AND
2640 enum namespace space AND
2641 enum address_class
class AND
2644 struct partial_symbol
*psym
;
2647 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2649 newsize
= listp
-> size
* 2;
2650 listp
-> list
= (struct partial_symbol
*)
2651 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2652 /* Next assumes we only went one over. Should be good if program works
2654 listp
-> next
= listp
-> list
+ listp
-> size
;
2655 listp
-> size
= newsize
;
2657 psym
= listp
-> next
++;
2658 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2659 SYMBOL_NAMESPACE (psym
) = space
;
2660 SYMBOL_CLASS (psym
) = class;
2661 SYMBOL_VALUE (psym
) = value
;
2668 add_enum_psymbol -- add enumeration members to partial symbol table
2672 Given pointer to a DIE that is known to be for an enumeration,
2673 extract the symbolic names of the enumeration members and add
2674 partial symbols for them.
2678 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2685 if ((scan
= dip
-> at_element_list
) != NULL
)
2687 if (dip
-> short_element_list
)
2689 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2690 listend
= scan
+ stemp
+ sizeof (stemp
);
2691 scan
+= sizeof (stemp
);
2695 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2696 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2697 scan
+= sizeof (ltemp
);
2699 while (scan
< listend
)
2701 scan
+= sizeof (long);
2702 add_psymbol_to_list (&static_psymbols
, scan
, VAR_NAMESPACE
,
2704 scan
+= strlen (scan
) + 1;
2713 add_partial_symbol -- add symbol to partial symbol table
2717 Given a DIE, if it is one of the types that we want to
2718 add to a partial symbol table, finish filling in the die info
2719 and then add a partial symbol table entry for it.
2724 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2726 switch (dip
-> dietag
)
2728 case TAG_global_subroutine
:
2729 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2730 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2731 LOC_BLOCK
, dip
-> at_low_pc
);
2733 case TAG_global_variable
:
2734 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2736 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2739 case TAG_subroutine
:
2740 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2741 LOC_BLOCK
, dip
-> at_low_pc
);
2743 case TAG_local_variable
:
2744 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2748 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2751 case TAG_structure_type
:
2752 case TAG_union_type
:
2753 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2756 case TAG_enumeration_type
:
2759 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
,
2760 STRUCT_NAMESPACE
, LOC_TYPEDEF
, 0);
2762 add_enum_psymbol (dip
);
2771 scan_partial_symbols -- scan DIE's within a single compilation unit
2775 Process the DIE's within a single compilation unit, looking for
2776 interesting DIE's that contribute to the partial symbol table entry
2777 for this compilation unit. Since we cannot follow any sibling
2778 chains without reading the complete DIE info for every DIE,
2779 it is probably faster to just sequentially check each one to
2780 see if it is one of the types we are interested in, and if so,
2781 then extract all the attributes info and generate a partial
2786 Don't attempt to add anonymous structures or unions since they have
2787 no name. Anonymous enumerations however are processed, because we
2788 want to extract their member names (the check for a tag name is
2791 Also, for variables and subroutines, check that this is the place
2792 where the actual definition occurs, rather than just a reference
2797 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2802 while (thisdie
< enddie
)
2804 basicdieinfo (&di
, thisdie
);
2805 if (di
.dielength
< sizeof (long))
2811 nextdie
= thisdie
+ di
.dielength
;
2812 /* To avoid getting complete die information for every die, we
2813 only do it (below) for the cases we are interested in. */
2816 case TAG_global_subroutine
:
2817 case TAG_subroutine
:
2818 case TAG_global_variable
:
2819 case TAG_local_variable
:
2820 completedieinfo (&di
);
2821 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2823 add_partial_symbol (&di
);
2827 case TAG_structure_type
:
2828 case TAG_union_type
:
2829 completedieinfo (&di
);
2832 add_partial_symbol (&di
);
2835 case TAG_enumeration_type
:
2836 completedieinfo (&di
);
2837 add_partial_symbol (&di
);
2849 scan_compilation_units -- build a psymtab entry for each compilation
2853 This is the top level dwarf parsing routine for building partial
2856 It scans from the beginning of the DWARF table looking for the first
2857 TAG_compile_unit DIE, and then follows the sibling chain to locate
2858 each additional TAG_compile_unit DIE.
2860 For each TAG_compile_unit DIE it creates a partial symtab structure,
2861 calls a subordinate routine to collect all the compilation unit's
2862 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2863 new partial symtab structure into the partial symbol table. It also
2864 records the appropriate information in the partial symbol table entry
2865 to allow the chunk of DIE's and line number table for this compilation
2866 unit to be located and re-read later, to generate a complete symbol
2867 table entry for the compilation unit.
2869 Thus it effectively partitions up a chunk of DIE's for multiple
2870 compilation units into smaller DIE chunks and line number tables,
2871 and associates them with a partial symbol table entry.
2875 If any compilation unit has no line number table associated with
2876 it for some reason (a missing at_stmt_list attribute, rather than
2877 just one with a value of zero, which is valid) then we ensure that
2878 the recorded file offset is zero so that the routine which later
2879 reads line number table fragments knows that there is no fragment
2889 DEFUN(scan_compilation_units
,
2890 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2895 unsigned int dbfoff AND
2896 unsigned int lnoffset AND
2897 struct objfile
*objfile
)
2901 struct partial_symtab
*pst
;
2906 while (thisdie
< enddie
)
2908 basicdieinfo (&di
, thisdie
);
2909 if (di
.dielength
< sizeof (long))
2913 else if (di
.dietag
!= TAG_compile_unit
)
2915 nextdie
= thisdie
+ di
.dielength
;
2919 completedieinfo (&di
);
2920 if (di
.at_sibling
!= 0)
2922 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2926 nextdie
= thisdie
+ di
.dielength
;
2928 curoff
= thisdie
- dbbase
;
2929 culength
= nextdie
- thisdie
;
2930 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2931 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2932 di
.at_low_pc
, di
.at_high_pc
,
2933 dbfoff
, curoff
, culength
, curlnoffset
,
2934 global_psymbols
.next
,
2935 static_psymbols
.next
);
2936 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2937 pst
-> n_global_syms
= global_psymbols
.next
-
2938 (global_psymbols
.list
+ pst
-> globals_offset
);
2939 pst
-> n_static_syms
= static_psymbols
.next
-
2940 (static_psymbols
.list
+ pst
-> statics_offset
);
2941 /* Sort the global list; don't sort the static list */
2942 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2943 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2945 /* If there is already a psymtab or symtab for a file of this name,
2946 remove it. (If there is a symtab, more drastic things also
2947 happen.) This happens in VxWorks. */
2948 free_named_symtabs (pst
-> filename
);
2949 /* Place the partial symtab on the partial symtab list */
2950 pst
-> next
= partial_symtab_list
;
2951 partial_symtab_list
= pst
;
2961 new_symbol -- make a symbol table entry for a new symbol
2965 static struct symbol *new_symbol (struct dieinfo *dip)
2969 Given a pointer to a DWARF information entry, figure out if we need
2970 to make a symbol table entry for it, and if so, create a new entry
2971 and return a pointer to it.
2974 static struct symbol
*
2975 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2977 struct symbol
*sym
= NULL
;
2979 if (dip
-> at_name
!= NULL
)
2981 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2982 sizeof (struct symbol
));
2983 (void) memset (sym
, 0, sizeof (struct symbol
));
2984 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2985 /* default assumptions */
2986 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2987 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2988 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2989 switch (dip
-> dietag
)
2992 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2993 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2995 case TAG_global_subroutine
:
2996 case TAG_subroutine
:
2997 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2998 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2999 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3000 if (dip
-> dietag
== TAG_global_subroutine
)
3002 add_symbol_to_list (sym
, &global_symbols
);
3006 add_symbol_to_list (sym
, &scope
-> symbols
);
3009 case TAG_global_variable
:
3010 case TAG_local_variable
:
3011 if (dip
-> at_location
!= NULL
)
3013 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3015 if (dip
-> dietag
== TAG_global_variable
)
3017 add_symbol_to_list (sym
, &global_symbols
);
3018 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3019 SYMBOL_VALUE (sym
) += baseaddr
;
3023 add_symbol_to_list (sym
, &scope
-> symbols
);
3024 if (scope
-> parent
!= NULL
)
3028 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3032 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3037 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3038 SYMBOL_VALUE (sym
) += baseaddr
;
3042 case TAG_formal_parameter
:
3043 if (dip
-> at_location
!= NULL
)
3045 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3047 add_symbol_to_list (sym
, &scope
-> symbols
);
3050 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3054 SYMBOL_CLASS (sym
) = LOC_ARG
;
3057 case TAG_unspecified_parameters
:
3058 /* From varargs functions; gdb doesn't seem to have any interest in
3059 this information, so just ignore it for now. (FIXME?) */
3061 case TAG_structure_type
:
3062 case TAG_union_type
:
3063 case TAG_enumeration_type
:
3064 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3065 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3066 add_symbol_to_list (sym
, &scope
-> symbols
);
3069 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3070 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3071 add_symbol_to_list (sym
, &scope
-> symbols
);
3074 /* Not a tag we recognize. Hopefully we aren't processing trash
3075 data, but since we must specifically ignore things we don't
3076 recognize, there is nothing else we should do at this point. */
3087 decode_mod_fund_type -- decode a modified fundamental type
3091 static struct type *decode_mod_fund_type (char *typedata)
3095 Decode a block of data containing a modified fundamental
3096 type specification. TYPEDATA is a pointer to the block,
3097 which consists of a two byte length, containing the size
3098 of the rest of the block. At the end of the block is a
3099 two byte value that gives the fundamental type. Everything
3100 in between are type modifiers.
3102 We simply compute the number of modifiers and call the general
3103 function decode_modified_type to do the actual work.
3106 static struct type
*
3107 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3109 struct type
*typep
= NULL
;
3110 unsigned short modcount
;
3111 unsigned char *modifiers
;
3113 /* Get the total size of the block, exclusive of the size itself */
3114 (void) memcpy (&modcount
, typedata
, sizeof (short));
3115 /* Deduct the size of the fundamental type bytes at the end of the block. */
3116 modcount
-= sizeof (short);
3117 /* Skip over the two size bytes at the beginning of the block. */
3118 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3119 /* Now do the actual decoding */
3120 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3128 decode_mod_u_d_type -- decode a modified user defined type
3132 static struct type *decode_mod_u_d_type (char *typedata)
3136 Decode a block of data containing a modified user defined
3137 type specification. TYPEDATA is a pointer to the block,
3138 which consists of a two byte length, containing the size
3139 of the rest of the block. At the end of the block is a
3140 four byte value that gives a reference to a user defined type.
3141 Everything in between are type modifiers.
3143 We simply compute the number of modifiers and call the general
3144 function decode_modified_type to do the actual work.
3147 static struct type
*
3148 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3150 struct type
*typep
= NULL
;
3151 unsigned short modcount
;
3152 unsigned char *modifiers
;
3154 /* Get the total size of the block, exclusive of the size itself */
3155 (void) memcpy (&modcount
, typedata
, sizeof (short));
3156 /* Deduct the size of the reference type bytes at the end of the block. */
3157 modcount
-= sizeof (long);
3158 /* Skip over the two size bytes at the beginning of the block. */
3159 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3160 /* Now do the actual decoding */
3161 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3169 decode_modified_type -- decode modified user or fundamental type
3173 static struct type *decode_modified_type (unsigned char *modifiers,
3174 unsigned short modcount, int mtype)
3178 Decode a modified type, either a modified fundamental type or
3179 a modified user defined type. MODIFIERS is a pointer to the
3180 block of bytes that define MODCOUNT modifiers. Immediately
3181 following the last modifier is a short containing the fundamental
3182 type or a long containing the reference to the user defined
3183 type. Which one is determined by MTYPE, which is either
3184 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3185 type we are generating.
3187 We call ourself recursively to generate each modified type,`
3188 until MODCOUNT reaches zero, at which point we have consumed
3189 all the modifiers and generate either the fundamental type or
3190 user defined type. When the recursion unwinds, each modifier
3191 is applied in turn to generate the full modified type.
3195 If we find a modifier that we don't recognize, and it is not one
3196 of those reserved for application specific use, then we issue a
3197 warning and simply ignore the modifier.
3201 We currently ignore MOD_const and MOD_volatile. (FIXME)
3205 static struct type
*
3206 DEFUN(decode_modified_type
,
3207 (modifiers
, modcount
, mtype
),
3208 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3210 struct type
*typep
= NULL
;
3211 unsigned short fundtype
;
3213 unsigned char modifier
;
3219 case AT_mod_fund_type
:
3220 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3221 typep
= decode_fund_type (fundtype
);
3223 case AT_mod_u_d_type
:
3224 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3225 if ((typep
= lookup_utype (dieref
)) == NULL
)
3227 typep
= alloc_utype (dieref
, NULL
);
3231 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3232 typep
= builtin_type_int
;
3238 modifier
= *modifiers
++;
3239 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3242 case MOD_pointer_to
:
3243 typep
= lookup_pointer_type (typep
);
3245 case MOD_reference_to
:
3246 typep
= lookup_reference_type (typep
);
3249 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3252 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3255 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3257 SQUAWK (("unknown type modifier %u", modifier
));
3269 decode_fund_type -- translate basic DWARF type to gdb base type
3273 Given an integer that is one of the fundamental DWARF types,
3274 translate it to one of the basic internal gdb types and return
3275 a pointer to the appropriate gdb type (a "struct type *").
3279 If we encounter a fundamental type that we are unprepared to
3280 deal with, and it is not in the range of those types defined
3281 as application specific types, then we issue a warning and
3282 treat the type as builtin_type_int.
3285 static struct type
*
3286 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3288 struct type
*typep
= NULL
;
3294 typep
= builtin_type_void
;
3297 case FT_pointer
: /* (void *) */
3298 typep
= lookup_pointer_type (builtin_type_void
);
3302 case FT_signed_char
:
3303 typep
= builtin_type_char
;
3307 case FT_signed_short
:
3308 typep
= builtin_type_short
;
3312 case FT_signed_integer
:
3313 case FT_boolean
: /* Was FT_set in AT&T version */
3314 typep
= builtin_type_int
;
3318 case FT_signed_long
:
3319 typep
= builtin_type_long
;
3323 typep
= builtin_type_float
;
3326 case FT_dbl_prec_float
:
3327 typep
= builtin_type_double
;
3330 case FT_unsigned_char
:
3331 typep
= builtin_type_unsigned_char
;
3334 case FT_unsigned_short
:
3335 typep
= builtin_type_unsigned_short
;
3338 case FT_unsigned_integer
:
3339 typep
= builtin_type_unsigned_int
;
3342 case FT_unsigned_long
:
3343 typep
= builtin_type_unsigned_long
;
3346 case FT_ext_prec_float
:
3347 typep
= builtin_type_long_double
;
3351 typep
= builtin_type_complex
;
3354 case FT_dbl_prec_complex
:
3355 typep
= builtin_type_double_complex
;
3359 case FT_signed_long_long
:
3360 typep
= builtin_type_long_long
;
3363 case FT_unsigned_long_long
:
3364 typep
= builtin_type_unsigned_long_long
;
3369 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3371 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3372 typep
= builtin_type_void
;
3382 create_name -- allocate a fresh copy of a string on an obstack
3386 Given a pointer to a string and a pointer to an obstack, allocates
3387 a fresh copy of the string on the specified obstack.
3392 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3397 length
= strlen (name
) + 1;
3398 newname
= (char *) obstack_alloc (obstackp
, length
);
3399 (void) strcpy (newname
, name
);
3407 basicdieinfo -- extract the minimal die info from raw die data
3411 void basicdieinfo (char *diep, struct dieinfo *dip)
3415 Given a pointer to raw DIE data, and a pointer to an instance of a
3416 die info structure, this function extracts the basic information
3417 from the DIE data required to continue processing this DIE, along
3418 with some bookkeeping information about the DIE.
3420 The information we absolutely must have includes the DIE tag,
3421 and the DIE length. If we need the sibling reference, then we
3422 will have to call completedieinfo() to process all the remaining
3425 Note that since there is no guarantee that the data is properly
3426 aligned in memory for the type of access required (indirection
3427 through anything other than a char pointer), we use memcpy to
3428 shuffle data items larger than a char. Possibly inefficient, but
3431 We also take care of some other basic things at this point, such
3432 as ensuring that the instance of the die info structure starts
3433 out completely zero'd and that curdie is initialized for use
3434 in error reporting if we have a problem with the current die.
3438 All DIE's must have at least a valid length, thus the minimum
3439 DIE size is sizeof (long). In order to have a valid tag, the
3440 DIE size must be at least sizeof (short) larger, otherwise they
3441 are forced to be TAG_padding DIES.
3443 Padding DIES must be at least sizeof(long) in length, implying that
3444 if a padding DIE is used for alignment and the amount needed is less
3445 than sizeof(long) then the padding DIE has to be big enough to align
3446 to the next alignment boundry.
3450 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3453 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3455 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3456 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3457 if (dip
-> dielength
< sizeof (long))
3459 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3461 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3463 dip
-> dietag
= TAG_padding
;
3467 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3475 completedieinfo -- finish reading the information for a given DIE
3479 void completedieinfo (struct dieinfo *dip)
3483 Given a pointer to an already partially initialized die info structure,
3484 scan the raw DIE data and finish filling in the die info structure
3485 from the various attributes found.
3487 Note that since there is no guarantee that the data is properly
3488 aligned in memory for the type of access required (indirection
3489 through anything other than a char pointer), we use memcpy to
3490 shuffle data items larger than a char. Possibly inefficient, but
3495 Each time we are called, we increment the diecount variable, which
3496 keeps an approximate count of the number of dies processed for
3497 each compilation unit. This information is presented to the user
3498 if the info_verbose flag is set.
3503 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3505 char *diep
; /* Current pointer into raw DIE data */
3506 char *end
; /* Terminate DIE scan here */
3507 unsigned short attr
; /* Current attribute being scanned */
3508 unsigned short form
; /* Form of the attribute */
3509 short block2sz
; /* Size of a block2 attribute field */
3510 long block4sz
; /* Size of a block4 attribute field */
3514 end
= diep
+ dip
-> dielength
;
3515 diep
+= sizeof (long) + sizeof (short);
3518 (void) memcpy (&attr
, diep
, sizeof (short));
3519 diep
+= sizeof (short);
3523 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3526 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3529 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3532 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3535 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3538 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3539 dip
-> has_at_stmt_list
= 1;
3542 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3543 dip
-> has_at_low_pc
= 1;
3546 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3549 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3551 case AT_user_def_type
:
3552 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3555 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3558 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3561 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3564 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3567 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3570 dip
-> at_location
= diep
;
3572 case AT_mod_fund_type
:
3573 dip
-> at_mod_fund_type
= diep
;
3575 case AT_subscr_data
:
3576 dip
-> at_subscr_data
= diep
;
3578 case AT_mod_u_d_type
:
3579 dip
-> at_mod_u_d_type
= diep
;
3581 case AT_element_list
:
3582 dip
-> at_element_list
= diep
;
3583 dip
-> short_element_list
= 0;
3585 case AT_short_element_list
:
3586 dip
-> at_element_list
= diep
;
3587 dip
-> short_element_list
= 1;
3589 case AT_discr_value
:
3590 dip
-> at_discr_value
= diep
;
3592 case AT_string_length
:
3593 dip
-> at_string_length
= diep
;
3596 dip
-> at_name
= diep
;
3599 dip
-> at_comp_dir
= diep
;
3602 dip
-> at_producer
= diep
;
3605 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3607 case AT_start_scope
:
3608 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3610 case AT_stride_size
:
3611 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3614 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3617 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3620 /* Found an attribute that we are unprepared to handle. However
3621 it is specifically one of the design goals of DWARF that
3622 consumers should ignore unknown attributes. As long as the
3623 form is one that we recognize (so we know how to skip it),
3624 we can just ignore the unknown attribute. */
3631 diep
+= sizeof (short);
3634 diep
+= sizeof (long);
3637 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3641 diep
+= sizeof (long);
3644 (void) memcpy (&block2sz
, diep
, sizeof (short));
3645 block2sz
+= sizeof (short);
3649 (void) memcpy (&block4sz
, diep
, sizeof (long));
3650 block4sz
+= sizeof (long);
3654 diep
+= strlen (diep
) + 1;
3657 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));