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(init_psymbol_list
, (int total_symbols
));
338 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
341 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
344 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
347 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
349 static struct symtab
*
350 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
354 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
357 EXFUN(read_structure_scope
,
358 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
359 struct objfile
*objfile
));
362 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
365 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
368 EXFUN(read_array_type
, (struct dieinfo
*dip
));
371 EXFUN(read_subroutine_type
,
372 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
375 EXFUN(read_enumeration
,
376 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
380 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie AND
381 struct objfile
*objfile
));
384 EXFUN(enum_type
, (struct dieinfo
*dip
));
387 EXFUN(start_symtab
, (void));
391 (char *filename AND
long language AND
struct objfile
*objfile
));
394 EXFUN(scopecount
, (struct scopenode
*node
));
398 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
401 EXFUN(freescope
, (struct scopenode
*node
));
403 static struct block
*
404 EXFUN(buildblock
, (struct pending_symbol
*syms
));
407 EXFUN(closescope
, (void));
410 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
413 EXFUN(decode_line_numbers
, (char *linetable
));
416 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
419 EXFUN(decode_mod_fund_type
, (char *typedata
));
422 EXFUN(decode_mod_u_d_type
, (char *typedata
));
425 EXFUN(decode_modified_type
,
426 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
429 EXFUN(decode_fund_type
, (unsigned short fundtype
));
432 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
435 EXFUN(add_symbol_to_list
,
436 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
438 static struct block
**
439 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
441 static struct blockvector
*
442 EXFUN(make_blockvector
, (void));
445 EXFUN(lookup_utype
, (DIEREF dieref
));
448 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
450 static struct symbol
*
451 EXFUN(new_symbol
, (struct dieinfo
*dip
));
454 EXFUN(locval
, (char *loc
));
457 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
458 enum misc_function_type
));
461 EXFUN(compare_psymbols
,
462 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
469 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
473 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
474 int mainline, unsigned int dbfoff, unsigned int dbsize,
475 unsigned int lnoffset, unsigned int lnsize,
476 struct objfile *objfile)
480 This function is called upon to build partial symtabs from files
481 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
483 It is passed a file descriptor for an open file containing the DIES
484 and line number information, the corresponding filename for that
485 file, a base address for relocating the symbols, a flag indicating
486 whether or not this debugging information is from a "main symbol
487 table" rather than a shared library or dynamically linked file,
488 and file offset/size pairs for the DIE information and line number
498 DEFUN(dwarf_build_psymtabs
,
499 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
505 unsigned int dbfoff AND
506 unsigned int dbsize AND
507 unsigned int lnoffset AND
508 unsigned int lnsize AND
509 struct objfile
*objfile
)
511 struct cleanup
*back_to
;
513 dbbase
= xmalloc (dbsize
);
515 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
516 (read (desc
, dbbase
, dbsize
) != dbsize
))
519 error ("can't read DWARF data from '%s'", filename
);
521 back_to
= make_cleanup (free
, dbbase
);
523 /* If we are reinitializing, or if we have never loaded syms yet, init.
524 Since we have no idea how many DIES we are looking at, we just guess
525 some arbitrary value. */
527 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
529 init_psymbol_list (1024);
532 /* From this point on, we don't need to pass mainline around, so zap
533 addr to zero if we don't need relocation. */
540 /* Follow the compilation unit sibling chain, building a partial symbol
541 table entry for each one. Save enough information about each compilation
542 unit to locate the full DWARF information later. */
544 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
545 dbfoff
, lnoffset
, objfile
);
547 do_cleanups (back_to
);
555 record_misc_function -- add entry to miscellaneous function vector
559 static void record_misc_function (char *name, CORE_ADDR address,
560 enum misc_function_type mf_type)
564 Given a pointer to the name of a symbol that should be added to the
565 miscellaneous function vector, and the address associated with that
566 symbol, records this information for later use in building the
567 miscellaneous function vector.
572 DEFUN(record_misc_function
, (name
, address
, mf_type
),
573 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
575 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
583 dwarfwarn -- issue a DWARF related warning
587 Issue warnings about DWARF related things that aren't serious enough
588 to warrant aborting with an error, but should not be ignored either.
589 This includes things like detectable corruption in DIE's, missing
590 DIE's, unimplemented features, etc.
592 In general, running across tags or attributes that we don't recognize
593 is not considered to be a problem and we should not issue warnings
598 We mostly follow the example of the error() routine, but without
599 returning to command level. It is arguable about whether warnings
600 should be issued at all, and if so, where they should go (stdout or
603 We assume that curdie is valid and contains at least the basic
604 information for the DIE where the problem was noticed.
609 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
615 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
616 if (curdie
-> at_name
)
618 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
620 vfprintf (stderr
, fmt
, ap
);
621 fprintf (stderr
, "\n");
635 fmt
= va_arg (ap
, char *);
637 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
638 if (curdie
-> at_name
)
640 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
642 vfprintf (stderr
, fmt
, ap
);
643 fprintf (stderr
, "\n");
652 compare_psymbols -- compare two partial symbols by name
656 Given pointer to two partial symbol table entries, compare
657 them by name and return -N, 0, or +N (ala strcmp). Typically
658 used by sorting routines like qsort().
662 This is a copy from dbxread.c. It should be moved to a generic
663 gdb file and made available for all psymtab builders (FIXME).
665 Does direct compare of first two characters before punting
666 and passing to strcmp for longer compares. Note that the
667 original version had a bug whereby two null strings or two
668 identically named one character strings would return the
669 comparison of memory following the null byte.
674 DEFUN(compare_psymbols
, (s1
, s2
),
675 struct partial_symbol
*s1 AND
676 struct partial_symbol
*s2
)
678 register char *st1
= SYMBOL_NAME (s1
);
679 register char *st2
= SYMBOL_NAME (s2
);
681 if ((st1
[0] - st2
[0]) || !st1
[0])
683 return (st1
[0] - st2
[0]);
685 else if ((st1
[1] - st2
[1]) || !st1
[1])
687 return (st1
[1] - st2
[1]);
691 return (strcmp (st1
+ 2, st2
+ 2));
699 read_lexical_block_scope -- process all dies in a lexical block
703 static void read_lexical_block_scope (struct dieinfo *dip,
704 char *thisdie, char *enddie)
708 Process all the DIES contained within a lexical block scope.
709 Start a new scope, process the dies, and then close the scope.
714 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
715 struct dieinfo
*dip AND
718 struct objfile
*objfile
)
720 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
721 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
729 lookup_utype -- look up a user defined type from die reference
733 static type *lookup_utype (DIEREF dieref)
737 Given a DIE reference, lookup the user defined type associated with
738 that DIE, if it has been registered already. If not registered, then
739 return NULL. Alloc_utype() can be called to register an empty
740 type for this reference, which will be filled in later when the
741 actual referenced DIE is processed.
745 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
747 struct type
*type
= NULL
;
750 utypeidx
= (dieref
- dbroff
) / 4;
751 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
753 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
757 type
= *(utypes
+ utypeidx
);
767 alloc_utype -- add a user defined type for die reference
771 static type *alloc_utype (DIEREF dieref, struct type *utypep)
775 Given a die reference DIEREF, and a possible pointer to a user
776 defined type UTYPEP, register that this reference has a user
777 defined type and either use the specified type in UTYPEP or
778 make a new empty type that will be filled in later.
780 We should only be called after calling lookup_utype() to verify that
781 there is not currently a type registered for DIEREF.
785 DEFUN(alloc_utype
, (dieref
, utypep
),
792 utypeidx
= (dieref
- dbroff
) / 4;
793 typep
= utypes
+ utypeidx
;
794 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
796 utypep
= builtin_type_int
;
797 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
799 else if (*typep
!= NULL
)
802 SQUAWK (("internal error: dup user type allocation"));
808 utypep
= (struct type
*)
809 obstack_alloc (symbol_obstack
, sizeof (struct type
));
810 (void) memset (utypep
, 0, sizeof (struct type
));
821 decode_die_type -- return a type for a specified die
825 static struct type *decode_die_type (struct dieinfo *dip)
829 Given a pointer to a die information structure DIP, decode the
830 type of the die and return a pointer to the decoded type. All
831 dies without specific types default to type int.
835 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
837 struct type
*type
= NULL
;
839 if (dip
-> at_fund_type
!= 0)
841 type
= decode_fund_type (dip
-> at_fund_type
);
843 else if (dip
-> at_mod_fund_type
!= NULL
)
845 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
847 else if (dip
-> at_user_def_type
)
849 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
851 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
854 else if (dip
-> at_mod_u_d_type
)
856 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
860 type
= builtin_type_int
;
869 struct_type -- compute and return the type for a struct or union
873 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
874 char *enddie, struct objfile *objfile)
878 Given pointer to a die information structure for a die which
879 defines a union or structure (and MUST define one or the other),
880 and pointers to the raw die data that define the range of dies which
881 define the members, compute and return the user defined type for the
886 DEFUN(struct_type
, (dip
, thisdie
, enddie
, objfile
),
887 struct dieinfo
*dip AND
890 struct objfile
*objfile
)
894 struct nextfield
*next
;
897 struct nextfield
*list
= NULL
;
898 struct nextfield
*new;
905 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
907 /* No forward references created an empty type, so install one now */
908 type
= alloc_utype (dip
-> dieref
, NULL
);
910 INIT_CPLUS_SPECIFIC(type
);
911 switch (dip
-> dietag
)
913 case TAG_structure_type
:
914 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
918 TYPE_CODE (type
) = TYPE_CODE_UNION
;
922 /* Should never happen */
923 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
925 SQUAWK (("missing structure or union tag"));
928 /* Some compilers try to be helpful by inventing "fake" names for
929 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
930 Thanks, but no thanks... */
931 if (dip
-> at_name
!= NULL
932 && *dip
-> at_name
!= '~'
933 && *dip
-> at_name
!= '.')
935 TYPE_NAME (type
) = obconcat (tpart1
, " ", dip
-> at_name
);
937 if (dip
-> at_byte_size
!= 0)
939 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
941 thisdie
+= dip
-> dielength
;
942 while (thisdie
< enddie
)
944 basicdieinfo (&mbr
, thisdie
);
945 completedieinfo (&mbr
);
946 if (mbr
.dielength
<= sizeof (long))
950 else if (mbr
.at_sibling
!= 0)
952 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
956 nextdie
= thisdie
+ mbr
.dielength
;
961 /* Get space to record the next field's data. */
962 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
966 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
967 list
-> field
.type
= decode_die_type (&mbr
);
968 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
969 list
-> field
.bitsize
= 0;
973 process_dies (thisdie
, nextdie
, objfile
);
978 /* Now create the vector of fields, and record how big it is. We may
979 not even have any fields, if this DIE was generated due to a reference
980 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
981 set, which clues gdb in to the fact that it needs to search elsewhere
982 for the full structure definition. */
985 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
989 TYPE_NFIELDS (type
) = nfields
;
990 TYPE_FIELDS (type
) = (struct field
*)
991 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
992 /* Copy the saved-up fields into the field vector. */
993 for (n
= nfields
; list
; list
= list
-> next
)
995 TYPE_FIELD (type
, --n
) = list
-> field
;
1005 read_structure_scope -- process all dies within struct or union
1009 static void read_structure_scope (struct dieinfo *dip,
1010 char *thisdie, char *enddie, struct objfile *objfile)
1014 Called when we find the DIE that starts a structure or union
1015 scope (definition) to process all dies that define the members
1016 of the structure or union. DIP is a pointer to the die info
1017 struct for the DIE that names the structure or union.
1021 Note that we need to call struct_type regardless of whether or not
1022 the DIE has an at_name attribute, since it might be an anonymous
1023 structure or union. This gets the type entered into our set of
1026 However, if the structure is incomplete (an opaque struct/union)
1027 then suppress creating a symbol table entry for it since gdb only
1028 wants to find the one with the complete definition. Note that if
1029 it is complete, we just call new_symbol, which does it's own
1030 checking about whether the struct/union is anonymous or not (and
1031 suppresses creating a symbol table entry itself).
1036 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
, objfile
),
1037 struct dieinfo
*dip AND
1040 struct objfile
*objfile
)
1045 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1046 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1048 if ((sym
= new_symbol (dip
)) != NULL
)
1050 SYMBOL_TYPE (sym
) = type
;
1059 decode_array_element_type -- decode type of the array elements
1063 static struct type *decode_array_element_type (char *scan, char *end)
1067 As the last step in decoding the array subscript information for an
1068 array DIE, we need to decode the type of the array elements. We are
1069 passed a pointer to this last part of the subscript information and
1070 must return the appropriate type. If the type attribute is not
1071 recognized, just warn about the problem and return type int.
1074 static struct type
*
1075 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1080 unsigned short fundtype
;
1082 (void) memcpy (&attribute
, scan
, sizeof (short));
1083 scan
+= sizeof (short);
1087 (void) memcpy (&fundtype
, scan
, sizeof (short));
1088 typep
= decode_fund_type (fundtype
);
1090 case AT_mod_fund_type
:
1091 typep
= decode_mod_fund_type (scan
);
1093 case AT_user_def_type
:
1094 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1095 if ((typep
= lookup_utype (dieref
)) == NULL
)
1097 typep
= alloc_utype (dieref
, NULL
);
1100 case AT_mod_u_d_type
:
1101 typep
= decode_mod_u_d_type (scan
);
1104 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1105 typep
= builtin_type_int
;
1115 decode_subscr_data -- decode array subscript and element type data
1119 static struct type *decode_subscr_data (char *scan, char *end)
1123 The array subscripts and the data type of the elements of an
1124 array are described by a list of data items, stored as a block
1125 of contiguous bytes. There is a data item describing each array
1126 dimension, and a final data item describing the element type.
1127 The data items are ordered the same as their appearance in the
1128 source (I.E. leftmost dimension first, next to leftmost second,
1131 We are passed a pointer to the start of the block of bytes
1132 containing the data items, and a pointer to the first byte past
1133 the data. This function decodes the data and returns a type.
1136 FIXME: This code only implements the forms currently used
1137 by the AT&T and GNU C compilers.
1139 The end pointer is supplied for error checking, maybe we should
1143 static struct type
*
1144 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1146 struct type
*typep
= NULL
;
1147 struct type
*nexttype
;
1157 typep
= decode_array_element_type (scan
, end
);
1160 (void) memcpy (&fundtype
, scan
, sizeof (short));
1161 scan
+= sizeof (short);
1162 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1163 && fundtype
!= FT_unsigned_integer
)
1165 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1170 (void) memcpy (&lowbound
, scan
, sizeof (long));
1171 scan
+= sizeof (long);
1172 (void) memcpy (&highbound
, scan
, sizeof (long));
1173 scan
+= sizeof (long);
1174 nexttype
= decode_subscr_data (scan
, end
);
1175 if (nexttype
!= NULL
)
1177 typep
= (struct type
*)
1178 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1179 (void) memset (typep
, 0, sizeof (struct type
));
1180 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1181 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1182 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1183 TYPE_TARGET_TYPE (typep
) = nexttype
;
1194 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1197 SQUAWK (("unknown array subscript format %x", format
));
1207 read_array_type -- read TAG_array_type DIE
1211 static void read_array_type (struct dieinfo *dip)
1215 Extract all information from a TAG_array_type DIE and add to
1216 the user defined type vector.
1220 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1227 if (dip
-> at_ordering
!= ORD_row_major
)
1229 /* FIXME: Can gdb even handle column major arrays? */
1230 SQUAWK (("array not row major; not handled correctly"));
1232 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1234 (void) memcpy (&temp
, sub
, sizeof (short));
1235 subend
= sub
+ sizeof (short) + temp
;
1236 sub
+= sizeof (short);
1237 type
= decode_subscr_data (sub
, subend
);
1240 type
= alloc_utype (dip
-> dieref
, NULL
);
1241 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1242 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1243 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1247 type
= alloc_utype (dip
-> dieref
, type
);
1256 read_subroutine_type -- process TAG_subroutine_type dies
1260 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1265 Handle DIES due to C code like:
1268 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1274 The parameter DIES are currently ignored. See if gdb has a way to
1275 include this info in it's type system, and decode them if so. Is
1276 this what the type structure's "arg_types" field is for? (FIXME)
1280 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1281 struct dieinfo
*dip AND
1287 type
= decode_die_type (dip
);
1288 type
= lookup_function_type (type
);
1289 type
= alloc_utype (dip
-> dieref
, type
);
1296 read_enumeration -- process dies which define an enumeration
1300 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1305 Given a pointer to a die which begins an enumeration, process all
1306 the dies that define the members of the enumeration.
1310 Note that we need to call enum_type regardless of whether or not we
1311 have a symbol, since we might have an enum without a tag name (thus
1312 no symbol for the tagname).
1316 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1317 struct dieinfo
*dip AND
1324 type
= enum_type (dip
);
1325 if ((sym
= new_symbol (dip
)) != NULL
)
1327 SYMBOL_TYPE (sym
) = type
;
1335 enum_type -- decode and return a type for an enumeration
1339 static type *enum_type (struct dieinfo *dip)
1343 Given a pointer to a die information structure for the die which
1344 starts an enumeration, process all the dies that define the members
1345 of the enumeration and return a type pointer for the enumeration.
1347 At the same time, for each member of the enumeration, create a
1348 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1349 and give it the type of the enumeration itself.
1353 Note that the DWARF specification explicitly mandates that enum
1354 constants occur in reverse order from the source program order,
1355 for "consistency" and because this ordering is easier for many
1356 compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
1357 Entries). Because gdb wants to see the enum members in program
1358 source order, we have to ensure that the order gets reversed while
1359 we are processing them.
1362 static struct type
*
1363 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1367 struct nextfield
*next
;
1370 struct nextfield
*list
= NULL
;
1371 struct nextfield
*new;
1380 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1382 /* No forward references created an empty type, so install one now */
1383 type
= alloc_utype (dip
-> dieref
, NULL
);
1385 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1386 /* Some compilers try to be helpful by inventing "fake" names for
1387 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1388 Thanks, but no thanks... */
1389 if (dip
-> at_name
!= NULL
1390 && *dip
-> at_name
!= '~'
1391 && *dip
-> at_name
!= '.')
1393 TYPE_NAME (type
) = obconcat ("enum", " ", dip
-> at_name
);
1395 if (dip
-> at_byte_size
!= 0)
1397 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1399 if ((scan
= dip
-> at_element_list
) != NULL
)
1401 if (dip
-> short_element_list
)
1403 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1404 listend
= scan
+ stemp
+ sizeof (stemp
);
1405 scan
+= sizeof (stemp
);
1409 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1410 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1411 scan
+= sizeof (ltemp
);
1413 while (scan
< listend
)
1415 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1418 list
-> field
.type
= NULL
;
1419 list
-> field
.bitsize
= 0;
1420 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1421 scan
+= sizeof (long);
1422 list
-> field
.name
= savestring (scan
, strlen (scan
));
1423 scan
+= strlen (scan
) + 1;
1425 /* Handcraft a new symbol for this enum member. */
1426 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
1427 sizeof (struct symbol
));
1428 (void) memset (sym
, 0, sizeof (struct symbol
));
1429 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
, symbol_obstack
);
1430 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1431 SYMBOL_CLASS (sym
) = LOC_CONST
;
1432 SYMBOL_TYPE (sym
) = type
;
1433 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1434 add_symbol_to_list (sym
, &scope
-> symbols
);
1436 /* Now create the vector of fields, and record how big it is. This is
1437 where we reverse the order, by pulling the members of the list in
1438 reverse order from how they were inserted. If we have no fields
1439 (this is apparently possible in C++) then skip building a field
1443 TYPE_NFIELDS (type
) = nfields
;
1444 TYPE_FIELDS (type
) = (struct field
*)
1445 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1446 /* Copy the saved-up fields into the field vector. */
1447 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1449 TYPE_FIELD (type
, n
++) = list
-> field
;
1460 read_func_scope -- process all dies within a function scope
1464 Process all dies within a given function scope. We are passed
1465 a die information structure pointer DIP for the die which
1466 starts the function scope, and pointers into the raw die data
1467 that define the dies within the function scope.
1469 For now, we ignore lexical block scopes within the function.
1470 The problem is that AT&T cc does not define a DWARF lexical
1471 block scope for the function itself, while gcc defines a
1472 lexical block scope for the function. We need to think about
1473 how to handle this difference, or if it is even a problem.
1478 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1479 struct dieinfo
*dip AND
1482 struct objfile
*objfile
)
1486 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1488 entry_scope_lowpc
= dip
-> at_low_pc
;
1489 entry_scope_highpc
= dip
-> at_high_pc
;
1491 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1493 main_scope_lowpc
= dip
-> at_low_pc
;
1494 main_scope_highpc
= dip
-> at_high_pc
;
1496 sym
= new_symbol (dip
);
1497 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1498 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1506 read_file_scope -- process all dies within a file scope
1510 Process all dies within a given file scope. We are passed a
1511 pointer to the die information structure for the die which
1512 starts the file scope, and pointers into the raw die data which
1513 mark the range of dies within the file scope.
1515 When the partial symbol table is built, the file offset for the line
1516 number table for each compilation unit is saved in the partial symbol
1517 table entry for that compilation unit. As the symbols for each
1518 compilation unit are read, the line number table is read into memory
1519 and the variable lnbase is set to point to it. Thus all we have to
1520 do is use lnbase to access the line number table for the current
1525 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1526 struct dieinfo
*dip AND
1529 struct objfile
*objfile
)
1531 struct cleanup
*back_to
;
1533 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1535 startup_file_start
= dip
-> at_low_pc
;
1536 startup_file_end
= dip
-> at_high_pc
;
1538 numutypes
= (enddie
- thisdie
) / 4;
1539 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1540 back_to
= make_cleanup (free
, utypes
);
1541 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1543 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1544 decode_line_numbers (lnbase
);
1545 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1547 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1548 do_cleanups (back_to
);
1557 start_symtab -- do initialization for starting new symbol table
1561 static void start_symtab (void)
1565 Called whenever we are starting to process dies for a new
1566 compilation unit, to perform initializations. Right now
1567 the only thing we really have to do is initialize storage
1568 space for the line number vector.
1573 DEFUN_VOID (start_symtab
)
1577 line_vector_index
= 0;
1578 line_vector_length
= 1000;
1579 nbytes
= sizeof (struct linetable
);
1580 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1581 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1588 process_dies -- process a range of DWARF Information Entries
1592 static void process_dies (char *thisdie, char *enddie,
1593 struct objfile *objfile)
1597 Process all DIE's in a specified range. May be (and almost
1598 certainly will be) called recursively.
1602 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1603 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1608 while (thisdie
< enddie
)
1610 basicdieinfo (&di
, thisdie
);
1611 if (di
.dielength
< sizeof (long))
1615 else if (di
.dietag
== TAG_padding
)
1617 nextdie
= thisdie
+ di
.dielength
;
1621 completedieinfo (&di
);
1622 if (di
.at_sibling
!= 0)
1624 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1628 nextdie
= thisdie
+ di
.dielength
;
1632 case TAG_compile_unit
:
1633 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1635 case TAG_global_subroutine
:
1636 case TAG_subroutine
:
1637 if (di
.has_at_low_pc
)
1639 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1642 case TAG_lexical_block
:
1643 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1645 case TAG_structure_type
:
1646 case TAG_union_type
:
1647 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1649 case TAG_enumeration_type
:
1650 read_enumeration (&di
, thisdie
, nextdie
);
1652 case TAG_subroutine_type
:
1653 read_subroutine_type (&di
, thisdie
, nextdie
);
1655 case TAG_array_type
:
1656 read_array_type (&di
);
1659 (void) new_symbol (&di
);
1671 end_symtab -- finish processing for a compilation unit
1675 static void end_symtab (char *filename, long language)
1679 Complete the symbol table entry for the current compilation
1680 unit. Make the struct symtab and put it on the list of all
1686 DEFUN(end_symtab
, (filename
, language
, objfile
),
1687 char *filename AND
long language AND
struct objfile
*objfile
)
1689 struct symtab
*symtab
;
1690 struct blockvector
*blockvector
;
1693 /* Ignore a file that has no functions with real debugging info. */
1694 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1698 line_vector_length
= -1;
1699 freescope (scopetree
);
1700 scope
= scopetree
= NULL
;
1703 /* Create the blockvector that points to all the file's blocks. */
1705 blockvector
= make_blockvector ();
1707 /* Now create the symtab object for this source file. */
1709 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1712 symtab
-> free_ptr
= 0;
1714 /* Fill in its components. */
1715 symtab
-> blockvector
= blockvector
;
1716 symtab
-> free_code
= free_linetable
;
1718 /* Save the line number information. */
1720 line_vector
-> nitems
= line_vector_index
;
1721 nbytes
= sizeof (struct linetable
);
1722 if (line_vector_index
> 1)
1724 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1726 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1728 /* FIXME: The following may need to be expanded for other languages */
1733 symtab
-> language
= language_c
;
1735 case LANG_C_PLUS_PLUS
:
1736 symtab
-> language
= language_cplus
;
1742 /* Link the new symtab into the list of such. */
1743 symtab
-> next
= symtab_list
;
1744 symtab_list
= symtab
;
1746 /* Recursively free the scope tree */
1747 freescope (scopetree
);
1748 scope
= scopetree
= NULL
;
1750 /* Reinitialize for beginning of new file. */
1752 line_vector_length
= -1;
1759 scopecount -- count the number of enclosed scopes
1763 static int scopecount (struct scopenode *node)
1767 Given pointer to a node, compute the size of the subtree which is
1768 rooted in this node, which also happens to be the number of scopes
1773 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1779 count
+= scopecount (node
-> child
);
1780 count
+= scopecount (node
-> sibling
);
1790 openscope -- start a new lexical block scope
1794 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1799 Start a new scope by allocating a new scopenode, adding it as the
1800 next child of the current scope (if any) or as the root of the
1801 scope tree, and then making the new node the current scope node.
1805 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1806 struct symbol
*namesym AND
1810 struct scopenode
*new;
1811 struct scopenode
*child
;
1813 new = (struct scopenode
*) xmalloc (sizeof (*new));
1814 (void) memset (new, 0, sizeof (*new));
1815 new -> namesym
= namesym
;
1816 new -> lowpc
= lowpc
;
1817 new -> highpc
= highpc
;
1822 else if ((child
= scope
-> child
) == NULL
)
1824 scope
-> child
= new;
1825 new -> parent
= scope
;
1829 while (child
-> sibling
!= NULL
)
1831 child
= child
-> sibling
;
1833 child
-> sibling
= new;
1834 new -> parent
= scope
;
1843 freescope -- free a scope tree rooted at the given node
1847 static void freescope (struct scopenode *node)
1851 Given a pointer to a node in the scope tree, free the subtree
1852 rooted at that node. First free all the children and sibling
1853 nodes, and then the node itself. Used primarily for cleaning
1854 up after ourselves and returning memory to the system.
1858 DEFUN(freescope
, (node
), struct scopenode
*node
)
1862 freescope (node
-> child
);
1863 freescope (node
-> sibling
);
1872 buildblock -- build a new block from pending symbols list
1876 static struct block *buildblock (struct pending_symbol *syms)
1880 Given a pointer to a list of symbols, build a new block and free
1881 the symbol list structure. Also check each symbol to see if it
1882 is the special symbol that flags that this block was compiled by
1883 gcc, and if so, mark the block appropriately.
1886 static struct block
*
1887 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1889 struct pending_symbol
*next
, *next1
;
1891 struct block
*newblock
;
1894 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1896 /* Allocate a new block */
1898 nbytes
= sizeof (struct block
);
1901 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1903 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1904 (void) memset (newblock
, 0, nbytes
);
1906 /* Copy the symbols into the block. */
1908 BLOCK_NSYMS (newblock
) = i
;
1909 for (next
= syms
; next
; next
= next
-> next
)
1911 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1912 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1913 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1915 BLOCK_GCC_COMPILED (newblock
) = 1;
1919 /* Now free the links of the list, and empty the list. */
1921 for (next
= syms
; next
; next
= next1
)
1923 next1
= next
-> next
;
1934 closescope -- close a lexical block scope
1938 static void closescope (void)
1942 Close the current lexical block scope. Closing the current scope
1943 is as simple as moving the current scope pointer up to the parent
1944 of the current scope pointer. But we also take this opportunity
1945 to build the block for the current scope first, since we now have
1946 all of it's symbols.
1950 DEFUN_VOID(closescope
)
1952 struct scopenode
*child
;
1956 error ("DWARF parse error, too many close scopes");
1960 if (scope
-> parent
== NULL
)
1962 global_symbol_block
= buildblock (global_symbols
);
1963 global_symbols
= NULL
;
1964 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1965 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1967 scope
-> block
= buildblock (scope
-> symbols
);
1968 scope
-> symbols
= NULL
;
1969 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1970 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1972 /* Put the local block in as the value of the symbol that names it. */
1974 if (scope
-> namesym
)
1976 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1977 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1980 /* Install this scope's local block as the superblock of all child
1983 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1985 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1988 scope
= scope
-> parent
;
1996 record_line -- record a line number entry in the line vector
2000 static void record_line (int line, CORE_ADDR pc)
2004 Given a line number and the corresponding pc value, record
2005 this pair in the line number vector, expanding the vector as
2010 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
2012 struct linetable_entry
*e
;
2015 /* Make sure line vector is big enough. */
2017 if (line_vector_index
+ 2 >= line_vector_length
)
2019 line_vector_length
*= 2;
2020 nbytes
= sizeof (struct linetable
);
2021 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
2022 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
2024 e
= line_vector
-> item
+ line_vector_index
++;
2033 decode_line_numbers -- decode a line number table fragment
2037 static void decode_line_numbers (char *tblscan, char *tblend,
2038 long length, long base, long line, long pc)
2042 Translate the DWARF line number information to gdb form.
2044 The ".line" section contains one or more line number tables, one for
2045 each ".line" section from the objects that were linked.
2047 The AT_stmt_list attribute for each TAG_source_file entry in the
2048 ".debug" section contains the offset into the ".line" section for the
2049 start of the table for that file.
2051 The table itself has the following structure:
2053 <table length><base address><source statement entry>
2054 4 bytes 4 bytes 10 bytes
2056 The table length is the total size of the table, including the 4 bytes
2057 for the length information.
2059 The base address is the address of the first instruction generated
2060 for the source file.
2062 Each source statement entry has the following structure:
2064 <line number><statement position><address delta>
2065 4 bytes 2 bytes 4 bytes
2067 The line number is relative to the start of the file, starting with
2070 The statement position either -1 (0xFFFF) or the number of characters
2071 from the beginning of the line to the beginning of the statement.
2073 The address delta is the difference between the base address and
2074 the address of the first instruction for the statement.
2076 Note that we must copy the bytes from the packed table to our local
2077 variables before attempting to use them, to avoid alignment problems
2078 on some machines, particularly RISC processors.
2082 Does gdb expect the line numbers to be sorted? They are now by
2083 chance/luck, but are not required to be. (FIXME)
2085 The line with number 0 is unused, gdb apparently can discover the
2086 span of the last line some other way. How? (FIXME)
2090 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2099 if (linetable
!= NULL
)
2101 tblscan
= tblend
= linetable
;
2102 (void) memcpy (&length
, tblscan
, sizeof (long));
2103 tblscan
+= sizeof (long);
2105 (void) memcpy (&base
, tblscan
, sizeof (long));
2107 tblscan
+= sizeof (long);
2108 while (tblscan
< tblend
)
2110 (void) memcpy (&line
, tblscan
, sizeof (long));
2111 tblscan
+= sizeof (long) + sizeof (short);
2112 (void) memcpy (&pc
, tblscan
, sizeof (long));
2113 tblscan
+= sizeof (long);
2117 record_line (line
, pc
);
2127 add_symbol_to_list -- add a symbol to head of current symbol list
2131 static void add_symbol_to_list (struct symbol *symbol, struct
2132 pending_symbol **listhead)
2136 Given a pointer to a symbol and a pointer to a pointer to a
2137 list of symbols, add this symbol as the current head of the
2138 list. Typically used for example to add a symbol to the
2139 symbol list for the current scope.
2144 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2145 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2147 struct pending_symbol
*link
;
2151 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2152 link
-> next
= *listhead
;
2153 link
-> symbol
= symbol
;
2162 gatherblocks -- walk a scope tree and build block vectors
2166 static struct block **gatherblocks (struct block **dest,
2167 struct scopenode *node)
2171 Recursively walk a scope tree rooted in the given node, adding blocks
2172 to the array pointed to by DEST, in preorder. I.E., first we add the
2173 block for the current scope, then all the blocks for child scopes,
2174 and finally all the blocks for sibling scopes.
2177 static struct block
**
2178 DEFUN(gatherblocks
, (dest
, node
),
2179 struct block
**dest AND
struct scopenode
*node
)
2183 *dest
++ = node
-> block
;
2184 dest
= gatherblocks (dest
, node
-> child
);
2185 dest
= gatherblocks (dest
, node
-> sibling
);
2194 make_blockvector -- make a block vector from current scope tree
2198 static struct blockvector *make_blockvector (void)
2202 Make a blockvector from all the blocks in the current scope tree.
2203 The first block is always the global symbol block, followed by the
2204 block for the root of the scope tree which is the local symbol block,
2205 followed by all the remaining blocks in the scope tree, which are all
2210 Note that since the root node of the scope tree is created at the time
2211 each file scope is entered, there are always at least two blocks,
2212 neither of which may have any symbols, but always contribute a block
2213 to the block vector. So the test for number of blocks greater than 1
2214 below is unnecessary given bug free code.
2216 The resulting block structure varies slightly from that produced
2217 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2218 with dbxread.c, block 1 is a child of block 0. This does not
2219 seem to cause any problems, but probably should be fixed. (FIXME)
2222 static struct blockvector
*
2223 DEFUN_VOID(make_blockvector
)
2225 struct blockvector
*blockvector
= NULL
;
2229 /* Recursively walk down the tree, counting the number of blocks.
2230 Then add one to account for the global's symbol block */
2232 i
= scopecount (scopetree
) + 1;
2233 nbytes
= sizeof (struct blockvector
);
2236 nbytes
+= (i
- 1) * sizeof (struct block
*);
2238 blockvector
= (struct blockvector
*)
2239 obstack_alloc (symbol_obstack
, nbytes
);
2241 /* Copy the blocks into the blockvector. */
2243 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2244 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2245 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2247 return (blockvector
);
2254 locval -- compute the value of a location attribute
2258 static int locval (char *loc)
2262 Given pointer to a string of bytes that define a location, compute
2263 the location and return the value.
2265 When computing values involving the current value of the frame pointer,
2266 the value zero is used, which results in a value relative to the frame
2267 pointer, rather than the absolute value. This is what GDB wants
2270 When the result is a register number, the global isreg flag is set,
2271 otherwise it is cleared. This is a kludge until we figure out a better
2272 way to handle the problem. Gdb's design does not mesh well with the
2273 DWARF notion of a location computing interpreter, which is a shame
2274 because the flexibility goes unused.
2278 Note that stack[0] is unused except as a default error return.
2279 Note that stack overflow is not yet handled.
2283 DEFUN(locval
, (loc
), char *loc
)
2285 unsigned short nbytes
;
2291 (void) memcpy (&nbytes
, loc
, sizeof (short));
2292 end
= loc
+ sizeof (short) + nbytes
;
2296 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2304 /* push register (number) */
2305 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2309 /* push value of register (number) */
2310 /* Actually, we compute the value as if register has 0 */
2311 (void) memcpy (®no
, loc
, sizeof (long));
2314 stack
[++stacki
] = 0;
2318 stack
[++stacki
] = 0;
2319 SQUAWK (("BASEREG %d not handled!", regno
));
2323 /* push address (relocated address) */
2324 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2327 /* push constant (number) */
2328 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2331 /* pop, deref and push 2 bytes (as a long) */
2332 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2334 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2335 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2337 case OP_ADD
: /* pop top 2 items, add, push result */
2338 stack
[stacki
- 1] += stack
[stacki
];
2343 return (stack
[stacki
]);
2350 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2354 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2360 static struct symtab
*
2361 DEFUN(read_ofile_symtab
, (pst
),
2362 struct partial_symtab
*pst
)
2364 struct cleanup
*back_to
;
2367 bfd
*abfd
= pst
->objfile
->obfd
;
2369 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2370 unit, seek to the location in the file, and read in all the DIE's. */
2373 dbbase
= xmalloc (DBLENGTH(pst
));
2374 dbroff
= DBROFF(pst
);
2375 foffset
= DBFOFF(pst
) + dbroff
;
2376 baseaddr
= pst
-> addr
;
2377 if (bfd_seek (abfd
, foffset
, 0) ||
2378 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2381 error ("can't read DWARF data");
2383 back_to
= make_cleanup (free
, dbbase
);
2385 /* If there is a line number table associated with this compilation unit
2386 then read the first long word from the line number table fragment, which
2387 contains the size of the fragment in bytes (including the long word
2388 itself). Allocate a buffer for the fragment and read it in for future
2394 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2395 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2397 error ("can't read DWARF line number table size");
2399 lnbase
= xmalloc (lnsize
);
2400 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2401 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2404 error ("can't read DWARF line numbers");
2406 make_cleanup (free
, lnbase
);
2409 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
2410 do_cleanups (back_to
);
2411 return (symtab_list
);
2418 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2422 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2426 Called once for each partial symbol table entry that needs to be
2427 expanded into a full symbol table entry.
2432 DEFUN(psymtab_to_symtab_1
,
2434 struct partial_symtab
*pst
)
2444 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2449 /* Read in all partial symtabs on which this one is dependent */
2450 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2451 if (!pst
-> dependencies
[i
] -> readin
)
2453 /* Inform about additional files that need to be read in. */
2456 fputs_filtered (" ", stdout
);
2458 fputs_filtered ("and ", stdout
);
2460 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2461 wrap_here (""); /* Flush output */
2464 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2467 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2469 pst
-> symtab
= read_ofile_symtab (pst
);
2472 printf_filtered ("%d DIE's, sorting...", diecount
);
2475 sort_symtab_syms (pst
-> symtab
);
2484 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2488 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2492 This is the DWARF support entry point for building a full symbol
2493 table entry from a partial symbol table entry. We are passed a
2494 pointer to the partial symbol table entry that needs to be expanded.
2499 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2508 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2513 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2515 /* Print the message now, before starting serious work, to avoid
2516 disconcerting pauses. */
2519 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2523 psymtab_to_symtab_1 (pst
);
2525 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2526 we need to do an equivalent or is this something peculiar to
2527 stabs/a.out format. */
2528 /* Match with global symbols. This only needs to be done once,
2529 after all of the symtabs and dependencies have been read in. */
2530 scan_file_globals ();
2533 /* Finish up the debug error message. */
2536 printf_filtered ("done.\n");
2545 init_psymbol_list -- initialize storage for partial symbols
2549 static void init_psymbol_list (int total_symbols)
2553 Initializes storage for all of the partial symbols that will be
2554 created by dwarf_build_psymtabs and subsidiaries.
2558 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2560 /* Free any previously allocated psymbol lists. */
2562 if (global_psymbols
.list
)
2564 free (global_psymbols
.list
);
2566 if (static_psymbols
.list
)
2568 free (static_psymbols
.list
);
2571 /* Current best guess is that there are approximately a twentieth
2572 of the total symbols (in a debugging file) are global or static
2575 global_psymbols
.size
= total_symbols
/ 10;
2576 static_psymbols
.size
= total_symbols
/ 10;
2577 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2578 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2579 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2580 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2587 start_psymtab -- allocate and partially fill a partial symtab entry
2591 Allocate and partially fill a partial symtab. It will be completely
2592 filled at the end of the symbol list.
2594 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2595 ADDR is the address relative to which its symbols are (incremental)
2596 or 0 (normal). FILENAME is the name of the compilation unit that
2597 these symbols were defined in, and they appear starting a address
2598 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2599 the full symbols can be read for compilation unit FILENAME.
2600 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2605 static struct partial_symtab
*
2606 DEFUN(start_psymtab
,
2607 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2608 culength
, lnfoff
, global_syms
, static_syms
),
2609 struct objfile
*objfile AND
2612 CORE_ADDR textlow AND
2613 CORE_ADDR texthigh AND
2618 struct partial_symbol
*global_syms AND
2619 struct partial_symbol
*static_syms
)
2621 struct partial_symtab
*result
;
2623 result
= (struct partial_symtab
*)
2624 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2625 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2626 result
-> addr
= addr
;
2627 result
-> objfile
= objfile
;
2628 result
-> filename
= create_name (filename
, psymbol_obstack
);
2629 result
-> textlow
= textlow
;
2630 result
-> texthigh
= texthigh
;
2631 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2632 sizeof (struct dwfinfo
));
2633 DBFOFF (result
) = dbfoff
;
2634 DBROFF (result
) = curoff
;
2635 DBLENGTH (result
) = culength
;
2636 LNFOFF (result
) = lnfoff
;
2637 result
-> readin
= 0;
2638 result
-> symtab
= NULL
;
2639 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2640 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2641 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2643 result
->n_global_syms
= 0;
2644 result
->n_static_syms
= 0;
2653 add_enum_psymbol -- add enumeration members to partial symbol table
2657 Given pointer to a DIE that is known to be for an enumeration,
2658 extract the symbolic names of the enumeration members and add
2659 partial symbols for them.
2663 DEFUN(add_enum_psymbol
, (dip
), struct dieinfo
*dip
)
2670 if ((scan
= dip
-> at_element_list
) != NULL
)
2672 if (dip
-> short_element_list
)
2674 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
2675 listend
= scan
+ stemp
+ sizeof (stemp
);
2676 scan
+= sizeof (stemp
);
2680 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
2681 listend
= scan
+ ltemp
+ sizeof (ltemp
);
2682 scan
+= sizeof (ltemp
);
2684 while (scan
< listend
)
2686 scan
+= sizeof (long);
2687 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2688 static_psymbols
, 0);
2689 scan
+= strlen (scan
) + 1;
2698 add_partial_symbol -- add symbol to partial symbol table
2702 Given a DIE, if it is one of the types that we want to
2703 add to a partial symbol table, finish filling in the die info
2704 and then add a partial symbol table entry for it.
2709 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2711 switch (dip
-> dietag
)
2713 case TAG_global_subroutine
:
2714 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2715 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2716 VAR_NAMESPACE
, LOC_BLOCK
, global_psymbols
,
2719 case TAG_global_variable
:
2720 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2722 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2723 VAR_NAMESPACE
, LOC_STATIC
, global_psymbols
,
2726 case TAG_subroutine
:
2727 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2728 VAR_NAMESPACE
, LOC_BLOCK
, static_psymbols
,
2731 case TAG_local_variable
:
2732 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2733 VAR_NAMESPACE
, LOC_STATIC
, static_psymbols
,
2737 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2738 VAR_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2741 case TAG_structure_type
:
2742 case TAG_union_type
:
2743 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2744 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2747 case TAG_enumeration_type
:
2750 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2751 STRUCT_NAMESPACE
, LOC_TYPEDEF
, static_psymbols
,
2754 add_enum_psymbol (dip
);
2763 scan_partial_symbols -- scan DIE's within a single compilation unit
2767 Process the DIE's within a single compilation unit, looking for
2768 interesting DIE's that contribute to the partial symbol table entry
2769 for this compilation unit. Since we cannot follow any sibling
2770 chains without reading the complete DIE info for every DIE,
2771 it is probably faster to just sequentially check each one to
2772 see if it is one of the types we are interested in, and if so,
2773 then extract all the attributes info and generate a partial
2778 Don't attempt to add anonymous structures or unions since they have
2779 no name. Anonymous enumerations however are processed, because we
2780 want to extract their member names (the check for a tag name is
2783 Also, for variables and subroutines, check that this is the place
2784 where the actual definition occurs, rather than just a reference
2789 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2794 while (thisdie
< enddie
)
2796 basicdieinfo (&di
, thisdie
);
2797 if (di
.dielength
< sizeof (long))
2803 nextdie
= thisdie
+ di
.dielength
;
2804 /* To avoid getting complete die information for every die, we
2805 only do it (below) for the cases we are interested in. */
2808 case TAG_global_subroutine
:
2809 case TAG_subroutine
:
2810 case TAG_global_variable
:
2811 case TAG_local_variable
:
2812 completedieinfo (&di
);
2813 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2815 add_partial_symbol (&di
);
2819 case TAG_structure_type
:
2820 case TAG_union_type
:
2821 completedieinfo (&di
);
2824 add_partial_symbol (&di
);
2827 case TAG_enumeration_type
:
2828 completedieinfo (&di
);
2829 add_partial_symbol (&di
);
2841 scan_compilation_units -- build a psymtab entry for each compilation
2845 This is the top level dwarf parsing routine for building partial
2848 It scans from the beginning of the DWARF table looking for the first
2849 TAG_compile_unit DIE, and then follows the sibling chain to locate
2850 each additional TAG_compile_unit DIE.
2852 For each TAG_compile_unit DIE it creates a partial symtab structure,
2853 calls a subordinate routine to collect all the compilation unit's
2854 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2855 new partial symtab structure into the partial symbol table. It also
2856 records the appropriate information in the partial symbol table entry
2857 to allow the chunk of DIE's and line number table for this compilation
2858 unit to be located and re-read later, to generate a complete symbol
2859 table entry for the compilation unit.
2861 Thus it effectively partitions up a chunk of DIE's for multiple
2862 compilation units into smaller DIE chunks and line number tables,
2863 and associates them with a partial symbol table entry.
2867 If any compilation unit has no line number table associated with
2868 it for some reason (a missing at_stmt_list attribute, rather than
2869 just one with a value of zero, which is valid) then we ensure that
2870 the recorded file offset is zero so that the routine which later
2871 reads line number table fragments knows that there is no fragment
2881 DEFUN(scan_compilation_units
,
2882 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2887 unsigned int dbfoff AND
2888 unsigned int lnoffset AND
2889 struct objfile
*objfile
)
2893 struct partial_symtab
*pst
;
2898 while (thisdie
< enddie
)
2900 basicdieinfo (&di
, thisdie
);
2901 if (di
.dielength
< sizeof (long))
2905 else if (di
.dietag
!= TAG_compile_unit
)
2907 nextdie
= thisdie
+ di
.dielength
;
2911 completedieinfo (&di
);
2912 if (di
.at_sibling
!= 0)
2914 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2918 nextdie
= thisdie
+ di
.dielength
;
2920 curoff
= thisdie
- dbbase
;
2921 culength
= nextdie
- thisdie
;
2922 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2923 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2924 di
.at_low_pc
+ addr
,
2925 di
.at_high_pc
+ addr
,
2926 dbfoff
, curoff
, culength
, curlnoffset
,
2927 global_psymbols
.next
,
2928 static_psymbols
.next
);
2929 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2930 pst
-> n_global_syms
= global_psymbols
.next
-
2931 (global_psymbols
.list
+ pst
-> globals_offset
);
2932 pst
-> n_static_syms
= static_psymbols
.next
-
2933 (static_psymbols
.list
+ pst
-> statics_offset
);
2934 /* Sort the global list; don't sort the static list */
2935 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2936 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2938 /* If there is already a psymtab or symtab for a file of this name,
2939 remove it. (If there is a symtab, more drastic things also
2940 happen.) This happens in VxWorks. */
2941 free_named_symtabs (pst
-> filename
);
2942 /* Place the partial symtab on the partial symtab list */
2943 pst
-> next
= partial_symtab_list
;
2944 partial_symtab_list
= pst
;
2954 new_symbol -- make a symbol table entry for a new symbol
2958 static struct symbol *new_symbol (struct dieinfo *dip)
2962 Given a pointer to a DWARF information entry, figure out if we need
2963 to make a symbol table entry for it, and if so, create a new entry
2964 and return a pointer to it.
2967 static struct symbol
*
2968 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2970 struct symbol
*sym
= NULL
;
2972 if (dip
-> at_name
!= NULL
)
2974 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2975 sizeof (struct symbol
));
2976 (void) memset (sym
, 0, sizeof (struct symbol
));
2977 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2978 /* default assumptions */
2979 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2980 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2981 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2982 switch (dip
-> dietag
)
2985 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2986 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2988 case TAG_global_subroutine
:
2989 case TAG_subroutine
:
2990 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2991 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2992 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2993 if (dip
-> dietag
== TAG_global_subroutine
)
2995 add_symbol_to_list (sym
, &global_symbols
);
2999 add_symbol_to_list (sym
, &scope
-> symbols
);
3002 case TAG_global_variable
:
3003 case TAG_local_variable
:
3004 if (dip
-> at_location
!= NULL
)
3006 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3008 if (dip
-> dietag
== TAG_global_variable
)
3010 add_symbol_to_list (sym
, &global_symbols
);
3011 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3012 SYMBOL_VALUE (sym
) += baseaddr
;
3016 add_symbol_to_list (sym
, &scope
-> symbols
);
3017 if (scope
-> parent
!= NULL
)
3021 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3025 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3030 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3031 SYMBOL_VALUE (sym
) += baseaddr
;
3035 case TAG_formal_parameter
:
3036 if (dip
-> at_location
!= NULL
)
3038 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
3040 add_symbol_to_list (sym
, &scope
-> symbols
);
3043 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3047 SYMBOL_CLASS (sym
) = LOC_ARG
;
3050 case TAG_unspecified_parameters
:
3051 /* From varargs functions; gdb doesn't seem to have any interest in
3052 this information, so just ignore it for now. (FIXME?) */
3054 case TAG_structure_type
:
3055 case TAG_union_type
:
3056 case TAG_enumeration_type
:
3057 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3058 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3059 add_symbol_to_list (sym
, &scope
-> symbols
);
3062 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3063 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3064 add_symbol_to_list (sym
, &scope
-> symbols
);
3067 /* Not a tag we recognize. Hopefully we aren't processing trash
3068 data, but since we must specifically ignore things we don't
3069 recognize, there is nothing else we should do at this point. */
3080 decode_mod_fund_type -- decode a modified fundamental type
3084 static struct type *decode_mod_fund_type (char *typedata)
3088 Decode a block of data containing a modified fundamental
3089 type specification. TYPEDATA is a pointer to the block,
3090 which consists of a two byte length, containing the size
3091 of the rest of the block. At the end of the block is a
3092 two byte value that gives the fundamental type. Everything
3093 in between are type modifiers.
3095 We simply compute the number of modifiers and call the general
3096 function decode_modified_type to do the actual work.
3099 static struct type
*
3100 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3102 struct type
*typep
= NULL
;
3103 unsigned short modcount
;
3104 unsigned char *modifiers
;
3106 /* Get the total size of the block, exclusive of the size itself */
3107 (void) memcpy (&modcount
, typedata
, sizeof (short));
3108 /* Deduct the size of the fundamental type bytes at the end of the block. */
3109 modcount
-= sizeof (short);
3110 /* Skip over the two size bytes at the beginning of the block. */
3111 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3112 /* Now do the actual decoding */
3113 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3121 decode_mod_u_d_type -- decode a modified user defined type
3125 static struct type *decode_mod_u_d_type (char *typedata)
3129 Decode a block of data containing a modified user defined
3130 type specification. TYPEDATA is a pointer to the block,
3131 which consists of a two byte length, containing the size
3132 of the rest of the block. At the end of the block is a
3133 four byte value that gives a reference to a user defined type.
3134 Everything in between are type modifiers.
3136 We simply compute the number of modifiers and call the general
3137 function decode_modified_type to do the actual work.
3140 static struct type
*
3141 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3143 struct type
*typep
= NULL
;
3144 unsigned short modcount
;
3145 unsigned char *modifiers
;
3147 /* Get the total size of the block, exclusive of the size itself */
3148 (void) memcpy (&modcount
, typedata
, sizeof (short));
3149 /* Deduct the size of the reference type bytes at the end of the block. */
3150 modcount
-= sizeof (long);
3151 /* Skip over the two size bytes at the beginning of the block. */
3152 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3153 /* Now do the actual decoding */
3154 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3162 decode_modified_type -- decode modified user or fundamental type
3166 static struct type *decode_modified_type (unsigned char *modifiers,
3167 unsigned short modcount, int mtype)
3171 Decode a modified type, either a modified fundamental type or
3172 a modified user defined type. MODIFIERS is a pointer to the
3173 block of bytes that define MODCOUNT modifiers. Immediately
3174 following the last modifier is a short containing the fundamental
3175 type or a long containing the reference to the user defined
3176 type. Which one is determined by MTYPE, which is either
3177 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3178 type we are generating.
3180 We call ourself recursively to generate each modified type,`
3181 until MODCOUNT reaches zero, at which point we have consumed
3182 all the modifiers and generate either the fundamental type or
3183 user defined type. When the recursion unwinds, each modifier
3184 is applied in turn to generate the full modified type.
3188 If we find a modifier that we don't recognize, and it is not one
3189 of those reserved for application specific use, then we issue a
3190 warning and simply ignore the modifier.
3194 We currently ignore MOD_const and MOD_volatile. (FIXME)
3198 static struct type
*
3199 DEFUN(decode_modified_type
,
3200 (modifiers
, modcount
, mtype
),
3201 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3203 struct type
*typep
= NULL
;
3204 unsigned short fundtype
;
3206 unsigned char modifier
;
3212 case AT_mod_fund_type
:
3213 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3214 typep
= decode_fund_type (fundtype
);
3216 case AT_mod_u_d_type
:
3217 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3218 if ((typep
= lookup_utype (dieref
)) == NULL
)
3220 typep
= alloc_utype (dieref
, NULL
);
3224 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3225 typep
= builtin_type_int
;
3231 modifier
= *modifiers
++;
3232 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3235 case MOD_pointer_to
:
3236 typep
= lookup_pointer_type (typep
);
3238 case MOD_reference_to
:
3239 typep
= lookup_reference_type (typep
);
3242 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3245 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3248 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3250 SQUAWK (("unknown type modifier %u", modifier
));
3262 decode_fund_type -- translate basic DWARF type to gdb base type
3266 Given an integer that is one of the fundamental DWARF types,
3267 translate it to one of the basic internal gdb types and return
3268 a pointer to the appropriate gdb type (a "struct type *").
3272 If we encounter a fundamental type that we are unprepared to
3273 deal with, and it is not in the range of those types defined
3274 as application specific types, then we issue a warning and
3275 treat the type as builtin_type_int.
3278 static struct type
*
3279 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3281 struct type
*typep
= NULL
;
3287 typep
= builtin_type_void
;
3290 case FT_pointer
: /* (void *) */
3291 typep
= lookup_pointer_type (builtin_type_void
);
3295 case FT_signed_char
:
3296 typep
= builtin_type_char
;
3300 case FT_signed_short
:
3301 typep
= builtin_type_short
;
3305 case FT_signed_integer
:
3306 case FT_boolean
: /* Was FT_set in AT&T version */
3307 typep
= builtin_type_int
;
3311 case FT_signed_long
:
3312 typep
= builtin_type_long
;
3316 typep
= builtin_type_float
;
3319 case FT_dbl_prec_float
:
3320 typep
= builtin_type_double
;
3323 case FT_unsigned_char
:
3324 typep
= builtin_type_unsigned_char
;
3327 case FT_unsigned_short
:
3328 typep
= builtin_type_unsigned_short
;
3331 case FT_unsigned_integer
:
3332 typep
= builtin_type_unsigned_int
;
3335 case FT_unsigned_long
:
3336 typep
= builtin_type_unsigned_long
;
3339 case FT_ext_prec_float
:
3340 typep
= builtin_type_long_double
;
3344 typep
= builtin_type_complex
;
3347 case FT_dbl_prec_complex
:
3348 typep
= builtin_type_double_complex
;
3352 case FT_signed_long_long
:
3353 typep
= builtin_type_long_long
;
3356 case FT_unsigned_long_long
:
3357 typep
= builtin_type_unsigned_long_long
;
3362 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3364 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3365 typep
= builtin_type_void
;
3375 create_name -- allocate a fresh copy of a string on an obstack
3379 Given a pointer to a string and a pointer to an obstack, allocates
3380 a fresh copy of the string on the specified obstack.
3385 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3390 length
= strlen (name
) + 1;
3391 newname
= (char *) obstack_alloc (obstackp
, length
);
3392 (void) strcpy (newname
, name
);
3400 basicdieinfo -- extract the minimal die info from raw die data
3404 void basicdieinfo (char *diep, struct dieinfo *dip)
3408 Given a pointer to raw DIE data, and a pointer to an instance of a
3409 die info structure, this function extracts the basic information
3410 from the DIE data required to continue processing this DIE, along
3411 with some bookkeeping information about the DIE.
3413 The information we absolutely must have includes the DIE tag,
3414 and the DIE length. If we need the sibling reference, then we
3415 will have to call completedieinfo() to process all the remaining
3418 Note that since there is no guarantee that the data is properly
3419 aligned in memory for the type of access required (indirection
3420 through anything other than a char pointer), we use memcpy to
3421 shuffle data items larger than a char. Possibly inefficient, but
3424 We also take care of some other basic things at this point, such
3425 as ensuring that the instance of the die info structure starts
3426 out completely zero'd and that curdie is initialized for use
3427 in error reporting if we have a problem with the current die.
3431 All DIE's must have at least a valid length, thus the minimum
3432 DIE size is sizeof (long). In order to have a valid tag, the
3433 DIE size must be at least sizeof (short) larger, otherwise they
3434 are forced to be TAG_padding DIES.
3436 Padding DIES must be at least sizeof(long) in length, implying that
3437 if a padding DIE is used for alignment and the amount needed is less
3438 than sizeof(long) then the padding DIE has to be big enough to align
3439 to the next alignment boundry.
3443 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3446 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3448 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3449 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3450 if (dip
-> dielength
< sizeof (long))
3452 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3454 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3456 dip
-> dietag
= TAG_padding
;
3460 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3468 completedieinfo -- finish reading the information for a given DIE
3472 void completedieinfo (struct dieinfo *dip)
3476 Given a pointer to an already partially initialized die info structure,
3477 scan the raw DIE data and finish filling in the die info structure
3478 from the various attributes found.
3480 Note that since there is no guarantee that the data is properly
3481 aligned in memory for the type of access required (indirection
3482 through anything other than a char pointer), we use memcpy to
3483 shuffle data items larger than a char. Possibly inefficient, but
3488 Each time we are called, we increment the diecount variable, which
3489 keeps an approximate count of the number of dies processed for
3490 each compilation unit. This information is presented to the user
3491 if the info_verbose flag is set.
3496 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3498 char *diep
; /* Current pointer into raw DIE data */
3499 char *end
; /* Terminate DIE scan here */
3500 unsigned short attr
; /* Current attribute being scanned */
3501 unsigned short form
; /* Form of the attribute */
3502 short block2sz
; /* Size of a block2 attribute field */
3503 long block4sz
; /* Size of a block4 attribute field */
3507 end
= diep
+ dip
-> dielength
;
3508 diep
+= sizeof (long) + sizeof (short);
3511 (void) memcpy (&attr
, diep
, sizeof (short));
3512 diep
+= sizeof (short);
3516 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3519 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3522 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3525 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3528 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3531 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3532 dip
-> has_at_stmt_list
= 1;
3535 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3536 dip
-> has_at_low_pc
= 1;
3539 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3542 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3544 case AT_user_def_type
:
3545 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3548 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3551 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3554 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3557 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3560 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3563 dip
-> at_location
= diep
;
3565 case AT_mod_fund_type
:
3566 dip
-> at_mod_fund_type
= diep
;
3568 case AT_subscr_data
:
3569 dip
-> at_subscr_data
= diep
;
3571 case AT_mod_u_d_type
:
3572 dip
-> at_mod_u_d_type
= diep
;
3574 case AT_element_list
:
3575 dip
-> at_element_list
= diep
;
3576 dip
-> short_element_list
= 0;
3578 case AT_short_element_list
:
3579 dip
-> at_element_list
= diep
;
3580 dip
-> short_element_list
= 1;
3582 case AT_discr_value
:
3583 dip
-> at_discr_value
= diep
;
3585 case AT_string_length
:
3586 dip
-> at_string_length
= diep
;
3589 dip
-> at_name
= diep
;
3592 dip
-> at_comp_dir
= diep
;
3595 dip
-> at_producer
= diep
;
3598 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3600 case AT_start_scope
:
3601 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3603 case AT_stride_size
:
3604 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3607 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3610 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3613 /* Found an attribute that we are unprepared to handle. However
3614 it is specifically one of the design goals of DWARF that
3615 consumers should ignore unknown attributes. As long as the
3616 form is one that we recognize (so we know how to skip it),
3617 we can just ignore the unknown attribute. */
3624 diep
+= sizeof (short);
3627 diep
+= sizeof (long);
3630 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3634 diep
+= sizeof (long);
3637 (void) memcpy (&block2sz
, diep
, sizeof (short));
3638 block2sz
+= sizeof (short);
3642 (void) memcpy (&block4sz
, diep
, sizeof (long));
3643 block4sz
+= sizeof (long);
3647 diep
+= strlen (diep
) + 1;
3650 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));