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. :-)
79 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
80 #define SQUAWK(stuff) dwarfwarn stuff
85 #ifndef R_FP /* FIXME */
86 #define R_FP 14 /* Kludge to get frame pointer register number */
89 typedef unsigned int DIEREF
; /* Reference to a DIE */
91 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
92 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
94 #define STREQ(a,b) (strcmp(a,b)==0)
96 extern CORE_ADDR entry_point
; /* Process entry point */
97 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
98 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
99 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
100 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
101 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
102 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
103 extern int info_verbose
; /* From main.c; nonzero => verbose */
106 /* The DWARF debugging information consists of two major pieces,
107 one is a block of DWARF Information Entries (DIE's) and the other
108 is a line number table. The "struct dieinfo" structure contains
109 the information for a single DIE, the one currently being processed.
111 In order to make it easier to randomly access the attribute fields
112 of the current DIE, which are specifically unordered within the DIE
113 each DIE is scanned and an instance of the "struct dieinfo"
114 structure is initialized.
116 Initialization is done in two levels. The first, done by basicdieinfo(),
117 just initializes those fields that are vital to deciding whether or not
118 to use this DIE, how to skip past it, etc. The second, done by the
119 function completedieinfo(), fills in the rest of the information.
121 Attributes which have block forms are not interpreted at the time
122 the DIE is scanned, instead we just save pointers to the start
123 of their value fields.
125 Some fields have a flag <name>_p that is set when the value of the
126 field is valid (I.E. we found a matching attribute in the DIE). Since
127 we may want to test for the presence of some attributes in the DIE,
128 such as AT_is_external, without restricting the values of the field,
129 we need someway to note that we found such an attribute.
136 char * die
; /* Pointer to the raw DIE data */
137 long dielength
; /* Length of the raw DIE data */
138 DIEREF dieref
; /* Offset of this DIE */
139 short dietag
; /* Tag for this DIE */
144 unsigned short at_fund_type
;
145 BLOCK
* at_mod_fund_type
;
146 long at_user_def_type
;
147 BLOCK
* at_mod_u_d_type
;
149 BLOCK
* at_subscr_data
;
153 BLOCK
* at_deriv_list
;
154 BLOCK
* at_element_list
;
161 BLOCK
* at_discr_value
;
164 BLOCK
* at_string_length
;
174 BLOCK
* at_const_data
;
175 short at_is_external
;
176 unsigned int at_is_external_p
:1;
177 unsigned int at_stmt_list_p
:1;
180 static int diecount
; /* Approximate count of dies for compilation unit */
181 static struct dieinfo
*curdie
; /* For warnings and such */
183 static char *dbbase
; /* Base pointer to dwarf info */
184 static int dbroff
; /* Relative offset from start of .debug section */
185 static char *lnbase
; /* Base pointer to line section */
186 static int isreg
; /* Kludge to identify register variables */
188 static CORE_ADDR baseaddr
; /* Add to each symbol value */
190 /* Each partial symbol table entry contains a pointer to private data for the
191 read_symtab() function to use when expanding a partial symbol table entry
192 to a full symbol table entry. For DWARF debugging info, this data is
193 contained in the following structure and macros are provided for easy
194 access to the members given a pointer to a partial symbol table entry.
196 dbfoff Always the absolute file offset to the start of the ".debug"
197 section for the file containing the DIE's being accessed.
199 dbroff Relative offset from the start of the ".debug" access to the
200 first DIE to be accessed. When building the partial symbol
201 table, this value will be zero since we are accessing the
202 entire ".debug" section. When expanding a partial symbol
203 table entry, this value will be the offset to the first
204 DIE for the compilation unit containing the symbol that
205 triggers the expansion.
207 dblength The size of the chunk of DIE's being examined, in bytes.
209 lnfoff The absolute file offset to the line table fragment. Ignored
210 when building partial symbol tables, but used when expanding
211 them, and contains the absolute file offset to the fragment
212 of the ".line" section containing the line numbers for the
213 current compilation unit.
217 int dbfoff
; /* Absolute file offset to start of .debug section */
218 int dbroff
; /* Relative offset from start of .debug section */
219 int dblength
; /* Size of the chunk of DIE's being examined */
220 int lnfoff
; /* Absolute file offset to line table fragment */
223 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
224 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
225 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
226 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
228 /* Record the symbols defined for each context in a linked list. We don't
229 create a struct block for the context until we know how long to make it.
230 Global symbols for each file are maintained in the global_symbols list. */
232 struct pending_symbol
{
233 struct pending_symbol
*next
; /* Next pending symbol */
234 struct symbol
*symbol
; /* The actual symbol */
237 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
238 static struct block
*global_symbol_block
;
240 /* Line number entries are read into a dynamically expandable vector before
241 being added to the symbol table section. Once we know how many there are
244 static struct linetable
*line_vector
; /* Vector of line numbers. */
245 static int line_vector_index
; /* Index of next entry. */
246 static int line_vector_length
; /* Current allocation limit */
248 /* Scope information is kept in a scope tree, one node per scope. Each time
249 a new scope is started, a child node is created under the current node
250 and set to the current scope. Each time a scope is closed, the current
251 scope moves back up the tree to the parent of the current scope.
253 Each scope contains a pointer to the list of symbols defined in the scope,
254 a pointer to the block vector for the scope, a pointer to the symbol
255 that names the scope (if any), and the range of PC values that mark
256 the start and end of the scope. */
259 struct scopenode
*parent
;
260 struct scopenode
*child
;
261 struct scopenode
*sibling
;
262 struct pending_symbol
*symbols
;
264 struct symbol
*namesym
;
269 static struct scopenode
*scopetree
;
270 static struct scopenode
*scope
;
272 /* DIES which have user defined types or modified user defined types refer to
273 other DIES for the type information. Thus we need to associate the offset
274 of a DIE for a user defined type with a pointer to the type information.
276 Originally this was done using a simple but expensive algorithm, with an
277 array of unsorted structures, each containing an offset/type-pointer pair.
278 This array was scanned linearly each time a lookup was done. The result
279 was that gdb was spending over half it's startup time munging through this
280 array of pointers looking for a structure that had the right offset member.
282 The second attempt used the same array of structures, but the array was
283 sorted using qsort each time a new offset/type was recorded, and a binary
284 search was used to find the type pointer for a given DIE offset. This was
285 even slower, due to the overhead of sorting the array each time a new
286 offset/type pair was entered.
288 The third attempt uses a fixed size array of type pointers, indexed by a
289 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
290 we can divide any DIE offset by 4 to obtain a unique index into this fixed
291 size array. Since each element is a 4 byte pointer, it takes exactly as
292 much memory to hold this array as to hold the DWARF info for a given
293 compilation unit. But it gets freed as soon as we are done with it. */
295 static struct type
**utypes
; /* Pointer to array of user type pointers */
296 static int numutypes
; /* Max number of user type pointers */
298 /* Forward declarations of static functions so we don't have to worry
299 about ordering within this file. The EXFUN macro may be slightly
300 misleading. Should probably be called DCLFUN instead, or something
301 more intuitive, since it can be used for both static and external
305 EXFUN (dwarfwarn
, (char *fmt DOTS
));
308 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
311 EXFUN (scan_compilation_units
,
312 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
313 AND
unsigned int dbfoff AND
unsigned int lnoffset
));
315 static struct partial_symtab
*
316 EXFUN(start_psymtab
, (char *symfile_name AND CORE_ADDR addr
317 AND
char *filename AND CORE_ADDR textlow
318 AND CORE_ADDR texthigh AND
int dbfoff
319 AND
int curoff AND
int culength AND
int lnfoff
320 AND
struct partial_symbol
*global_syms
321 AND
struct partial_symbol
*static_syms
));
323 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
326 EXFUN(add_psymbol_to_list
,
327 (struct psymbol_allocation_list
*listp AND
char *name
328 AND
enum namespace space AND
enum address_class
class
329 AND CORE_ADDR value
));
332 EXFUN(init_psymbol_list
, (int total_symbols
));
335 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
338 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
341 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
344 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst AND
int desc
));
346 static struct symtab
*
347 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst AND
int desc
));
350 EXFUN(process_dies
, (char *thisdie AND
char *enddie
));
353 EXFUN(read_lexical_block_scope
,
354 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
357 EXFUN(read_structure_scope
,
358 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
361 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
364 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
367 EXFUN(read_array_type
, (struct dieinfo
*dip
));
370 EXFUN(read_subroutine_type
,
371 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
374 EXFUN(read_enumeration
,
375 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
379 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
382 EXFUN(enum_type
, (struct dieinfo
*dip
));
385 EXFUN(read_func_scope
,
386 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
389 EXFUN(read_file_scope
,
390 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
393 EXFUN(start_symtab
, (void));
396 EXFUN(end_symtab
, (char *filename AND
long language
));
399 EXFUN(scopecount
, (struct scopenode
*node
));
403 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
406 EXFUN(freescope
, (struct scopenode
*node
));
408 static struct block
*
409 EXFUN(buildblock
, (struct pending_symbol
*syms
));
412 EXFUN(closescope
, (void));
415 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
418 EXFUN(decode_line_numbers
, (char *linetable
));
421 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
424 EXFUN(decode_mod_fund_type
, (char *typedata
));
427 EXFUN(decode_mod_u_d_type
, (char *typedata
));
430 EXFUN(decode_modified_type
,
431 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
434 EXFUN(decode_fund_type
, (unsigned short fundtype
));
437 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
440 EXFUN(add_symbol_to_list
,
441 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
443 static struct block
**
444 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
446 static struct blockvector
*
447 EXFUN(make_blockvector
, (void));
450 EXFUN(lookup_utype
, (DIEREF dieref
));
453 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
455 static struct symbol
*
456 EXFUN(new_symbol
, (struct dieinfo
*dip
));
459 EXFUN(locval
, (char *loc
));
462 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address
));
465 EXFUN(compare_psymbols
,
466 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
473 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
477 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
478 int mainline, unsigned int dbfoff, unsigned int dbsize,
479 unsigned int lnoffset, unsigned int lnsize)
483 This function is called upon to build partial symtabs from files
484 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
486 It is passed a file descriptor for an open file containing the DIES
487 and line number information, the corresponding filename for that
488 file, a base address for relocating the symbols, a flag indicating
489 whether or not this debugging information is from a "main symbol
490 table" rather than a shared library or dynamically linked file,
491 and file offset/size pairs for the DIE information and line number
501 DEFUN(dwarf_build_psymtabs
,
502 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
),
507 unsigned int dbfoff AND
508 unsigned int dbsize AND
509 unsigned int lnoffset AND
512 struct cleanup
*back_to
;
514 dbbase
= xmalloc (dbsize
);
516 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
517 (read (desc
, dbbase
, dbsize
) != dbsize
))
520 error ("can't read DWARF data from '%s'", filename
);
522 back_to
= make_cleanup (free
, dbbase
);
524 /* If we are reinitializing, or if we have never loaded syms yet, init.
525 Since we have no idea how many DIES we are looking at, we just guess
526 some arbitrary value. */
528 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
530 init_psymbol_list (1024);
533 init_misc_bunches ();
534 make_cleanup (discard_misc_bunches
, 0);
536 /* Follow the compilation unit sibling chain, building a partial symbol
537 table entry for each one. Save enough information about each compilation
538 unit to locate the full DWARF information later. */
540 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
543 /* Go over the miscellaneous functions and install them in the miscellaneous
546 condense_misc_bunches (!mainline
);
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)
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.
570 FIXME: For now we just use mf_text as the type. This should be
575 DEFUN(record_misc_function
, (name
, address
), char *name AND CORE_ADDR address
)
577 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
585 dwarfwarn -- issue a DWARF related warning
589 Issue warnings about DWARF related things that aren't serious enough
590 to warrant aborting with an error, but should not be ignored either.
591 This includes things like detectable corruption in DIE's, missing
592 DIE's, unimplemented features, etc.
594 In general, running across tags or attributes that we don't recognize
595 is not considered to be a problem and we should not issue warnings
600 We mostly follow the example of the error() routine, but without
601 returning to command level. It is arguable about whether warnings
602 should be issued at all, and if so, where they should go (stdout or
605 We assume that curdie is valid and contains at least the basic
606 information for the DIE where the problem was noticed.
617 fmt
= va_arg (ap
, char *);
619 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
620 if (curdie
-> at_name
)
622 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
624 vfprintf (stderr
, fmt
, ap
);
625 fprintf (stderr
, "\n");
634 compare_psymbols -- compare two partial symbols by name
638 Given pointer to two partial symbol table entries, compare
639 them by name and return -N, 0, or +N (ala strcmp). Typically
640 used by sorting routines like qsort().
644 This is a copy from dbxread.c. It should be moved to a generic
645 gdb file and made available for all psymtab builders (FIXME).
647 Does direct compare of first two characters before punting
648 and passing to strcmp for longer compares. Note that the
649 original version had a bug whereby two null strings or two
650 identically named one character strings would return the
651 comparison of memory following the null byte.
656 DEFUN(compare_psymbols
, (s1
, s2
),
657 struct partial_symbol
*s1 AND
658 struct partial_symbol
*s2
)
660 register char *st1
= SYMBOL_NAME (s1
);
661 register char *st2
= SYMBOL_NAME (s2
);
663 if ((st1
[0] - st2
[0]) || !st1
[0])
665 return (st1
[0] - st2
[0]);
667 else if ((st1
[1] - st2
[1]) || !st1
[1])
669 return (st1
[1] - st2
[1]);
673 return (strcmp (st1
+ 2, st2
+ 2));
681 read_lexical_block_scope -- process all dies in a lexical block
685 static void read_lexical_block_scope (struct dieinfo *dip,
686 char *thisdie, char *enddie)
690 Process all the DIES contained within a lexical block scope.
691 Start a new scope, process the dies, and then close the scope.
696 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
),
697 struct dieinfo
*dip AND
701 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
702 process_dies (thisdie
+ dip
-> dielength
, enddie
);
710 lookup_utype -- look up a user defined type from die reference
714 static type *lookup_utype (DIEREF dieref)
718 Given a DIE reference, lookup the user defined type associated with
719 that DIE, if it has been registered already. If not registered, then
720 return NULL. Alloc_utype() can be called to register an empty
721 type for this reference, which will be filled in later when the
722 actual referenced DIE is processed.
726 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
728 struct type
*type
= NULL
;
731 utypeidx
= (dieref
- dbroff
) / 4;
732 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
734 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
738 type
= *(utypes
+ utypeidx
);
748 alloc_utype -- add a user defined type for die reference
752 static type *alloc_utype (DIEREF dieref, struct type *utypep)
756 Given a die reference DIEREF, and a possible pointer to a user
757 defined type UTYPEP, register that this reference has a user
758 defined type and either use the specified type in UTYPEP or
759 make a new empty type that will be filled in later.
761 We should only be called after calling lookup_utype() to verify that
762 there is not currently a type registered for DIEREF.
766 DEFUN(alloc_utype
, (dieref
, utypep
),
773 utypeidx
= (dieref
- dbroff
) / 4;
774 typep
= utypes
+ utypeidx
;
775 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
777 utypep
= builtin_type_int
;
778 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
780 else if (*typep
!= NULL
)
783 SQUAWK (("internal error: dup user type allocation"));
789 utypep
= (struct type
*)
790 obstack_alloc (symbol_obstack
, sizeof (struct type
));
791 (void) memset (utypep
, 0, sizeof (struct type
));
802 decode_die_type -- return a type for a specified die
806 static struct type *decode_die_type (struct dieinfo *dip)
810 Given a pointer to a die information structure DIP, decode the
811 type of the die and return a pointer to the decoded type. All
812 dies without specific types default to type int.
816 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
818 struct type
*type
= NULL
;
820 if (dip
-> at_fund_type
!= 0)
822 type
= decode_fund_type (dip
-> at_fund_type
);
824 else if (dip
-> at_mod_fund_type
!= NULL
)
826 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
828 else if (dip
-> at_user_def_type
)
830 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
832 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
835 else if (dip
-> at_mod_u_d_type
)
837 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
841 type
= builtin_type_int
;
850 struct_type -- compute and return the type for a struct or union
854 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
859 Given pointer to a die information structure for a die which
860 defines a union or structure, and pointers to the raw die data
861 that define the range of dies which define the members, compute
862 and return the user defined type for the structure or union.
866 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
867 struct dieinfo
*dip AND
873 struct nextfield
*next
;
876 struct nextfield
*list
= NULL
;
877 struct nextfield
*new;
885 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
887 type
= alloc_utype (dip
-> dieref
, NULL
);
889 switch (dip
-> dietag
)
891 case TAG_structure_type
:
892 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
896 TYPE_CODE (type
) = TYPE_CODE_UNION
;
901 SQUAWK (("missing structure or union tag"));
902 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
905 if (dip
-> at_name
== NULL
)
911 tpart2
= dip
-> at_name
;
913 if (dip
-> at_byte_size
== 0)
915 tpart3
= " <opaque>";
917 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
920 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
);
921 thisdie
+= dip
-> dielength
;
922 while (thisdie
< enddie
)
924 basicdieinfo (&mbr
, thisdie
);
925 completedieinfo (&mbr
);
926 if (mbr
.dielength
<= sizeof (long))
933 /* Get space to record the next field's data. */
934 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
938 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
939 list
-> field
.type
= decode_die_type (&mbr
);
940 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
941 list
-> field
.bitsize
= 0;
945 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
948 thisdie
+= mbr
.dielength
;
950 /* Now create the vector of fields, and record how big it is. */
951 TYPE_NFIELDS (type
) = nfields
;
952 TYPE_FIELDS (type
) = (struct field
*)
953 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
954 /* Copy the saved-up fields into the field vector. */
955 for (n
= nfields
; list
; list
= list
-> next
)
957 TYPE_FIELD (type
, --n
) = list
-> field
;
966 read_structure_scope -- process all dies within struct or union
970 static void read_structure_scope (struct dieinfo *dip,
971 char *thisdie, char *enddie)
975 Called when we find the DIE that starts a structure or union
976 scope (definition) to process all dies that define the members
977 of the structure or union. DIP is a pointer to the die info
978 struct for the DIE that names the structure or union.
982 Note that we need to call struct_type regardless of whether or not
983 we have a symbol, since we might have a structure or union without
984 a tag name (thus no symbol for the tagname).
988 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
989 struct dieinfo
*dip AND
996 type
= struct_type (dip
, thisdie
, enddie
);
997 if ((sym
= new_symbol (dip
)) != NULL
)
999 SYMBOL_TYPE (sym
) = type
;
1007 decode_array_element_type -- decode type of the array elements
1011 static struct type *decode_array_element_type (char *scan, char *end)
1015 As the last step in decoding the array subscript information for an
1016 array DIE, we need to decode the type of the array elements. We are
1017 passed a pointer to this last part of the subscript information and
1018 must return the appropriate type. If the type attribute is not
1019 recognized, just warn about the problem and return type int.
1022 static struct type
*
1023 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1028 unsigned short fundtype
;
1030 (void) memcpy (&attribute
, scan
, sizeof (short));
1031 scan
+= sizeof (short);
1035 (void) memcpy (&fundtype
, scan
, sizeof (short));
1036 typep
= decode_fund_type (fundtype
);
1038 case AT_mod_fund_type
:
1039 typep
= decode_mod_fund_type (scan
);
1041 case AT_user_def_type
:
1042 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1043 if ((typep
= lookup_utype (dieref
)) == NULL
)
1045 typep
= alloc_utype (dieref
, NULL
);
1048 case AT_mod_u_d_type
:
1049 typep
= decode_mod_u_d_type (scan
);
1052 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1053 typep
= builtin_type_int
;
1063 decode_subscr_data -- decode array subscript and element type data
1067 static struct type *decode_subscr_data (char *scan, char *end)
1071 The array subscripts and the data type of the elements of an
1072 array are described by a list of data items, stored as a block
1073 of contiguous bytes. There is a data item describing each array
1074 dimension, and a final data item describing the element type.
1075 The data items are ordered the same as their appearance in the
1076 source (I.E. leftmost dimension first, next to leftmost second,
1079 We are passed a pointer to the start of the block of bytes
1080 containing the data items, and a pointer to the first byte past
1081 the data. This function decodes the data and returns a type.
1084 FIXME: This code only implements the forms currently used
1085 by the AT&T and GNU C compilers.
1087 The end pointer is supplied for error checking, maybe we should
1091 static struct type
*
1092 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1094 struct type
*typep
= NULL
;
1095 struct type
*nexttype
;
1105 typep
= decode_array_element_type (scan
, end
);
1108 (void) memcpy (&fundtype
, scan
, sizeof (short));
1109 scan
+= sizeof (short);
1110 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1111 && fundtype
!= FT_unsigned_integer
)
1113 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1118 (void) memcpy (&lowbound
, scan
, sizeof (long));
1119 scan
+= sizeof (long);
1120 (void) memcpy (&highbound
, scan
, sizeof (long));
1121 scan
+= sizeof (long);
1122 nexttype
= decode_subscr_data (scan
, end
);
1123 if (nexttype
!= NULL
)
1125 typep
= (struct type
*)
1126 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1127 (void) memset (typep
, 0, sizeof (struct type
));
1128 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1129 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1130 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1131 TYPE_TARGET_TYPE (typep
) = nexttype
;
1142 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1145 SQUAWK (("unknown array subscript format %x", format
));
1155 read_array_type -- read TAG_array_type DIE
1159 static void read_array_type (struct dieinfo *dip)
1163 Extract all information from a TAG_array_type DIE and add to
1164 the user defined type vector.
1168 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1175 if (dip
-> at_ordering
!= ORD_row_major
)
1177 /* FIXME: Can gdb even handle column major arrays? */
1178 SQUAWK (("array not row major; not handled correctly"));
1180 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1182 (void) memcpy (&temp
, sub
, sizeof (short));
1183 subend
= sub
+ sizeof (short) + temp
;
1184 sub
+= sizeof (short);
1185 type
= decode_subscr_data (sub
, subend
);
1188 type
= alloc_utype (dip
-> dieref
, NULL
);
1189 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1190 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1191 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1195 type
= alloc_utype (dip
-> dieref
, type
);
1204 read_subroutine_type -- process TAG_subroutine_type dies
1208 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1213 Handle DIES due to C code like:
1216 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1222 The parameter DIES are currently ignored. See if gdb has a way to
1223 include this info in it's type system, and decode them if so. Is
1224 this what the type structure's "arg_types" field is for? (FIXME)
1228 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1229 struct dieinfo
*dip AND
1235 type
= decode_die_type (dip
);
1236 type
= lookup_function_type (type
);
1237 type
= alloc_utype (dip
-> dieref
, type
);
1244 read_enumeration -- process dies which define an enumeration
1248 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1253 Given a pointer to a die which begins an enumeration, process all
1254 the dies that define the members of the enumeration.
1258 Note that we need to call enum_type regardless of whether or not we
1259 have a symbol, since we might have an enum without a tag name (thus
1260 no symbol for the tagname).
1264 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1265 struct dieinfo
*dip AND
1272 type
= enum_type (dip
);
1273 if ((sym
= new_symbol (dip
)) != NULL
)
1275 SYMBOL_TYPE (sym
) = type
;
1283 enum_type -- decode and return a type for an enumeration
1287 static type *enum_type (struct dieinfo *dip)
1291 Given a pointer to a die information structure for the die which
1292 starts an enumeration, process all the dies that define the members
1293 of the enumeration and return a type pointer for the enumeration.
1296 static struct type
*
1297 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1301 struct nextfield
*next
;
1304 struct nextfield
*list
= NULL
;
1305 struct nextfield
*new;
1315 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1317 type
= alloc_utype (dip
-> dieref
, NULL
);
1319 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1321 if (dip
-> at_name
== NULL
)
1325 tpart2
= dip
-> at_name
;
1327 if (dip
-> at_byte_size
== 0)
1329 tpart3
= " <opaque>";
1333 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1336 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
);
1337 if ((scan
= dip
-> at_element_list
) != NULL
)
1339 (void) memcpy (&temp
, scan
, sizeof (temp
));
1340 listend
= scan
+ temp
+ sizeof (temp
);
1341 scan
+= sizeof (temp
);
1342 while (scan
< listend
)
1344 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1347 list
-> field
.type
= NULL
;
1348 list
-> field
.bitsize
= 0;
1349 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1350 scan
+= sizeof (long);
1351 list
-> field
.name
= savestring (scan
, strlen (scan
));
1352 scan
+= strlen (scan
) + 1;
1356 /* Now create the vector of fields, and record how big it is. */
1357 TYPE_NFIELDS (type
) = nfields
;
1358 TYPE_FIELDS (type
) = (struct field
*)
1359 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1360 /* Copy the saved-up fields into the field vector. */
1361 for (n
= nfields
; list
; list
= list
-> next
)
1363 TYPE_FIELD (type
, --n
) = list
-> field
;
1372 read_func_scope -- process all dies within a function scope
1376 static void read_func_scope (struct dieinfo dip, char *thisdie,
1381 Process all dies within a given function scope. We are passed
1382 a die information structure pointer DIP for the die which
1383 starts the function scope, and pointers into the raw die data
1384 that define the dies within the function scope.
1386 For now, we ignore lexical block scopes within the function.
1387 The problem is that AT&T cc does not define a DWARF lexical
1388 block scope for the function itself, while gcc defines a
1389 lexical block scope for the function. We need to think about
1390 how to handle this difference, or if it is even a problem.
1395 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
),
1396 struct dieinfo
*dip AND
1402 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1404 entry_scope_lowpc
= dip
-> at_low_pc
;
1405 entry_scope_highpc
= dip
-> at_high_pc
;
1407 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1409 main_scope_lowpc
= dip
-> at_low_pc
;
1410 main_scope_highpc
= dip
-> at_high_pc
;
1412 sym
= new_symbol (dip
);
1413 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1414 process_dies (thisdie
+ dip
-> dielength
, enddie
);
1422 read_file_scope -- process all dies within a file scope
1426 static void read_file_scope (struct dieinfo *dip, char *thisdie
1431 Process all dies within a given file scope. We are passed a
1432 pointer to the die information structure for the die which
1433 starts the file scope, and pointers into the raw die data which
1434 mark the range of dies within the file scope.
1436 When the partial symbol table is built, the file offset for the line
1437 number table for each compilation unit is saved in the partial symbol
1438 table entry for that compilation unit. As the symbols for each
1439 compilation unit are read, the line number table is read into memory
1440 and the variable lnbase is set to point to it. Thus all we have to
1441 do is use lnbase to access the line number table for the current
1446 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
),
1447 struct dieinfo
*dip AND
1451 struct cleanup
*back_to
;
1453 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1455 startup_file_start
= dip
-> at_low_pc
;
1456 startup_file_end
= dip
-> at_high_pc
;
1458 numutypes
= (enddie
- thisdie
) / 4;
1459 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1460 back_to
= make_cleanup (free
, utypes
);
1461 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1463 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1464 decode_line_numbers (lnbase
);
1465 process_dies (thisdie
+ dip
-> dielength
, enddie
);
1467 end_symtab (dip
-> at_name
, dip
-> at_language
);
1468 do_cleanups (back_to
);
1477 start_symtab -- do initialization for starting new symbol table
1481 static void start_symtab (void)
1485 Called whenever we are starting to process dies for a new
1486 compilation unit, to perform initializations. Right now
1487 the only thing we really have to do is initialize storage
1488 space for the line number vector.
1493 DEFUN_VOID (start_symtab
)
1497 line_vector_index
= 0;
1498 line_vector_length
= 1000;
1499 nbytes
= sizeof (struct linetable
);
1500 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1501 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1508 process_dies -- process a range of DWARF Information Entries
1512 static void process_dies (char *thisdie, char *enddie)
1516 Process all DIE's in a specified range. May be (and almost
1517 certainly will be) called recursively.
1521 DEFUN(process_dies
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
1526 while (thisdie
< enddie
)
1528 basicdieinfo (&di
, thisdie
);
1529 if (di
.dielength
< sizeof (long))
1533 else if (di
.dietag
== TAG_padding
)
1535 nextdie
= thisdie
+ di
.dielength
;
1539 completedieinfo (&di
);
1540 if (di
.at_sibling
!= 0)
1542 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1546 nextdie
= thisdie
+ di
.dielength
;
1550 case TAG_compile_unit
:
1551 read_file_scope (&di
, thisdie
, nextdie
);
1553 case TAG_global_subroutine
:
1554 case TAG_subroutine
:
1555 if (!di
.at_is_external_p
)
1557 read_func_scope (&di
, thisdie
, nextdie
);
1560 case TAG_lexical_block
:
1561 read_lexical_block_scope (&di
, thisdie
, nextdie
);
1563 case TAG_structure_type
:
1564 case TAG_union_type
:
1565 read_structure_scope (&di
, thisdie
, nextdie
);
1567 case TAG_enumeration_type
:
1568 read_enumeration (&di
, thisdie
, nextdie
);
1570 case TAG_subroutine_type
:
1571 read_subroutine_type (&di
, thisdie
, nextdie
);
1573 case TAG_array_type
:
1574 read_array_type (&di
);
1577 (void) new_symbol (&di
);
1589 end_symtab -- finish processing for a compilation unit
1593 static void end_symtab (char *filename, long language)
1597 Complete the symbol table entry for the current compilation
1598 unit. Make the struct symtab and put it on the list of all
1604 DEFUN(end_symtab
, (filename
, language
), char *filename AND
long language
)
1606 struct symtab
*symtab
;
1607 struct blockvector
*blockvector
;
1610 /* Ignore a file that has no functions with real debugging info. */
1611 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1615 line_vector_length
= -1;
1616 freescope (scopetree
);
1617 scope
= scopetree
= NULL
;
1620 /* Create the blockvector that points to all the file's blocks. */
1622 blockvector
= make_blockvector ();
1624 /* Now create the symtab object for this source file. */
1626 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
1627 (void) memset (symtab
, 0, sizeof (struct symtab
));
1629 symtab
-> free_ptr
= 0;
1631 /* Fill in its components. */
1632 symtab
-> blockvector
= blockvector
;
1633 symtab
-> free_code
= free_linetable
;
1634 symtab
-> filename
= savestring (filename
, strlen (filename
));
1636 /* Save the line number information. */
1638 line_vector
-> nitems
= line_vector_index
;
1639 nbytes
= sizeof (struct linetable
);
1640 if (line_vector_index
> 1)
1642 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1644 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1645 symtab
-> nlines
= 0;
1646 symtab
-> line_charpos
= 0;
1648 /* FIXME: The following may need to be expanded for other languages */
1649 if (language
== LANG_C89
|| language
== LANG_C
)
1651 symtab
-> language
= language_c
;
1654 /* Link the new symtab into the list of such. */
1655 symtab
-> next
= symtab_list
;
1656 symtab_list
= symtab
;
1658 /* Recursively free the scope tree */
1659 freescope (scopetree
);
1660 scope
= scopetree
= NULL
;
1662 /* Reinitialize for beginning of new file. */
1664 line_vector_length
= -1;
1671 scopecount -- count the number of enclosed scopes
1675 static int scopecount (struct scopenode *node)
1679 Given pointer to a node, compute the size of the subtree which is
1680 rooted in this node, which also happens to be the number of scopes
1685 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1691 count
+= scopecount (node
-> child
);
1692 count
+= scopecount (node
-> sibling
);
1702 openscope -- start a new lexical block scope
1706 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1711 Start a new scope by allocating a new scopenode, adding it as the
1712 next child of the current scope (if any) or as the root of the
1713 scope tree, and then making the new node the current scope node.
1717 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1718 struct symbol
*namesym AND
1722 struct scopenode
*new;
1723 struct scopenode
*child
;
1725 new = (struct scopenode
*) xmalloc (sizeof (*new));
1726 (void) memset (new, 0, sizeof (*new));
1727 new -> namesym
= namesym
;
1728 new -> lowpc
= lowpc
;
1729 new -> highpc
= highpc
;
1734 else if ((child
= scope
-> child
) == NULL
)
1736 scope
-> child
= new;
1737 new -> parent
= scope
;
1741 while (child
-> sibling
!= NULL
)
1743 child
= child
-> sibling
;
1745 child
-> sibling
= new;
1746 new -> parent
= scope
;
1755 freescope -- free a scope tree rooted at the given node
1759 static void freescope (struct scopenode *node)
1763 Given a pointer to a node in the scope tree, free the subtree
1764 rooted at that node. First free all the children and sibling
1765 nodes, and then the node itself. Used primarily for cleaning
1766 up after ourselves and returning memory to the system.
1770 DEFUN(freescope
, (node
), struct scopenode
*node
)
1774 freescope (node
-> child
);
1775 freescope (node
-> sibling
);
1784 buildblock -- build a new block from pending symbols list
1788 static struct block *buildblock (struct pending_symbol *syms)
1792 Given a pointer to a list of symbols, build a new block and free
1793 the symbol list structure. Also check each symbol to see if it
1794 is the special symbol that flags that this block was compiled by
1795 gcc, and if so, mark the block appropriately.
1798 static struct block
*
1799 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1801 struct pending_symbol
*next
, *next1
;
1803 struct block
*newblock
;
1806 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1808 /* Allocate a new block */
1810 nbytes
= sizeof (struct block
);
1813 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1815 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1816 (void) memset (newblock
, 0, nbytes
);
1818 /* Copy the symbols into the block. */
1820 BLOCK_NSYMS (newblock
) = i
;
1821 for (next
= syms
; next
; next
= next
-> next
)
1823 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1824 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1825 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1827 BLOCK_GCC_COMPILED (newblock
) = 1;
1831 /* Now free the links of the list, and empty the list. */
1833 for (next
= syms
; next
; next
= next1
)
1835 next1
= next
-> next
;
1846 closescope -- close a lexical block scope
1850 static void closescope (void)
1854 Close the current lexical block scope. Closing the current scope
1855 is as simple as moving the current scope pointer up to the parent
1856 of the current scope pointer. But we also take this opportunity
1857 to build the block for the current scope first, since we now have
1858 all of it's symbols.
1862 DEFUN_VOID(closescope
)
1864 struct scopenode
*child
;
1868 error ("DWARF parse error, too many close scopes");
1872 if (scope
-> parent
== NULL
)
1874 global_symbol_block
= buildblock (global_symbols
);
1875 global_symbols
= NULL
;
1876 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1877 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1879 scope
-> block
= buildblock (scope
-> symbols
);
1880 scope
-> symbols
= NULL
;
1881 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1882 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1884 /* Put the local block in as the value of the symbol that names it. */
1886 if (scope
-> namesym
)
1888 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1889 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1892 /* Install this scope's local block as the superblock of all child
1895 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1897 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1900 scope
= scope
-> parent
;
1908 record_line -- record a line number entry in the line vector
1912 static void record_line (int line, CORE_ADDR pc)
1916 Given a line number and the corresponding pc value, record
1917 this pair in the line number vector, expanding the vector as
1922 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1924 struct linetable_entry
*e
;
1927 /* Make sure line vector is big enough. */
1929 if (line_vector_index
+ 2 >= line_vector_length
)
1931 line_vector_length
*= 2;
1932 nbytes
= sizeof (struct linetable
);
1933 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1934 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1936 e
= line_vector
-> item
+ line_vector_index
++;
1945 decode_line_numbers -- decode a line number table fragment
1949 static void decode_line_numbers (char *tblscan, char *tblend,
1950 long length, long base, long line, long pc)
1954 Translate the DWARF line number information to gdb form.
1956 The ".line" section contains one or more line number tables, one for
1957 each ".line" section from the objects that were linked.
1959 The AT_stmt_list attribute for each TAG_source_file entry in the
1960 ".debug" section contains the offset into the ".line" section for the
1961 start of the table for that file.
1963 The table itself has the following structure:
1965 <table length><base address><source statement entry>
1966 4 bytes 4 bytes 10 bytes
1968 The table length is the total size of the table, including the 4 bytes
1969 for the length information.
1971 The base address is the address of the first instruction generated
1972 for the source file.
1974 Each source statement entry has the following structure:
1976 <line number><statement position><address delta>
1977 4 bytes 2 bytes 4 bytes
1979 The line number is relative to the start of the file, starting with
1982 The statement position either -1 (0xFFFF) or the number of characters
1983 from the beginning of the line to the beginning of the statement.
1985 The address delta is the difference between the base address and
1986 the address of the first instruction for the statement.
1988 Note that we must copy the bytes from the packed table to our local
1989 variables before attempting to use them, to avoid alignment problems
1990 on some machines, particularly RISC processors.
1994 Does gdb expect the line numbers to be sorted? They are now by
1995 chance/luck, but are not required to be. (FIXME)
1997 The line with number 0 is unused, gdb apparently can discover the
1998 span of the last line some other way. How? (FIXME)
2002 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2011 if (linetable
!= NULL
)
2013 tblscan
= tblend
= linetable
;
2014 (void) memcpy (&length
, tblscan
, sizeof (long));
2015 tblscan
+= sizeof (long);
2017 (void) memcpy (&base
, tblscan
, sizeof (long));
2019 tblscan
+= sizeof (long);
2020 while (tblscan
< tblend
)
2022 (void) memcpy (&line
, tblscan
, sizeof (long));
2023 tblscan
+= sizeof (long) + sizeof (short);
2024 (void) memcpy (&pc
, tblscan
, sizeof (long));
2025 tblscan
+= sizeof (long);
2029 record_line (line
, pc
);
2039 add_symbol_to_list -- add a symbol to head of current symbol list
2043 static void add_symbol_to_list (struct symbol *symbol, struct
2044 pending_symbol **listhead)
2048 Given a pointer to a symbol and a pointer to a pointer to a
2049 list of symbols, add this symbol as the current head of the
2050 list. Typically used for example to add a symbol to the
2051 symbol list for the current scope.
2056 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2057 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2059 struct pending_symbol
*link
;
2063 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2064 link
-> next
= *listhead
;
2065 link
-> symbol
= symbol
;
2074 gatherblocks -- walk a scope tree and build block vectors
2078 static struct block **gatherblocks (struct block **dest,
2079 struct scopenode *node)
2083 Recursively walk a scope tree rooted in the given node, adding blocks
2084 to the array pointed to by DEST, in preorder. I.E., first we add the
2085 block for the current scope, then all the blocks for child scopes,
2086 and finally all the blocks for sibling scopes.
2089 static struct block
**
2090 DEFUN(gatherblocks
, (dest
, node
),
2091 struct block
**dest AND
struct scopenode
*node
)
2095 *dest
++ = node
-> block
;
2096 dest
= gatherblocks (dest
, node
-> child
);
2097 dest
= gatherblocks (dest
, node
-> sibling
);
2106 make_blockvector -- make a block vector from current scope tree
2110 static struct blockvector *make_blockvector (void)
2114 Make a blockvector from all the blocks in the current scope tree.
2115 The first block is always the global symbol block, followed by the
2116 block for the root of the scope tree which is the local symbol block,
2117 followed by all the remaining blocks in the scope tree, which are all
2122 Note that since the root node of the scope tree is created at the time
2123 each file scope is entered, there are always at least two blocks,
2124 neither of which may have any symbols, but always contribute a block
2125 to the block vector. So the test for number of blocks greater than 1
2126 below is unnecessary given bug free code.
2128 The resulting block structure varies slightly from that produced
2129 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2130 with dbxread.c, block 1 is a child of block 0. This does not
2131 seem to cause any problems, but probably should be fixed. (FIXME)
2134 static struct blockvector
*
2135 DEFUN_VOID(make_blockvector
)
2137 struct blockvector
*blockvector
= NULL
;
2141 /* Recursively walk down the tree, counting the number of blocks.
2142 Then add one to account for the global's symbol block */
2144 i
= scopecount (scopetree
) + 1;
2145 nbytes
= sizeof (struct blockvector
);
2148 nbytes
+= (i
- 1) * sizeof (struct block
*);
2150 blockvector
= (struct blockvector
*)
2151 obstack_alloc (symbol_obstack
, nbytes
);
2153 /* Copy the blocks into the blockvector. */
2155 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2156 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2157 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2159 return (blockvector
);
2166 locval -- compute the value of a location attribute
2170 static int locval (char *loc)
2174 Given pointer to a string of bytes that define a location, compute
2175 the location and return the value.
2177 When computing values involving the current value of the frame pointer,
2178 the value zero is used, which results in a value relative to the frame
2179 pointer, rather than the absolute value. This is what GDB wants
2182 When the result is a register number, the global isreg flag is set,
2183 otherwise it is cleared. This is a kludge until we figure out a better
2184 way to handle the problem. Gdb's design does not mesh well with the
2185 DWARF notion of a location computing interpreter, which is a shame
2186 because the flexibility goes unused.
2190 Note that stack[0] is unused except as a default error return.
2191 Note that stack overflow is not yet handled.
2195 DEFUN(locval
, (loc
), char *loc
)
2197 unsigned short nbytes
;
2203 (void) memcpy (&nbytes
, loc
, sizeof (short));
2204 end
= loc
+ sizeof (short) + nbytes
;
2208 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2216 /* push register (number) */
2217 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2221 /* push value of register (number) */
2222 /* Actually, we compute the value as if register has 0 */
2223 (void) memcpy (®no
, loc
, sizeof (long));
2226 stack
[++stacki
] = 0;
2230 stack
[++stacki
] = 0;
2231 SQUAWK (("BASEREG %d not handled!", regno
));
2235 /* push address (relocated address) */
2236 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2239 /* push constant (number) */
2240 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2243 /* pop, deref and push 2 bytes (as a long) */
2244 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2246 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2247 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2249 case OP_ADD
: /* pop top 2 items, add, push result */
2250 stack
[stacki
- 1] += stack
[stacki
];
2255 return (stack
[stacki
]);
2262 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2266 static struct symtab *read_ofile_symtab (struct partial_symtab *pst,
2271 DESC is the file descriptor for the file, positioned at the
2272 beginning of the symtab
2273 SYM_SIZE is the size of the symbol section to read
2274 TEXT_OFFSET is the beginning of the text segment we are reading
2276 TEXT_SIZE is the size of the text segment read in.
2277 OFFSET is a relocation offset which gets added to each symbol
2281 static struct symtab
*
2282 DEFUN(read_ofile_symtab
, (pst
, desc
),
2283 struct partial_symtab
*pst AND
2286 struct cleanup
*back_to
;
2290 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2291 unit, seek to the location in the file, and read in all the DIE's. */
2294 dbbase
= xmalloc (DBLENGTH(pst
));
2295 dbroff
= DBROFF(pst
);
2296 foffset
= DBFOFF(pst
) + dbroff
;
2297 if ((lseek (desc
, foffset
, 0) != foffset
) ||
2298 (read (desc
, dbbase
, DBLENGTH(pst
)) != DBLENGTH(pst
)))
2301 error ("can't read DWARF data");
2303 back_to
= make_cleanup (free
, dbbase
);
2305 /* If there is a line number table associated with this compilation unit
2306 then read the first long word from the line number table fragment, which
2307 contains the size of the fragment in bytes (including the long word
2308 itself). Allocate a buffer for the fragment and read it in for future
2314 if ((lseek (desc
, LNFOFF (pst
), 0) != LNFOFF (pst
)) ||
2315 (read (desc
, &lnsize
, sizeof(long)) != sizeof(long)))
2317 error ("can't read DWARF line number table size");
2319 lnbase
= xmalloc (lnsize
);
2320 if ((lseek (desc
, LNFOFF (pst
), 0) != LNFOFF (pst
)) ||
2321 (read (desc
, lnbase
, lnsize
) != lnsize
))
2324 error ("can't read DWARF line numbers");
2326 make_cleanup (free
, lnbase
);
2329 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
));
2330 do_cleanups (back_to
);
2331 return (symtab_list
);
2338 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2342 static void psymtab_to_symtab_1 (struct partial_symtab *pst, int desc)
2346 Called once for each partial symbol table entry that needs to be
2347 expanded into a full symbol table entry.
2352 DEFUN(psymtab_to_symtab_1
,
2354 struct partial_symtab
*pst AND
2365 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2370 /* Read in all partial symtabs on which this one is dependent */
2371 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2372 if (!pst
-> dependencies
[i
] -> readin
)
2374 /* Inform about additional files that need to be read in. */
2377 fputs_filtered (" ", stdout
);
2379 fputs_filtered ("and ", stdout
);
2381 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2382 wrap_here (""); /* Flush output */
2385 psymtab_to_symtab_1 (pst
-> dependencies
[i
], desc
);
2388 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2390 /* Init stuff necessary for reading in symbols */
2391 pst
-> symtab
= read_ofile_symtab (pst
, desc
);
2394 printf_filtered ("%d DIE's, sorting...", diecount
);
2397 sort_symtab_syms (pst
-> symtab
);
2406 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2410 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2414 This is the DWARF support entry point for building a full symbol
2415 table entry from a partial symbol table entry. We are passed a
2416 pointer to the partial symbol table entry that needs to be expanded.
2421 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2424 struct cleanup
*old_chain
;
2433 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2438 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2440 /* Print the message now, before starting serious work, to avoid
2441 disconcerting pauses. */
2444 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2448 /* Open symbol file. Symbol_file_command guarantees that the symbol
2449 file name will be absolute, so there is no need for openp. */
2450 desc
= open (pst
-> symfile_name
, O_RDONLY
, 0);
2454 perror_with_name (pst
-> symfile_name
);
2457 sym_bfd
= bfd_fdopenr (pst
-> symfile_name
, NULL
, desc
);
2460 (void) close (desc
);
2461 error ("Could not open `%s' to read symbols: %s",
2462 pst
-> symfile_name
, bfd_errmsg (bfd_error
));
2464 old_chain
= make_cleanup (bfd_close
, sym_bfd
);
2465 if (!bfd_check_format (sym_bfd
, bfd_object
))
2467 error ("\"%s\": can't read symbols: %s.",
2468 pst
-> symfile_name
, bfd_errmsg (bfd_error
));
2471 psymtab_to_symtab_1 (pst
, desc
);
2473 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2474 we need to do an equivalent or is this something peculiar to
2475 stabs/a.out format. */
2476 /* Match with global symbols. This only needs to be done once,
2477 after all of the symtabs and dependencies have been read in. */
2478 scan_file_globals ();
2481 do_cleanups (old_chain
);
2483 /* Finish up the debug error message. */
2486 printf_filtered ("done.\n");
2495 init_psymbol_list -- initialize storage for partial symbols
2499 static void init_psymbol_list (int total_symbols)
2503 Initializes storage for all of the partial symbols that will be
2504 created by dwarf_build_psymtabs and subsidiaries.
2508 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2510 /* Free any previously allocated psymbol lists. */
2512 if (global_psymbols
.list
)
2514 free (global_psymbols
.list
);
2516 if (static_psymbols
.list
)
2518 free (static_psymbols
.list
);
2521 /* Current best guess is that there are approximately a twentieth
2522 of the total symbols (in a debugging file) are global or static
2525 global_psymbols
.size
= total_symbols
/ 10;
2526 static_psymbols
.size
= total_symbols
/ 10;
2527 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2528 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2529 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2530 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2537 start_psymtab -- allocate and partially fill a partial symtab entry
2541 Allocate and partially fill a partial symtab. It will be completely
2542 filled at the end of the symbol list.
2544 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2545 ADDR is the address relative to which its symbols are (incremental)
2546 or 0 (normal). FILENAME is the name of the compilation unit that
2547 these symbols were defined in, and they appear starting a address
2548 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2549 the full symbols can be read for compilation unit FILENAME.
2550 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2555 static struct partial_symtab
*
2556 DEFUN(start_psymtab
,
2557 (symfile_name
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2558 culength
, lnfoff
, global_syms
, static_syms
),
2559 char *symfile_name AND
2562 CORE_ADDR textlow AND
2563 CORE_ADDR texthigh AND
2568 struct partial_symbol
*global_syms AND
2569 struct partial_symbol
*static_syms
)
2571 struct partial_symtab
*result
;
2573 result
= (struct partial_symtab
*)
2574 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2575 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2576 result
-> addr
= addr
;
2577 result
-> symfile_name
= create_name (symfile_name
, psymbol_obstack
);
2578 result
-> filename
= create_name (filename
, psymbol_obstack
);
2579 result
-> textlow
= textlow
;
2580 result
-> texthigh
= texthigh
;
2581 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2582 sizeof (struct dwfinfo
));
2583 DBFOFF (result
) = dbfoff
;
2584 DBROFF (result
) = curoff
;
2585 DBLENGTH (result
) = culength
;
2586 LNFOFF (result
) = lnfoff
;
2587 result
-> readin
= 0;
2588 result
-> symtab
= NULL
;
2589 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2590 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2591 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2593 result
->n_global_syms
= 0;
2594 result
->n_static_syms
= 0;
2603 add_psymbol_to_list -- add a partial symbol to given list
2607 Add a partial symbol to one of the partial symbol vectors (pointed to
2608 by listp). The vector is grown as necessary.
2613 DEFUN(add_psymbol_to_list
,
2614 (listp
, name
, space
, class, value
),
2615 struct psymbol_allocation_list
*listp AND
2617 enum namespace space AND
2618 enum address_class
class AND
2621 struct partial_symbol
*psym
;
2624 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2626 newsize
= listp
-> size
* 2;
2627 listp
-> list
= (struct partial_symbol
*)
2628 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2629 /* Next assumes we only went one over. Should be good if program works
2631 listp
-> next
= listp
-> list
+ listp
-> size
;
2632 listp
-> size
= newsize
;
2634 psym
= listp
-> next
++;
2635 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2636 SYMBOL_NAMESPACE (psym
) = space
;
2637 SYMBOL_CLASS (psym
) = class;
2638 SYMBOL_VALUE (psym
) = value
;
2645 add_partial_symbol -- add symbol to partial symbol table
2649 Given a DIE, if it is one of the types that we want to
2650 add to a partial symbol table, finish filling in the die info
2651 and then add a partial symbol table entry for it.
2656 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2658 switch (dip
-> dietag
)
2660 case TAG_global_subroutine
:
2661 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
);
2662 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2663 LOC_BLOCK
, dip
-> at_low_pc
);
2665 case TAG_global_variable
:
2666 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2669 case TAG_subroutine
:
2670 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2671 LOC_BLOCK
, dip
-> at_low_pc
);
2673 case TAG_local_variable
:
2674 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2678 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2681 case TAG_structure_type
:
2682 case TAG_union_type
:
2683 case TAG_enumeration_type
:
2684 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2694 scan_partial_symbols -- scan DIE's within a single compilation unit
2698 Process the DIE's within a single compilation unit, looking for
2699 interesting DIE's that contribute to the partial symbol table entry
2700 for this compilation unit. Since we cannot follow any sibling
2701 chains without reading the complete DIE info for every DIE,
2702 it is probably faster to just sequentially check each one to
2703 see if it is one of the types we are interested in, and if
2704 so, then extracting all the attributes info and generating a
2705 partial symbol table entry.
2710 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2715 while (thisdie
< enddie
)
2717 basicdieinfo (&di
, thisdie
);
2718 if (di
.dielength
< sizeof (long))
2724 nextdie
= thisdie
+ di
.dielength
;
2727 case TAG_global_subroutine
:
2728 case TAG_global_variable
:
2729 case TAG_subroutine
:
2730 case TAG_local_variable
:
2732 case TAG_structure_type
:
2733 case TAG_union_type
:
2734 case TAG_enumeration_type
:
2735 completedieinfo (&di
);
2736 /* Don't attempt to add anonymous structures, unions, or
2737 enumerations since they have no name. Also check that
2738 this is the place where the actual definition occurs,
2739 rather than just a reference to an external. */
2740 if (di
.at_name
!= NULL
&& !di
.at_is_external_p
)
2742 add_partial_symbol (&di
);
2755 scan_compilation_units -- build a psymtab entry for each compilation
2759 This is the top level dwarf parsing routine for building partial
2762 It scans from the beginning of the DWARF table looking for the first
2763 TAG_compile_unit DIE, and then follows the sibling chain to locate
2764 each additional TAG_compile_unit DIE.
2766 For each TAG_compile_unit DIE it creates a partial symtab structure,
2767 calls a subordinate routine to collect all the compilation unit's
2768 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2769 new partial symtab structure into the partial symbol table. It also
2770 records the appropriate information in the partial symbol table entry
2771 to allow the chunk of DIE's and line number table for this compilation
2772 unit to be located and re-read later, to generate a complete symbol
2773 table entry for the compilation unit.
2775 Thus it effectively partitions up a chunk of DIE's for multiple
2776 compilation units into smaller DIE chunks and line number tables,
2777 and associates them with a partial symbol table entry.
2781 If any compilation unit has no line number table associated with
2782 it for some reason (a missing at_stmt_list attribute, rather than
2783 just one with a value of zero, which is valid) then we ensure that
2784 the recorded file offset is zero so that the routine which later
2785 reads line number table fragments knows that there is no fragment
2795 DEFUN(scan_compilation_units
,
2796 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
),
2801 unsigned int dbfoff AND
2802 unsigned int lnoffset
)
2806 struct partial_symtab
*pst
;
2811 while (thisdie
< enddie
)
2813 basicdieinfo (&di
, thisdie
);
2814 if (di
.dielength
< sizeof (long))
2818 else if (di
.dietag
!= TAG_compile_unit
)
2820 nextdie
= thisdie
+ di
.dielength
;
2824 completedieinfo (&di
);
2825 if (di
.at_sibling
!= 0)
2827 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2831 nextdie
= thisdie
+ di
.dielength
;
2833 curoff
= thisdie
- dbbase
;
2834 culength
= nextdie
- thisdie
;
2835 curlnoffset
= di
.at_stmt_list_p
? lnoffset
+ di
.at_stmt_list
: 0;
2836 pst
= start_psymtab (filename
, addr
, di
.at_name
,
2837 di
.at_low_pc
, di
.at_high_pc
,
2838 dbfoff
, curoff
, culength
, curlnoffset
,
2839 global_psymbols
.next
,
2840 static_psymbols
.next
);
2841 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2842 pst
-> n_global_syms
= global_psymbols
.next
-
2843 (global_psymbols
.list
+ pst
-> globals_offset
);
2844 pst
-> n_static_syms
= static_psymbols
.next
-
2845 (static_psymbols
.list
+ pst
-> statics_offset
);
2846 /* Sort the global list; don't sort the static list */
2847 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2848 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2850 /* If there is already a psymtab or symtab for a file of this name,
2851 remove it. (If there is a symtab, more drastic things also
2852 happen.) This happens in VxWorks. */
2853 free_named_symtabs (pst
-> filename
);
2854 /* Place the partial symtab on the partial symtab list */
2855 pst
-> next
= partial_symtab_list
;
2856 partial_symtab_list
= pst
;
2866 new_symbol -- make a symbol table entry for a new symbol
2870 static struct symbol *new_symbol (struct dieinfo *dip)
2874 Given a pointer to a DWARF information entry, figure out if we need
2875 to make a symbol table entry for it, and if so, create a new entry
2876 and return a pointer to it.
2879 static struct symbol
*
2880 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2882 struct symbol
*sym
= NULL
;
2884 if (dip
-> at_name
!= NULL
)
2886 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2887 sizeof (struct symbol
));
2888 (void) memset (sym
, 0, sizeof (struct symbol
));
2889 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2890 /* default assumptions */
2891 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2892 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2893 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2894 switch (dip
-> dietag
)
2897 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2898 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2900 case TAG_global_subroutine
:
2901 case TAG_subroutine
:
2902 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2903 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2904 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2905 if (dip
-> dietag
== TAG_global_subroutine
)
2907 add_symbol_to_list (sym
, &global_symbols
);
2911 add_symbol_to_list (sym
, &scope
-> symbols
);
2914 case TAG_global_variable
:
2915 case TAG_local_variable
:
2916 if (dip
-> at_location
!= NULL
)
2918 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2920 if (dip
-> dietag
== TAG_global_variable
)
2922 add_symbol_to_list (sym
, &global_symbols
);
2923 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2924 SYMBOL_VALUE (sym
) += baseaddr
;
2928 add_symbol_to_list (sym
, &scope
-> symbols
);
2929 if (scope
-> parent
!= NULL
)
2933 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2937 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2942 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2943 SYMBOL_VALUE (sym
) += baseaddr
;
2947 case TAG_formal_parameter
:
2948 if (dip
-> at_location
!= NULL
)
2950 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2952 add_symbol_to_list (sym
, &scope
-> symbols
);
2955 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2959 SYMBOL_CLASS (sym
) = LOC_ARG
;
2962 case TAG_unspecified_parameters
:
2963 /* From varargs functions; gdb doesn't seem to have any interest in
2964 this information, so just ignore it for now. (FIXME?) */
2966 case TAG_structure_type
:
2967 case TAG_union_type
:
2968 case TAG_enumeration_type
:
2969 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2970 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2971 add_symbol_to_list (sym
, &scope
-> symbols
);
2974 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2975 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2976 add_symbol_to_list (sym
, &scope
-> symbols
);
2979 /* Not a tag we recognize. Hopefully we aren't processing trash
2980 data, but since we must specifically ignore things we don't
2981 recognize, there is nothing else we should do at this point. */
2992 decode_mod_fund_type -- decode a modified fundamental type
2996 static struct type *decode_mod_fund_type (char *typedata)
3000 Decode a block of data containing a modified fundamental
3001 type specification. TYPEDATA is a pointer to the block,
3002 which consists of a two byte length, containing the size
3003 of the rest of the block. At the end of the block is a
3004 two byte value that gives the fundamental type. Everything
3005 in between are type modifiers.
3007 We simply compute the number of modifiers and call the general
3008 function decode_modified_type to do the actual work.
3011 static struct type
*
3012 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3014 struct type
*typep
= NULL
;
3015 unsigned short modcount
;
3016 unsigned char *modifiers
;
3018 /* Get the total size of the block, exclusive of the size itself */
3019 (void) memcpy (&modcount
, typedata
, sizeof (short));
3020 /* Deduct the size of the fundamental type bytes at the end of the block. */
3021 modcount
-= sizeof (short);
3022 /* Skip over the two size bytes at the beginning of the block. */
3023 modifiers
= typedata
+ sizeof (short);
3024 /* Now do the actual decoding */
3025 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3033 decode_mod_u_d_type -- decode a modified user defined type
3037 static struct type *decode_mod_u_d_type (char *typedata)
3041 Decode a block of data containing a modified user defined
3042 type specification. TYPEDATA is a pointer to the block,
3043 which consists of a two byte length, containing the size
3044 of the rest of the block. At the end of the block is a
3045 four byte value that gives a reference to a user defined type.
3046 Everything in between are type modifiers.
3048 We simply compute the number of modifiers and call the general
3049 function decode_modified_type to do the actual work.
3052 static struct type
*
3053 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3055 struct type
*typep
= NULL
;
3056 unsigned short modcount
;
3057 unsigned char *modifiers
;
3059 /* Get the total size of the block, exclusive of the size itself */
3060 (void) memcpy (&modcount
, typedata
, sizeof (short));
3061 /* Deduct the size of the reference type bytes at the end of the block. */
3062 modcount
-= sizeof (long);
3063 /* Skip over the two size bytes at the beginning of the block. */
3064 modifiers
= typedata
+ sizeof (short);
3065 /* Now do the actual decoding */
3066 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3074 decode_modified_type -- decode modified user or fundamental type
3078 static struct type *decode_modified_type (unsigned char *modifiers,
3079 unsigned short modcount, int mtype)
3083 Decode a modified type, either a modified fundamental type or
3084 a modified user defined type. MODIFIERS is a pointer to the
3085 block of bytes that define MODCOUNT modifiers. Immediately
3086 following the last modifier is a short containing the fundamental
3087 type or a long containing the reference to the user defined
3088 type. Which one is determined by MTYPE, which is either
3089 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3090 type we are generating.
3092 We call ourself recursively to generate each modified type,`
3093 until MODCOUNT reaches zero, at which point we have consumed
3094 all the modifiers and generate either the fundamental type or
3095 user defined type. When the recursion unwinds, each modifier
3096 is applied in turn to generate the full modified type.
3100 If we find a modifier that we don't recognize, and it is not one
3101 of those reserved for application specific use, then we issue a
3102 warning and simply ignore the modifier.
3106 We currently ignore MOD_const and MOD_volatile. (FIXME)
3110 static struct type
*
3111 DEFUN(decode_modified_type
,
3112 (modifiers
, modcount
, mtype
),
3113 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3115 struct type
*typep
= NULL
;
3116 unsigned short fundtype
;
3118 unsigned char modifier
;
3124 case AT_mod_fund_type
:
3125 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3126 typep
= decode_fund_type (fundtype
);
3128 case AT_mod_u_d_type
:
3129 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3130 if ((typep
= lookup_utype (dieref
)) == NULL
)
3132 typep
= alloc_utype (dieref
, NULL
);
3136 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3137 typep
= builtin_type_int
;
3143 modifier
= *modifiers
++;
3144 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3147 case MOD_pointer_to
:
3148 typep
= lookup_pointer_type (typep
);
3150 case MOD_reference_to
:
3151 typep
= lookup_reference_type (typep
);
3154 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3157 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3160 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3162 SQUAWK (("unknown type modifier %u", modifier
));
3174 decode_fund_type -- translate basic DWARF type to gdb base type
3178 Given an integer that is one of the fundamental DWARF types,
3179 translate it to one of the basic internal gdb types and return
3180 a pointer to the appropriate gdb type (a "struct type *").
3184 If we encounter a fundamental type that we are unprepared to
3185 deal with, and it is not in the range of those types defined
3186 as application specific types, then we issue a warning and
3187 treat the type as builtin_type_int.
3190 static struct type
*
3191 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3193 struct type
*typep
= NULL
;
3199 typep
= builtin_type_void
;
3202 case FT_pointer
: /* (void *) */
3203 typep
= lookup_pointer_type (builtin_type_void
);
3207 case FT_signed_char
:
3208 typep
= builtin_type_char
;
3212 case FT_signed_short
:
3213 typep
= builtin_type_short
;
3217 case FT_signed_integer
:
3218 case FT_boolean
: /* Was FT_set in AT&T version */
3219 typep
= builtin_type_int
;
3223 case FT_signed_long
:
3224 typep
= builtin_type_long
;
3228 typep
= builtin_type_float
;
3231 case FT_dbl_prec_float
:
3232 typep
= builtin_type_double
;
3235 case FT_unsigned_char
:
3236 typep
= builtin_type_unsigned_char
;
3239 case FT_unsigned_short
:
3240 typep
= builtin_type_unsigned_short
;
3243 case FT_unsigned_integer
:
3244 typep
= builtin_type_unsigned_int
;
3247 case FT_unsigned_long
:
3248 typep
= builtin_type_unsigned_long
;
3251 case FT_ext_prec_float
:
3252 typep
= builtin_type_long_double
;
3256 typep
= builtin_type_complex
;
3259 case FT_dbl_prec_complex
:
3260 typep
= builtin_type_double_complex
;
3264 case FT_signed_long_long
:
3265 typep
= builtin_type_long_long
;
3268 case FT_unsigned_long_long
:
3269 typep
= builtin_type_unsigned_long_long
;
3274 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3276 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3277 typep
= builtin_type_void
;
3287 create_name -- allocate a fresh copy of a string on an obstack
3291 Given a pointer to a string and a pointer to an obstack, allocates
3292 a fresh copy of the string on the specified obstack.
3297 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3302 length
= strlen (name
) + 1;
3303 newname
= (char *) obstack_alloc (obstackp
, length
);
3304 (void) strcpy (newname
, name
);
3312 basicdieinfo -- extract the minimal die info from raw die data
3316 void basicdieinfo (char *diep, struct dieinfo *dip)
3320 Given a pointer to raw DIE data, and a pointer to an instance of a
3321 die info structure, this function extracts the basic information
3322 from the DIE data required to continue processing this DIE, along
3323 with some bookkeeping information about the DIE.
3325 The information we absolutely must have includes the DIE tag,
3326 and the DIE length. If we need the sibling reference, then we
3327 will have to call completedieinfo() to process all the remaining
3330 Note that since there is no guarantee that the data is properly
3331 aligned in memory for the type of access required (indirection
3332 through anything other than a char pointer), we use memcpy to
3333 shuffle data items larger than a char. Possibly inefficient, but
3336 We also take care of some other basic things at this point, such
3337 as ensuring that the instance of the die info structure starts
3338 out completely zero'd and that curdie is initialized for use
3339 in error reporting if we have a problem with the current die.
3343 All DIE's must have at least a valid length, thus the minimum
3344 DIE size is sizeof (long). In order to have a valid tag, the
3345 DIE size must be at least sizeof (short) larger, otherwise they
3346 are forced to be TAG_padding DIES.
3348 Padding DIES must be at least sizeof(long) in length, implying that
3349 if a padding DIE is used for alignment and the amount needed is less
3350 than sizeof(long) then the padding DIE has to be big enough to align
3351 to the next alignment boundry.
3355 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3358 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3360 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3361 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3362 if (dip
-> dielength
< sizeof (long))
3364 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3366 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3368 dip
-> dietag
= TAG_padding
;
3372 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3380 completedieinfo -- finish reading the information for a given DIE
3384 void completedieinfo (struct dieinfo *dip)
3388 Given a pointer to an already partially initialized die info structure,
3389 scan the raw DIE data and finish filling in the die info structure
3390 from the various attributes found.
3392 Note that since there is no guarantee that the data is properly
3393 aligned in memory for the type of access required (indirection
3394 through anything other than a char pointer), we use memcpy to
3395 shuffle data items larger than a char. Possibly inefficient, but
3400 Each time we are called, we increment the diecount variable, which
3401 keeps an approximate count of the number of dies processed for
3402 each compilation unit. This information is presented to the user
3403 if the info_verbose flag is set.
3408 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3410 char *diep
; /* Current pointer into raw DIE data */
3411 char *end
; /* Terminate DIE scan here */
3412 unsigned short attr
; /* Current attribute being scanned */
3413 unsigned short form
; /* Form of the attribute */
3414 short block2sz
; /* Size of a block2 attribute field */
3415 long block4sz
; /* Size of a block4 attribute field */
3419 end
= diep
+ dip
-> dielength
;
3420 diep
+= sizeof (long) + sizeof (short);
3423 (void) memcpy (&attr
, diep
, sizeof (short));
3424 diep
+= sizeof (short);
3428 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3431 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3434 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3437 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3440 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3443 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3444 dip
-> at_stmt_list_p
= 1;
3447 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3450 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3453 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3455 case AT_user_def_type
:
3456 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3459 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3462 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3465 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3468 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3471 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3474 dip
-> at_location
= diep
;
3476 case AT_mod_fund_type
:
3477 dip
-> at_mod_fund_type
= diep
;
3479 case AT_subscr_data
:
3480 dip
-> at_subscr_data
= diep
;
3482 case AT_mod_u_d_type
:
3483 dip
-> at_mod_u_d_type
= diep
;
3486 dip
-> at_deriv_list
= diep
;
3488 case AT_element_list
:
3489 dip
-> at_element_list
= diep
;
3491 case AT_discr_value
:
3492 dip
-> at_discr_value
= diep
;
3494 case AT_string_length
:
3495 dip
-> at_string_length
= diep
;
3498 dip
-> at_name
= diep
;
3501 dip
-> at_comp_dir
= diep
;
3504 dip
-> at_producer
= diep
;
3507 (void) memcpy (&dip
-> at_loclist
, diep
, sizeof (long));
3510 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3513 (void) memcpy (&dip
-> at_incomplete
, diep
, sizeof (short));
3515 case AT_start_scope
:
3516 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3518 case AT_stride_size
:
3519 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3522 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3525 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3528 dip
-> at_const_data
= diep
;
3530 case AT_is_external
:
3531 (void) memcpy (&dip
-> at_is_external
, diep
, sizeof (short));
3532 dip
-> at_is_external_p
= 1;
3535 /* Found an attribute that we are unprepared to handle. However
3536 it is specifically one of the design goals of DWARF that
3537 consumers should ignore unknown attributes. As long as the
3538 form is one that we recognize (so we know how to skip it),
3539 we can just ignore the unknown attribute. */
3546 diep
+= sizeof (short);
3549 diep
+= sizeof (long);
3552 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3556 diep
+= sizeof (long);
3559 (void) memcpy (&block2sz
, diep
, sizeof (short));
3560 block2sz
+= sizeof (short);
3564 (void) memcpy (&block4sz
, diep
, sizeof (long));
3565 block4sz
+= sizeof (long);
3569 diep
+= strlen (diep
) + 1;
3572 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));