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 startup_file_start
; /* From blockframe.c */
97 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
98 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
99 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
100 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
101 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
102 extern int info_verbose
; /* From main.c; nonzero => verbose */
105 /* The DWARF debugging information consists of two major pieces,
106 one is a block of DWARF Information Entries (DIE's) and the other
107 is a line number table. The "struct dieinfo" structure contains
108 the information for a single DIE, the one currently being processed.
110 In order to make it easier to randomly access the attribute fields
111 of the current DIE, which are specifically unordered within the DIE
112 each DIE is scanned and an instance of the "struct dieinfo"
113 structure is initialized.
115 Initialization is done in two levels. The first, done by basicdieinfo(),
116 just initializes those fields that are vital to deciding whether or not
117 to use this DIE, how to skip past it, etc. The second, done by the
118 function completedieinfo(), fills in the rest of the information.
120 Attributes which have block forms are not interpreted at the time
121 the DIE is scanned, instead we just save pointers to the start
122 of their value fields.
124 Some fields have a flag <name>_p that is set when the value of the
125 field is valid (I.E. we found a matching attribute in the DIE). Since
126 we may want to test for the presence of some attributes in the DIE,
127 such as AT_is_external, without restricting the values of the field,
128 we need someway to note that we found such an attribute.
135 char * die
; /* Pointer to the raw DIE data */
136 long dielength
; /* Length of the raw DIE data */
137 DIEREF dieref
; /* Offset of this DIE */
138 short dietag
; /* Tag for this DIE */
143 unsigned short at_fund_type
;
144 BLOCK
* at_mod_fund_type
;
145 long at_user_def_type
;
146 BLOCK
* at_mod_u_d_type
;
148 BLOCK
* at_subscr_data
;
152 BLOCK
* at_deriv_list
;
153 BLOCK
* at_element_list
;
160 BLOCK
* at_discr_value
;
163 BLOCK
* at_string_length
;
173 BLOCK
* at_const_data
;
174 short at_is_external
;
175 unsigned int at_is_external_p
:1;
176 unsigned int at_stmt_list_p
:1;
179 static int diecount
; /* Approximate count of dies for compilation unit */
180 static struct dieinfo
*curdie
; /* For warnings and such */
182 static char *dbbase
; /* Base pointer to dwarf info */
183 static int dbroff
; /* Relative offset from start of .debug section */
184 static char *lnbase
; /* Base pointer to line section */
185 static int isreg
; /* Kludge to identify register variables */
187 static CORE_ADDR baseaddr
; /* Add to each symbol value */
189 /* Each partial symbol table entry contains a pointer to private data for the
190 read_symtab() function to use when expanding a partial symbol table entry
191 to a full symbol table entry. For DWARF debugging info, this data is
192 contained in the following structure and macros are provided for easy
193 access to the members given a pointer to a partial symbol table entry.
195 dbfoff Always the absolute file offset to the start of the ".debug"
196 section for the file containing the DIE's being accessed.
198 dbroff Relative offset from the start of the ".debug" access to the
199 first DIE to be accessed. When building the partial symbol
200 table, this value will be zero since we are accessing the
201 entire ".debug" section. When expanding a partial symbol
202 table entry, this value will be the offset to the first
203 DIE for the compilation unit containing the symbol that
204 triggers the expansion.
206 dblength The size of the chunk of DIE's being examined, in bytes.
208 lnfoff The absolute file offset to the line table fragment. Ignored
209 when building partial symbol tables, but used when expanding
210 them, and contains the absolute file offset to the fragment
211 of the ".line" section containing the line numbers for the
212 current compilation unit.
216 int dbfoff
; /* Absolute file offset to start of .debug section */
217 int dbroff
; /* Relative offset from start of .debug section */
218 int dblength
; /* Size of the chunk of DIE's being examined */
219 int lnfoff
; /* Absolute file offset to line table fragment */
222 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
223 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
224 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
225 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
227 /* Record the symbols defined for each context in a linked list. We don't
228 create a struct block for the context until we know how long to make it.
229 Global symbols for each file are maintained in the global_symbols list. */
231 struct pending_symbol
{
232 struct pending_symbol
*next
; /* Next pending symbol */
233 struct symbol
*symbol
; /* The actual symbol */
236 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
237 static struct block
*global_symbol_block
;
239 /* Line number entries are read into a dynamically expandable vector before
240 being added to the symbol table section. Once we know how many there are
243 static struct linetable
*line_vector
; /* Vector of line numbers. */
244 static int line_vector_index
; /* Index of next entry. */
245 static int line_vector_length
; /* Current allocation limit */
247 /* Scope information is kept in a scope tree, one node per scope. Each time
248 a new scope is started, a child node is created under the current node
249 and set to the current scope. Each time a scope is closed, the current
250 scope moves back up the tree to the parent of the current scope.
252 Each scope contains a pointer to the list of symbols defined in the scope,
253 a pointer to the block vector for the scope, a pointer to the symbol
254 that names the scope (if any), and the range of PC values that mark
255 the start and end of the scope. */
258 struct scopenode
*parent
;
259 struct scopenode
*child
;
260 struct scopenode
*sibling
;
261 struct pending_symbol
*symbols
;
263 struct symbol
*namesym
;
268 static struct scopenode
*scopetree
;
269 static struct scopenode
*scope
;
271 /* DIES which have user defined types or modified user defined types refer to
272 other DIES for the type information. Thus we need to associate the offset
273 of a DIE for a user defined type with a pointer to the type information.
275 Originally this was done using a simple but expensive algorithm, with an
276 array of unsorted structures, each containing an offset/type-pointer pair.
277 This array was scanned linearly each time a lookup was done. The result
278 was that gdb was spending over half it's startup time munging through this
279 array of pointers looking for a structure that had the right offset member.
281 The second attempt used the same array of structures, but the array was
282 sorted using qsort each time a new offset/type was recorded, and a binary
283 search was used to find the type pointer for a given DIE offset. This was
284 even slower, due to the overhead of sorting the array each time a new
285 offset/type pair was entered.
287 The third attempt uses a fixed size array of type pointers, indexed by a
288 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
289 we can divide any DIE offset by 4 to obtain a unique index into this fixed
290 size array. Since each element is a 4 byte pointer, it takes exactly as
291 much memory to hold this array as to hold the DWARF info for a given
292 compilation unit. But it gets freed as soon as we are done with it. */
294 static struct type
**utypes
; /* Pointer to array of user type pointers */
295 static int numutypes
; /* Max number of user type pointers */
297 /* Forward declarations of static functions so we don't have to worry
298 about ordering within this file. The EXFUN macro may be slightly
299 misleading. Should probably be called DCLFUN instead, or something
300 more intuitive, since it can be used for both static and external
303 static void dwarfwarn (); /* EXFUN breaks with <varargs.h> (FIXME)*/
306 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
309 EXFUN (scan_compilation_units
,
310 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
311 AND
unsigned int dbfoff AND
unsigned int lnoffset
312 AND
struct objfile
*objfile
));
314 static struct partial_symtab
*
315 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
316 AND
char *filename AND CORE_ADDR textlow
317 AND CORE_ADDR texthigh AND
int dbfoff
318 AND
int curoff AND
int culength AND
int lnfoff
319 AND
struct partial_symbol
*global_syms
320 AND
struct partial_symbol
*static_syms
));
322 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
325 EXFUN(add_psymbol_to_list
,
326 (struct psymbol_allocation_list
*listp AND
char *name
327 AND
enum namespace space AND
enum address_class
class
328 AND CORE_ADDR value
));
331 EXFUN(init_psymbol_list
, (int total_symbols
));
334 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
337 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
340 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
343 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
345 static struct symtab
*
346 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
350 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
353 EXFUN(read_structure_scope
,
354 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
357 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
360 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
363 EXFUN(read_array_type
, (struct dieinfo
*dip
));
366 EXFUN(read_subroutine_type
,
367 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
370 EXFUN(read_enumeration
,
371 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
375 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
378 EXFUN(enum_type
, (struct dieinfo
*dip
));
381 EXFUN(start_symtab
, (void));
385 (char *filename AND
long language AND
struct objfile
*objfile
));
388 EXFUN(scopecount
, (struct scopenode
*node
));
392 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
395 EXFUN(freescope
, (struct scopenode
*node
));
397 static struct block
*
398 EXFUN(buildblock
, (struct pending_symbol
*syms
));
401 EXFUN(closescope
, (void));
404 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
407 EXFUN(decode_line_numbers
, (char *linetable
));
410 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
413 EXFUN(decode_mod_fund_type
, (char *typedata
));
416 EXFUN(decode_mod_u_d_type
, (char *typedata
));
419 EXFUN(decode_modified_type
,
420 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
423 EXFUN(decode_fund_type
, (unsigned short fundtype
));
426 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
429 EXFUN(add_symbol_to_list
,
430 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
432 static struct block
**
433 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
435 static struct blockvector
*
436 EXFUN(make_blockvector
, (void));
439 EXFUN(lookup_utype
, (DIEREF dieref
));
442 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
444 static struct symbol
*
445 EXFUN(new_symbol
, (struct dieinfo
*dip
));
448 EXFUN(locval
, (char *loc
));
451 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
452 enum misc_function_type
));
455 EXFUN(compare_psymbols
,
456 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
463 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
467 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
468 int mainline, unsigned int dbfoff, unsigned int dbsize,
469 unsigned int lnoffset, unsigned int lnsize,
470 struct objfile *objfile)
474 This function is called upon to build partial symtabs from files
475 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
477 It is passed a file descriptor for an open file containing the DIES
478 and line number information, the corresponding filename for that
479 file, a base address for relocating the symbols, a flag indicating
480 whether or not this debugging information is from a "main symbol
481 table" rather than a shared library or dynamically linked file,
482 and file offset/size pairs for the DIE information and line number
492 DEFUN(dwarf_build_psymtabs
,
493 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
499 unsigned int dbfoff AND
500 unsigned int dbsize AND
501 unsigned int lnoffset AND
502 unsigned int lnsize AND
503 struct objfile
*objfile
)
505 struct cleanup
*back_to
;
507 dbbase
= xmalloc (dbsize
);
509 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
510 (read (desc
, dbbase
, dbsize
) != dbsize
))
513 error ("can't read DWARF data from '%s'", filename
);
515 back_to
= make_cleanup (free
, dbbase
);
517 /* If we are reinitializing, or if we have never loaded syms yet, init.
518 Since we have no idea how many DIES we are looking at, we just guess
519 some arbitrary value. */
521 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
523 init_psymbol_list (1024);
526 /* Follow the compilation unit sibling chain, building a partial symbol
527 table entry for each one. Save enough information about each compilation
528 unit to locate the full DWARF information later. */
530 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
531 dbfoff
, lnoffset
, objfile
);
533 do_cleanups (back_to
);
541 record_misc_function -- add entry to miscellaneous function vector
545 static void record_misc_function (char *name, CORE_ADDR address,
546 enum misc_function_type mf_type)
550 Given a pointer to the name of a symbol that should be added to the
551 miscellaneous function vector, and the address associated with that
552 symbol, records this information for later use in building the
553 miscellaneous function vector.
558 DEFUN(record_misc_function
, (name
, address
, mf_type
),
559 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
561 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
569 dwarfwarn -- issue a DWARF related warning
573 Issue warnings about DWARF related things that aren't serious enough
574 to warrant aborting with an error, but should not be ignored either.
575 This includes things like detectable corruption in DIE's, missing
576 DIE's, unimplemented features, etc.
578 In general, running across tags or attributes that we don't recognize
579 is not considered to be a problem and we should not issue warnings
584 We mostly follow the example of the error() routine, but without
585 returning to command level. It is arguable about whether warnings
586 should be issued at all, and if so, where they should go (stdout or
589 We assume that curdie is valid and contains at least the basic
590 information for the DIE where the problem was noticed.
601 fmt
= va_arg (ap
, char *);
603 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
604 if (curdie
-> at_name
)
606 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
608 vfprintf (stderr
, fmt
, ap
);
609 fprintf (stderr
, "\n");
618 compare_psymbols -- compare two partial symbols by name
622 Given pointer to two partial symbol table entries, compare
623 them by name and return -N, 0, or +N (ala strcmp). Typically
624 used by sorting routines like qsort().
628 This is a copy from dbxread.c. It should be moved to a generic
629 gdb file and made available for all psymtab builders (FIXME).
631 Does direct compare of first two characters before punting
632 and passing to strcmp for longer compares. Note that the
633 original version had a bug whereby two null strings or two
634 identically named one character strings would return the
635 comparison of memory following the null byte.
640 DEFUN(compare_psymbols
, (s1
, s2
),
641 struct partial_symbol
*s1 AND
642 struct partial_symbol
*s2
)
644 register char *st1
= SYMBOL_NAME (s1
);
645 register char *st2
= SYMBOL_NAME (s2
);
647 if ((st1
[0] - st2
[0]) || !st1
[0])
649 return (st1
[0] - st2
[0]);
651 else if ((st1
[1] - st2
[1]) || !st1
[1])
653 return (st1
[1] - st2
[1]);
657 return (strcmp (st1
+ 2, st2
+ 2));
665 read_lexical_block_scope -- process all dies in a lexical block
669 static void read_lexical_block_scope (struct dieinfo *dip,
670 char *thisdie, char *enddie)
674 Process all the DIES contained within a lexical block scope.
675 Start a new scope, process the dies, and then close the scope.
680 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
681 struct dieinfo
*dip AND
684 struct objfile
*objfile
)
686 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
687 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
695 lookup_utype -- look up a user defined type from die reference
699 static type *lookup_utype (DIEREF dieref)
703 Given a DIE reference, lookup the user defined type associated with
704 that DIE, if it has been registered already. If not registered, then
705 return NULL. Alloc_utype() can be called to register an empty
706 type for this reference, which will be filled in later when the
707 actual referenced DIE is processed.
711 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
713 struct type
*type
= NULL
;
716 utypeidx
= (dieref
- dbroff
) / 4;
717 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
719 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
723 type
= *(utypes
+ utypeidx
);
733 alloc_utype -- add a user defined type for die reference
737 static type *alloc_utype (DIEREF dieref, struct type *utypep)
741 Given a die reference DIEREF, and a possible pointer to a user
742 defined type UTYPEP, register that this reference has a user
743 defined type and either use the specified type in UTYPEP or
744 make a new empty type that will be filled in later.
746 We should only be called after calling lookup_utype() to verify that
747 there is not currently a type registered for DIEREF.
751 DEFUN(alloc_utype
, (dieref
, utypep
),
758 utypeidx
= (dieref
- dbroff
) / 4;
759 typep
= utypes
+ utypeidx
;
760 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
762 utypep
= builtin_type_int
;
763 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
765 else if (*typep
!= NULL
)
768 SQUAWK (("internal error: dup user type allocation"));
774 utypep
= (struct type
*)
775 obstack_alloc (symbol_obstack
, sizeof (struct type
));
776 (void) memset (utypep
, 0, sizeof (struct type
));
787 decode_die_type -- return a type for a specified die
791 static struct type *decode_die_type (struct dieinfo *dip)
795 Given a pointer to a die information structure DIP, decode the
796 type of the die and return a pointer to the decoded type. All
797 dies without specific types default to type int.
801 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
803 struct type
*type
= NULL
;
805 if (dip
-> at_fund_type
!= 0)
807 type
= decode_fund_type (dip
-> at_fund_type
);
809 else if (dip
-> at_mod_fund_type
!= NULL
)
811 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
813 else if (dip
-> at_user_def_type
)
815 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
817 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
820 else if (dip
-> at_mod_u_d_type
)
822 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
826 type
= builtin_type_int
;
835 struct_type -- compute and return the type for a struct or union
839 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
844 Given pointer to a die information structure for a die which
845 defines a union or structure, and pointers to the raw die data
846 that define the range of dies which define the members, compute
847 and return the user defined type for the structure or union.
851 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
852 struct dieinfo
*dip AND
858 struct nextfield
*next
;
861 struct nextfield
*list
= NULL
;
862 struct nextfield
*new;
870 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
872 type
= alloc_utype (dip
-> dieref
, NULL
);
874 switch (dip
-> dietag
)
876 case TAG_structure_type
:
877 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
881 TYPE_CODE (type
) = TYPE_CODE_UNION
;
886 SQUAWK (("missing structure or union tag"));
887 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
890 if (dip
-> at_name
== NULL
)
896 tpart2
= dip
-> at_name
;
898 if (dip
-> at_byte_size
== 0)
900 tpart3
= " <opaque>";
902 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
905 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
906 thisdie
+= dip
-> dielength
;
907 while (thisdie
< enddie
)
909 basicdieinfo (&mbr
, thisdie
);
910 completedieinfo (&mbr
);
911 if (mbr
.dielength
<= sizeof (long))
918 /* Get space to record the next field's data. */
919 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
923 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
924 list
-> field
.type
= decode_die_type (&mbr
);
925 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
926 list
-> field
.bitsize
= 0;
930 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
933 thisdie
+= mbr
.dielength
;
935 /* Now create the vector of fields, and record how big it is. */
936 TYPE_NFIELDS (type
) = nfields
;
937 TYPE_FIELDS (type
) = (struct field
*)
938 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
939 /* Copy the saved-up fields into the field vector. */
940 for (n
= nfields
; list
; list
= list
-> next
)
942 TYPE_FIELD (type
, --n
) = list
-> field
;
951 read_structure_scope -- process all dies within struct or union
955 static void read_structure_scope (struct dieinfo *dip,
956 char *thisdie, char *enddie)
960 Called when we find the DIE that starts a structure or union
961 scope (definition) to process all dies that define the members
962 of the structure or union. DIP is a pointer to the die info
963 struct for the DIE that names the structure or union.
967 Note that we need to call struct_type regardless of whether or not
968 we have a symbol, since we might have a structure or union without
969 a tag name (thus no symbol for the tagname).
973 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
974 struct dieinfo
*dip AND
981 type
= struct_type (dip
, thisdie
, enddie
);
982 if ((sym
= new_symbol (dip
)) != NULL
)
984 SYMBOL_TYPE (sym
) = type
;
992 decode_array_element_type -- decode type of the array elements
996 static struct type *decode_array_element_type (char *scan, char *end)
1000 As the last step in decoding the array subscript information for an
1001 array DIE, we need to decode the type of the array elements. We are
1002 passed a pointer to this last part of the subscript information and
1003 must return the appropriate type. If the type attribute is not
1004 recognized, just warn about the problem and return type int.
1007 static struct type
*
1008 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1013 unsigned short fundtype
;
1015 (void) memcpy (&attribute
, scan
, sizeof (short));
1016 scan
+= sizeof (short);
1020 (void) memcpy (&fundtype
, scan
, sizeof (short));
1021 typep
= decode_fund_type (fundtype
);
1023 case AT_mod_fund_type
:
1024 typep
= decode_mod_fund_type (scan
);
1026 case AT_user_def_type
:
1027 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1028 if ((typep
= lookup_utype (dieref
)) == NULL
)
1030 typep
= alloc_utype (dieref
, NULL
);
1033 case AT_mod_u_d_type
:
1034 typep
= decode_mod_u_d_type (scan
);
1037 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1038 typep
= builtin_type_int
;
1048 decode_subscr_data -- decode array subscript and element type data
1052 static struct type *decode_subscr_data (char *scan, char *end)
1056 The array subscripts and the data type of the elements of an
1057 array are described by a list of data items, stored as a block
1058 of contiguous bytes. There is a data item describing each array
1059 dimension, and a final data item describing the element type.
1060 The data items are ordered the same as their appearance in the
1061 source (I.E. leftmost dimension first, next to leftmost second,
1064 We are passed a pointer to the start of the block of bytes
1065 containing the data items, and a pointer to the first byte past
1066 the data. This function decodes the data and returns a type.
1069 FIXME: This code only implements the forms currently used
1070 by the AT&T and GNU C compilers.
1072 The end pointer is supplied for error checking, maybe we should
1076 static struct type
*
1077 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1079 struct type
*typep
= NULL
;
1080 struct type
*nexttype
;
1090 typep
= decode_array_element_type (scan
, end
);
1093 (void) memcpy (&fundtype
, scan
, sizeof (short));
1094 scan
+= sizeof (short);
1095 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1096 && fundtype
!= FT_unsigned_integer
)
1098 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1103 (void) memcpy (&lowbound
, scan
, sizeof (long));
1104 scan
+= sizeof (long);
1105 (void) memcpy (&highbound
, scan
, sizeof (long));
1106 scan
+= sizeof (long);
1107 nexttype
= decode_subscr_data (scan
, end
);
1108 if (nexttype
!= NULL
)
1110 typep
= (struct type
*)
1111 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1112 (void) memset (typep
, 0, sizeof (struct type
));
1113 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1114 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1115 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1116 TYPE_TARGET_TYPE (typep
) = nexttype
;
1127 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1130 SQUAWK (("unknown array subscript format %x", format
));
1140 read_array_type -- read TAG_array_type DIE
1144 static void read_array_type (struct dieinfo *dip)
1148 Extract all information from a TAG_array_type DIE and add to
1149 the user defined type vector.
1153 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1160 if (dip
-> at_ordering
!= ORD_row_major
)
1162 /* FIXME: Can gdb even handle column major arrays? */
1163 SQUAWK (("array not row major; not handled correctly"));
1165 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1167 (void) memcpy (&temp
, sub
, sizeof (short));
1168 subend
= sub
+ sizeof (short) + temp
;
1169 sub
+= sizeof (short);
1170 type
= decode_subscr_data (sub
, subend
);
1173 type
= alloc_utype (dip
-> dieref
, NULL
);
1174 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1175 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1176 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1180 type
= alloc_utype (dip
-> dieref
, type
);
1189 read_subroutine_type -- process TAG_subroutine_type dies
1193 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1198 Handle DIES due to C code like:
1201 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1207 The parameter DIES are currently ignored. See if gdb has a way to
1208 include this info in it's type system, and decode them if so. Is
1209 this what the type structure's "arg_types" field is for? (FIXME)
1213 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1214 struct dieinfo
*dip AND
1220 type
= decode_die_type (dip
);
1221 type
= lookup_function_type (type
);
1222 type
= alloc_utype (dip
-> dieref
, type
);
1229 read_enumeration -- process dies which define an enumeration
1233 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1238 Given a pointer to a die which begins an enumeration, process all
1239 the dies that define the members of the enumeration.
1243 Note that we need to call enum_type regardless of whether or not we
1244 have a symbol, since we might have an enum without a tag name (thus
1245 no symbol for the tagname).
1249 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1250 struct dieinfo
*dip AND
1257 type
= enum_type (dip
);
1258 if ((sym
= new_symbol (dip
)) != NULL
)
1260 SYMBOL_TYPE (sym
) = type
;
1268 enum_type -- decode and return a type for an enumeration
1272 static type *enum_type (struct dieinfo *dip)
1276 Given a pointer to a die information structure for the die which
1277 starts an enumeration, process all the dies that define the members
1278 of the enumeration and return a type pointer for the enumeration.
1281 static struct type
*
1282 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1286 struct nextfield
*next
;
1289 struct nextfield
*list
= NULL
;
1290 struct nextfield
*new;
1300 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1302 type
= alloc_utype (dip
-> dieref
, NULL
);
1304 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1306 if (dip
-> at_name
== NULL
)
1310 tpart2
= dip
-> at_name
;
1312 if (dip
-> at_byte_size
== 0)
1314 tpart3
= " <opaque>";
1318 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1321 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
1322 if ((scan
= dip
-> at_element_list
) != NULL
)
1324 (void) memcpy (&temp
, scan
, sizeof (temp
));
1325 listend
= scan
+ temp
+ sizeof (temp
);
1326 scan
+= sizeof (temp
);
1327 while (scan
< listend
)
1329 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1332 list
-> field
.type
= NULL
;
1333 list
-> field
.bitsize
= 0;
1334 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1335 scan
+= sizeof (long);
1336 list
-> field
.name
= savestring (scan
, strlen (scan
));
1337 scan
+= strlen (scan
) + 1;
1341 /* Now create the vector of fields, and record how big it is. */
1342 TYPE_NFIELDS (type
) = nfields
;
1343 TYPE_FIELDS (type
) = (struct field
*)
1344 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1345 /* Copy the saved-up fields into the field vector. */
1346 for (n
= nfields
; list
; list
= list
-> next
)
1348 TYPE_FIELD (type
, --n
) = list
-> field
;
1357 read_func_scope -- process all dies within a function scope
1361 Process all dies within a given function scope. We are passed
1362 a die information structure pointer DIP for the die which
1363 starts the function scope, and pointers into the raw die data
1364 that define the dies within the function scope.
1366 For now, we ignore lexical block scopes within the function.
1367 The problem is that AT&T cc does not define a DWARF lexical
1368 block scope for the function itself, while gcc defines a
1369 lexical block scope for the function. We need to think about
1370 how to handle this difference, or if it is even a problem.
1375 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1376 struct dieinfo
*dip AND
1379 struct objfile
*objfile
)
1383 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1385 entry_scope_lowpc
= dip
-> at_low_pc
;
1386 entry_scope_highpc
= dip
-> at_high_pc
;
1388 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1390 main_scope_lowpc
= dip
-> at_low_pc
;
1391 main_scope_highpc
= dip
-> at_high_pc
;
1393 sym
= new_symbol (dip
);
1394 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1395 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1403 read_file_scope -- process all dies within a file scope
1407 Process all dies within a given file scope. We are passed a
1408 pointer to the die information structure for the die which
1409 starts the file scope, and pointers into the raw die data which
1410 mark the range of dies within the file scope.
1412 When the partial symbol table is built, the file offset for the line
1413 number table for each compilation unit is saved in the partial symbol
1414 table entry for that compilation unit. As the symbols for each
1415 compilation unit are read, the line number table is read into memory
1416 and the variable lnbase is set to point to it. Thus all we have to
1417 do is use lnbase to access the line number table for the current
1422 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1423 struct dieinfo
*dip AND
1426 struct objfile
*objfile
)
1428 struct cleanup
*back_to
;
1430 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1432 startup_file_start
= dip
-> at_low_pc
;
1433 startup_file_end
= dip
-> at_high_pc
;
1435 numutypes
= (enddie
- thisdie
) / 4;
1436 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1437 back_to
= make_cleanup (free
, utypes
);
1438 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1440 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1441 decode_line_numbers (lnbase
);
1442 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1444 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1445 do_cleanups (back_to
);
1454 start_symtab -- do initialization for starting new symbol table
1458 static void start_symtab (void)
1462 Called whenever we are starting to process dies for a new
1463 compilation unit, to perform initializations. Right now
1464 the only thing we really have to do is initialize storage
1465 space for the line number vector.
1470 DEFUN_VOID (start_symtab
)
1474 line_vector_index
= 0;
1475 line_vector_length
= 1000;
1476 nbytes
= sizeof (struct linetable
);
1477 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1478 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1485 process_dies -- process a range of DWARF Information Entries
1489 static void process_dies (char *thisdie, char *enddie)
1493 Process all DIE's in a specified range. May be (and almost
1494 certainly will be) called recursively.
1498 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1499 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1504 while (thisdie
< enddie
)
1506 basicdieinfo (&di
, thisdie
);
1507 if (di
.dielength
< sizeof (long))
1511 else if (di
.dietag
== TAG_padding
)
1513 nextdie
= thisdie
+ di
.dielength
;
1517 completedieinfo (&di
);
1518 if (di
.at_sibling
!= 0)
1520 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1524 nextdie
= thisdie
+ di
.dielength
;
1528 case TAG_compile_unit
:
1529 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1531 case TAG_global_subroutine
:
1532 case TAG_subroutine
:
1533 if (!di
.at_is_external_p
)
1535 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1538 case TAG_lexical_block
:
1539 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1541 case TAG_structure_type
:
1542 case TAG_union_type
:
1543 read_structure_scope (&di
, thisdie
, nextdie
);
1545 case TAG_enumeration_type
:
1546 read_enumeration (&di
, thisdie
, nextdie
);
1548 case TAG_subroutine_type
:
1549 read_subroutine_type (&di
, thisdie
, nextdie
);
1551 case TAG_array_type
:
1552 read_array_type (&di
);
1555 (void) new_symbol (&di
);
1567 end_symtab -- finish processing for a compilation unit
1571 static void end_symtab (char *filename, long language)
1575 Complete the symbol table entry for the current compilation
1576 unit. Make the struct symtab and put it on the list of all
1582 DEFUN(end_symtab
, (filename
, language
, objfile
),
1583 char *filename AND
long language AND
struct objfile
*objfile
)
1585 struct symtab
*symtab
;
1586 struct blockvector
*blockvector
;
1589 /* Ignore a file that has no functions with real debugging info. */
1590 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1594 line_vector_length
= -1;
1595 freescope (scopetree
);
1596 scope
= scopetree
= NULL
;
1599 /* Create the blockvector that points to all the file's blocks. */
1601 blockvector
= make_blockvector ();
1603 /* Now create the symtab object for this source file. */
1605 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1608 symtab
-> free_ptr
= 0;
1610 /* Fill in its components. */
1611 symtab
-> blockvector
= blockvector
;
1612 symtab
-> free_code
= free_linetable
;
1614 /* Save the line number information. */
1616 line_vector
-> nitems
= line_vector_index
;
1617 nbytes
= sizeof (struct linetable
);
1618 if (line_vector_index
> 1)
1620 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1622 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1624 /* FIXME: The following may need to be expanded for other languages */
1629 symtab
-> language
= language_c
;
1631 case LANG_C_PLUS_PLUS
:
1632 symtab
-> language
= language_cplus
;
1638 /* Link the new symtab into the list of such. */
1639 symtab
-> next
= symtab_list
;
1640 symtab_list
= symtab
;
1642 /* Recursively free the scope tree */
1643 freescope (scopetree
);
1644 scope
= scopetree
= NULL
;
1646 /* Reinitialize for beginning of new file. */
1648 line_vector_length
= -1;
1655 scopecount -- count the number of enclosed scopes
1659 static int scopecount (struct scopenode *node)
1663 Given pointer to a node, compute the size of the subtree which is
1664 rooted in this node, which also happens to be the number of scopes
1669 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1675 count
+= scopecount (node
-> child
);
1676 count
+= scopecount (node
-> sibling
);
1686 openscope -- start a new lexical block scope
1690 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1695 Start a new scope by allocating a new scopenode, adding it as the
1696 next child of the current scope (if any) or as the root of the
1697 scope tree, and then making the new node the current scope node.
1701 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1702 struct symbol
*namesym AND
1706 struct scopenode
*new;
1707 struct scopenode
*child
;
1709 new = (struct scopenode
*) xmalloc (sizeof (*new));
1710 (void) memset (new, 0, sizeof (*new));
1711 new -> namesym
= namesym
;
1712 new -> lowpc
= lowpc
;
1713 new -> highpc
= highpc
;
1718 else if ((child
= scope
-> child
) == NULL
)
1720 scope
-> child
= new;
1721 new -> parent
= scope
;
1725 while (child
-> sibling
!= NULL
)
1727 child
= child
-> sibling
;
1729 child
-> sibling
= new;
1730 new -> parent
= scope
;
1739 freescope -- free a scope tree rooted at the given node
1743 static void freescope (struct scopenode *node)
1747 Given a pointer to a node in the scope tree, free the subtree
1748 rooted at that node. First free all the children and sibling
1749 nodes, and then the node itself. Used primarily for cleaning
1750 up after ourselves and returning memory to the system.
1754 DEFUN(freescope
, (node
), struct scopenode
*node
)
1758 freescope (node
-> child
);
1759 freescope (node
-> sibling
);
1768 buildblock -- build a new block from pending symbols list
1772 static struct block *buildblock (struct pending_symbol *syms)
1776 Given a pointer to a list of symbols, build a new block and free
1777 the symbol list structure. Also check each symbol to see if it
1778 is the special symbol that flags that this block was compiled by
1779 gcc, and if so, mark the block appropriately.
1782 static struct block
*
1783 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1785 struct pending_symbol
*next
, *next1
;
1787 struct block
*newblock
;
1790 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1792 /* Allocate a new block */
1794 nbytes
= sizeof (struct block
);
1797 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1799 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1800 (void) memset (newblock
, 0, nbytes
);
1802 /* Copy the symbols into the block. */
1804 BLOCK_NSYMS (newblock
) = i
;
1805 for (next
= syms
; next
; next
= next
-> next
)
1807 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1808 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1809 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1811 BLOCK_GCC_COMPILED (newblock
) = 1;
1815 /* Now free the links of the list, and empty the list. */
1817 for (next
= syms
; next
; next
= next1
)
1819 next1
= next
-> next
;
1830 closescope -- close a lexical block scope
1834 static void closescope (void)
1838 Close the current lexical block scope. Closing the current scope
1839 is as simple as moving the current scope pointer up to the parent
1840 of the current scope pointer. But we also take this opportunity
1841 to build the block for the current scope first, since we now have
1842 all of it's symbols.
1846 DEFUN_VOID(closescope
)
1848 struct scopenode
*child
;
1852 error ("DWARF parse error, too many close scopes");
1856 if (scope
-> parent
== NULL
)
1858 global_symbol_block
= buildblock (global_symbols
);
1859 global_symbols
= NULL
;
1860 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1861 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1863 scope
-> block
= buildblock (scope
-> symbols
);
1864 scope
-> symbols
= NULL
;
1865 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1866 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1868 /* Put the local block in as the value of the symbol that names it. */
1870 if (scope
-> namesym
)
1872 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1873 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1876 /* Install this scope's local block as the superblock of all child
1879 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1881 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1884 scope
= scope
-> parent
;
1892 record_line -- record a line number entry in the line vector
1896 static void record_line (int line, CORE_ADDR pc)
1900 Given a line number and the corresponding pc value, record
1901 this pair in the line number vector, expanding the vector as
1906 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1908 struct linetable_entry
*e
;
1911 /* Make sure line vector is big enough. */
1913 if (line_vector_index
+ 2 >= line_vector_length
)
1915 line_vector_length
*= 2;
1916 nbytes
= sizeof (struct linetable
);
1917 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1918 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1920 e
= line_vector
-> item
+ line_vector_index
++;
1929 decode_line_numbers -- decode a line number table fragment
1933 static void decode_line_numbers (char *tblscan, char *tblend,
1934 long length, long base, long line, long pc)
1938 Translate the DWARF line number information to gdb form.
1940 The ".line" section contains one or more line number tables, one for
1941 each ".line" section from the objects that were linked.
1943 The AT_stmt_list attribute for each TAG_source_file entry in the
1944 ".debug" section contains the offset into the ".line" section for the
1945 start of the table for that file.
1947 The table itself has the following structure:
1949 <table length><base address><source statement entry>
1950 4 bytes 4 bytes 10 bytes
1952 The table length is the total size of the table, including the 4 bytes
1953 for the length information.
1955 The base address is the address of the first instruction generated
1956 for the source file.
1958 Each source statement entry has the following structure:
1960 <line number><statement position><address delta>
1961 4 bytes 2 bytes 4 bytes
1963 The line number is relative to the start of the file, starting with
1966 The statement position either -1 (0xFFFF) or the number of characters
1967 from the beginning of the line to the beginning of the statement.
1969 The address delta is the difference between the base address and
1970 the address of the first instruction for the statement.
1972 Note that we must copy the bytes from the packed table to our local
1973 variables before attempting to use them, to avoid alignment problems
1974 on some machines, particularly RISC processors.
1978 Does gdb expect the line numbers to be sorted? They are now by
1979 chance/luck, but are not required to be. (FIXME)
1981 The line with number 0 is unused, gdb apparently can discover the
1982 span of the last line some other way. How? (FIXME)
1986 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
1995 if (linetable
!= NULL
)
1997 tblscan
= tblend
= linetable
;
1998 (void) memcpy (&length
, tblscan
, sizeof (long));
1999 tblscan
+= sizeof (long);
2001 (void) memcpy (&base
, tblscan
, sizeof (long));
2003 tblscan
+= sizeof (long);
2004 while (tblscan
< tblend
)
2006 (void) memcpy (&line
, tblscan
, sizeof (long));
2007 tblscan
+= sizeof (long) + sizeof (short);
2008 (void) memcpy (&pc
, tblscan
, sizeof (long));
2009 tblscan
+= sizeof (long);
2013 record_line (line
, pc
);
2023 add_symbol_to_list -- add a symbol to head of current symbol list
2027 static void add_symbol_to_list (struct symbol *symbol, struct
2028 pending_symbol **listhead)
2032 Given a pointer to a symbol and a pointer to a pointer to a
2033 list of symbols, add this symbol as the current head of the
2034 list. Typically used for example to add a symbol to the
2035 symbol list for the current scope.
2040 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2041 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2043 struct pending_symbol
*link
;
2047 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2048 link
-> next
= *listhead
;
2049 link
-> symbol
= symbol
;
2058 gatherblocks -- walk a scope tree and build block vectors
2062 static struct block **gatherblocks (struct block **dest,
2063 struct scopenode *node)
2067 Recursively walk a scope tree rooted in the given node, adding blocks
2068 to the array pointed to by DEST, in preorder. I.E., first we add the
2069 block for the current scope, then all the blocks for child scopes,
2070 and finally all the blocks for sibling scopes.
2073 static struct block
**
2074 DEFUN(gatherblocks
, (dest
, node
),
2075 struct block
**dest AND
struct scopenode
*node
)
2079 *dest
++ = node
-> block
;
2080 dest
= gatherblocks (dest
, node
-> child
);
2081 dest
= gatherblocks (dest
, node
-> sibling
);
2090 make_blockvector -- make a block vector from current scope tree
2094 static struct blockvector *make_blockvector (void)
2098 Make a blockvector from all the blocks in the current scope tree.
2099 The first block is always the global symbol block, followed by the
2100 block for the root of the scope tree which is the local symbol block,
2101 followed by all the remaining blocks in the scope tree, which are all
2106 Note that since the root node of the scope tree is created at the time
2107 each file scope is entered, there are always at least two blocks,
2108 neither of which may have any symbols, but always contribute a block
2109 to the block vector. So the test for number of blocks greater than 1
2110 below is unnecessary given bug free code.
2112 The resulting block structure varies slightly from that produced
2113 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2114 with dbxread.c, block 1 is a child of block 0. This does not
2115 seem to cause any problems, but probably should be fixed. (FIXME)
2118 static struct blockvector
*
2119 DEFUN_VOID(make_blockvector
)
2121 struct blockvector
*blockvector
= NULL
;
2125 /* Recursively walk down the tree, counting the number of blocks.
2126 Then add one to account for the global's symbol block */
2128 i
= scopecount (scopetree
) + 1;
2129 nbytes
= sizeof (struct blockvector
);
2132 nbytes
+= (i
- 1) * sizeof (struct block
*);
2134 blockvector
= (struct blockvector
*)
2135 obstack_alloc (symbol_obstack
, nbytes
);
2137 /* Copy the blocks into the blockvector. */
2139 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2140 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2141 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2143 return (blockvector
);
2150 locval -- compute the value of a location attribute
2154 static int locval (char *loc)
2158 Given pointer to a string of bytes that define a location, compute
2159 the location and return the value.
2161 When computing values involving the current value of the frame pointer,
2162 the value zero is used, which results in a value relative to the frame
2163 pointer, rather than the absolute value. This is what GDB wants
2166 When the result is a register number, the global isreg flag is set,
2167 otherwise it is cleared. This is a kludge until we figure out a better
2168 way to handle the problem. Gdb's design does not mesh well with the
2169 DWARF notion of a location computing interpreter, which is a shame
2170 because the flexibility goes unused.
2174 Note that stack[0] is unused except as a default error return.
2175 Note that stack overflow is not yet handled.
2179 DEFUN(locval
, (loc
), char *loc
)
2181 unsigned short nbytes
;
2187 (void) memcpy (&nbytes
, loc
, sizeof (short));
2188 end
= loc
+ sizeof (short) + nbytes
;
2192 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2200 /* push register (number) */
2201 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2205 /* push value of register (number) */
2206 /* Actually, we compute the value as if register has 0 */
2207 (void) memcpy (®no
, loc
, sizeof (long));
2210 stack
[++stacki
] = 0;
2214 stack
[++stacki
] = 0;
2215 SQUAWK (("BASEREG %d not handled!", regno
));
2219 /* push address (relocated address) */
2220 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2223 /* push constant (number) */
2224 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2227 /* pop, deref and push 2 bytes (as a long) */
2228 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2230 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2231 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2233 case OP_ADD
: /* pop top 2 items, add, push result */
2234 stack
[stacki
- 1] += stack
[stacki
];
2239 return (stack
[stacki
]);
2246 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2250 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2254 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2257 static struct symtab
*
2258 DEFUN(read_ofile_symtab
, (pst
),
2259 struct partial_symtab
*pst
)
2261 struct cleanup
*back_to
;
2264 bfd
*abfd
= pst
->objfile
->obfd
;
2266 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2267 unit, seek to the location in the file, and read in all the DIE's. */
2270 dbbase
= xmalloc (DBLENGTH(pst
));
2271 dbroff
= DBROFF(pst
);
2272 foffset
= DBFOFF(pst
) + dbroff
;
2273 if (bfd_seek (abfd
, foffset
, 0) ||
2274 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2277 error ("can't read DWARF data");
2279 back_to
= make_cleanup (free
, dbbase
);
2281 /* If there is a line number table associated with this compilation unit
2282 then read the first long word from the line number table fragment, which
2283 contains the size of the fragment in bytes (including the long word
2284 itself). Allocate a buffer for the fragment and read it in for future
2290 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2291 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2293 error ("can't read DWARF line number table size");
2295 lnbase
= xmalloc (lnsize
);
2296 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2297 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2300 error ("can't read DWARF line numbers");
2302 make_cleanup (free
, lnbase
);
2305 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2306 do_cleanups (back_to
);
2307 return (symtab_list
);
2314 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2318 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2322 Called once for each partial symbol table entry that needs to be
2323 expanded into a full symbol table entry.
2328 DEFUN(psymtab_to_symtab_1
,
2330 struct partial_symtab
*pst
)
2340 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2345 /* Read in all partial symtabs on which this one is dependent */
2346 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2347 if (!pst
-> dependencies
[i
] -> readin
)
2349 /* Inform about additional files that need to be read in. */
2352 fputs_filtered (" ", stdout
);
2354 fputs_filtered ("and ", stdout
);
2356 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2357 wrap_here (""); /* Flush output */
2360 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2363 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2365 /* Init stuff necessary for reading in symbols */
2366 pst
-> symtab
= read_ofile_symtab (pst
);
2369 printf_filtered ("%d DIE's, sorting...", diecount
);
2372 sort_symtab_syms (pst
-> symtab
);
2381 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2385 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2389 This is the DWARF support entry point for building a full symbol
2390 table entry from a partial symbol table entry. We are passed a
2391 pointer to the partial symbol table entry that needs to be expanded.
2396 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2407 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2412 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2414 /* Print the message now, before starting serious work, to avoid
2415 disconcerting pauses. */
2418 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2422 psymtab_to_symtab_1 (pst
);
2424 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2425 we need to do an equivalent or is this something peculiar to
2426 stabs/a.out format. */
2427 /* Match with global symbols. This only needs to be done once,
2428 after all of the symtabs and dependencies have been read in. */
2429 scan_file_globals ();
2432 /* Finish up the debug error message. */
2435 printf_filtered ("done.\n");
2444 init_psymbol_list -- initialize storage for partial symbols
2448 static void init_psymbol_list (int total_symbols)
2452 Initializes storage for all of the partial symbols that will be
2453 created by dwarf_build_psymtabs and subsidiaries.
2457 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2459 /* Free any previously allocated psymbol lists. */
2461 if (global_psymbols
.list
)
2463 free (global_psymbols
.list
);
2465 if (static_psymbols
.list
)
2467 free (static_psymbols
.list
);
2470 /* Current best guess is that there are approximately a twentieth
2471 of the total symbols (in a debugging file) are global or static
2474 global_psymbols
.size
= total_symbols
/ 10;
2475 static_psymbols
.size
= total_symbols
/ 10;
2476 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2477 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2478 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2479 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2486 start_psymtab -- allocate and partially fill a partial symtab entry
2490 Allocate and partially fill a partial symtab. It will be completely
2491 filled at the end of the symbol list.
2493 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2494 ADDR is the address relative to which its symbols are (incremental)
2495 or 0 (normal). FILENAME is the name of the compilation unit that
2496 these symbols were defined in, and they appear starting a address
2497 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2498 the full symbols can be read for compilation unit FILENAME.
2499 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2504 static struct partial_symtab
*
2505 DEFUN(start_psymtab
,
2506 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2507 culength
, lnfoff
, global_syms
, static_syms
),
2508 struct objfile
*objfile AND
2511 CORE_ADDR textlow AND
2512 CORE_ADDR texthigh AND
2517 struct partial_symbol
*global_syms AND
2518 struct partial_symbol
*static_syms
)
2520 struct partial_symtab
*result
;
2522 result
= (struct partial_symtab
*)
2523 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2524 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2525 result
-> addr
= addr
;
2526 result
-> objfile
= objfile
;
2527 result
-> filename
= create_name (filename
, psymbol_obstack
);
2528 result
-> textlow
= textlow
;
2529 result
-> texthigh
= texthigh
;
2530 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2531 sizeof (struct dwfinfo
));
2532 DBFOFF (result
) = dbfoff
;
2533 DBROFF (result
) = curoff
;
2534 DBLENGTH (result
) = culength
;
2535 LNFOFF (result
) = lnfoff
;
2536 result
-> readin
= 0;
2537 result
-> symtab
= NULL
;
2538 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2539 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2540 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2542 result
->n_global_syms
= 0;
2543 result
->n_static_syms
= 0;
2552 add_psymbol_to_list -- add a partial symbol to given list
2556 Add a partial symbol to one of the partial symbol vectors (pointed to
2557 by listp). The vector is grown as necessary.
2562 DEFUN(add_psymbol_to_list
,
2563 (listp
, name
, space
, class, value
),
2564 struct psymbol_allocation_list
*listp AND
2566 enum namespace space AND
2567 enum address_class
class AND
2570 struct partial_symbol
*psym
;
2573 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2575 newsize
= listp
-> size
* 2;
2576 listp
-> list
= (struct partial_symbol
*)
2577 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2578 /* Next assumes we only went one over. Should be good if program works
2580 listp
-> next
= listp
-> list
+ listp
-> size
;
2581 listp
-> size
= newsize
;
2583 psym
= listp
-> next
++;
2584 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2585 SYMBOL_NAMESPACE (psym
) = space
;
2586 SYMBOL_CLASS (psym
) = class;
2587 SYMBOL_VALUE (psym
) = value
;
2594 add_partial_symbol -- add symbol to partial symbol table
2598 Given a DIE, if it is one of the types that we want to
2599 add to a partial symbol table, finish filling in the die info
2600 and then add a partial symbol table entry for it.
2605 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2607 switch (dip
-> dietag
)
2609 case TAG_global_subroutine
:
2610 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2611 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2612 LOC_BLOCK
, dip
-> at_low_pc
);
2614 case TAG_global_variable
:
2615 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2617 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2620 case TAG_subroutine
:
2621 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2622 LOC_BLOCK
, dip
-> at_low_pc
);
2624 case TAG_local_variable
:
2625 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2629 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2632 case TAG_structure_type
:
2633 case TAG_union_type
:
2634 case TAG_enumeration_type
:
2635 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2645 scan_partial_symbols -- scan DIE's within a single compilation unit
2649 Process the DIE's within a single compilation unit, looking for
2650 interesting DIE's that contribute to the partial symbol table entry
2651 for this compilation unit. Since we cannot follow any sibling
2652 chains without reading the complete DIE info for every DIE,
2653 it is probably faster to just sequentially check each one to
2654 see if it is one of the types we are interested in, and if
2655 so, then extracting all the attributes info and generating a
2656 partial symbol table entry.
2661 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2666 while (thisdie
< enddie
)
2668 basicdieinfo (&di
, thisdie
);
2669 if (di
.dielength
< sizeof (long))
2675 nextdie
= thisdie
+ di
.dielength
;
2678 case TAG_global_subroutine
:
2679 case TAG_global_variable
:
2680 case TAG_subroutine
:
2681 case TAG_local_variable
:
2683 case TAG_structure_type
:
2684 case TAG_union_type
:
2685 case TAG_enumeration_type
:
2686 completedieinfo (&di
);
2687 /* Don't attempt to add anonymous structures, unions, or
2688 enumerations since they have no name. Also check that
2689 this is the place where the actual definition occurs,
2690 rather than just a reference to an external. */
2691 if (di
.at_name
!= NULL
&& !di
.at_is_external_p
)
2693 add_partial_symbol (&di
);
2706 scan_compilation_units -- build a psymtab entry for each compilation
2710 This is the top level dwarf parsing routine for building partial
2713 It scans from the beginning of the DWARF table looking for the first
2714 TAG_compile_unit DIE, and then follows the sibling chain to locate
2715 each additional TAG_compile_unit DIE.
2717 For each TAG_compile_unit DIE it creates a partial symtab structure,
2718 calls a subordinate routine to collect all the compilation unit's
2719 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2720 new partial symtab structure into the partial symbol table. It also
2721 records the appropriate information in the partial symbol table entry
2722 to allow the chunk of DIE's and line number table for this compilation
2723 unit to be located and re-read later, to generate a complete symbol
2724 table entry for the compilation unit.
2726 Thus it effectively partitions up a chunk of DIE's for multiple
2727 compilation units into smaller DIE chunks and line number tables,
2728 and associates them with a partial symbol table entry.
2732 If any compilation unit has no line number table associated with
2733 it for some reason (a missing at_stmt_list attribute, rather than
2734 just one with a value of zero, which is valid) then we ensure that
2735 the recorded file offset is zero so that the routine which later
2736 reads line number table fragments knows that there is no fragment
2746 DEFUN(scan_compilation_units
,
2747 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2752 unsigned int dbfoff AND
2753 unsigned int lnoffset AND
2754 struct objfile
*objfile
)
2758 struct partial_symtab
*pst
;
2763 while (thisdie
< enddie
)
2765 basicdieinfo (&di
, thisdie
);
2766 if (di
.dielength
< sizeof (long))
2770 else if (di
.dietag
!= TAG_compile_unit
)
2772 nextdie
= thisdie
+ di
.dielength
;
2776 completedieinfo (&di
);
2777 if (di
.at_sibling
!= 0)
2779 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2783 nextdie
= thisdie
+ di
.dielength
;
2785 curoff
= thisdie
- dbbase
;
2786 culength
= nextdie
- thisdie
;
2787 curlnoffset
= di
.at_stmt_list_p
? lnoffset
+ di
.at_stmt_list
: 0;
2788 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2789 di
.at_low_pc
, di
.at_high_pc
,
2790 dbfoff
, curoff
, culength
, curlnoffset
,
2791 global_psymbols
.next
,
2792 static_psymbols
.next
);
2793 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2794 pst
-> n_global_syms
= global_psymbols
.next
-
2795 (global_psymbols
.list
+ pst
-> globals_offset
);
2796 pst
-> n_static_syms
= static_psymbols
.next
-
2797 (static_psymbols
.list
+ pst
-> statics_offset
);
2798 /* Sort the global list; don't sort the static list */
2799 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2800 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2802 /* If there is already a psymtab or symtab for a file of this name,
2803 remove it. (If there is a symtab, more drastic things also
2804 happen.) This happens in VxWorks. */
2805 free_named_symtabs (pst
-> filename
);
2806 /* Place the partial symtab on the partial symtab list */
2807 pst
-> next
= partial_symtab_list
;
2808 partial_symtab_list
= pst
;
2818 new_symbol -- make a symbol table entry for a new symbol
2822 static struct symbol *new_symbol (struct dieinfo *dip)
2826 Given a pointer to a DWARF information entry, figure out if we need
2827 to make a symbol table entry for it, and if so, create a new entry
2828 and return a pointer to it.
2831 static struct symbol
*
2832 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2834 struct symbol
*sym
= NULL
;
2836 if (dip
-> at_name
!= NULL
)
2838 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2839 sizeof (struct symbol
));
2840 (void) memset (sym
, 0, sizeof (struct symbol
));
2841 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2842 /* default assumptions */
2843 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2844 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2845 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2846 switch (dip
-> dietag
)
2849 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2850 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2852 case TAG_global_subroutine
:
2853 case TAG_subroutine
:
2854 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2855 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2856 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2857 if (dip
-> dietag
== TAG_global_subroutine
)
2859 add_symbol_to_list (sym
, &global_symbols
);
2863 add_symbol_to_list (sym
, &scope
-> symbols
);
2866 case TAG_global_variable
:
2867 case TAG_local_variable
:
2868 if (dip
-> at_location
!= NULL
)
2870 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2872 if (dip
-> dietag
== TAG_global_variable
)
2874 add_symbol_to_list (sym
, &global_symbols
);
2875 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2876 SYMBOL_VALUE (sym
) += baseaddr
;
2880 add_symbol_to_list (sym
, &scope
-> symbols
);
2881 if (scope
-> parent
!= NULL
)
2885 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2889 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2894 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2895 SYMBOL_VALUE (sym
) += baseaddr
;
2899 case TAG_formal_parameter
:
2900 if (dip
-> at_location
!= NULL
)
2902 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2904 add_symbol_to_list (sym
, &scope
-> symbols
);
2907 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2911 SYMBOL_CLASS (sym
) = LOC_ARG
;
2914 case TAG_unspecified_parameters
:
2915 /* From varargs functions; gdb doesn't seem to have any interest in
2916 this information, so just ignore it for now. (FIXME?) */
2918 case TAG_structure_type
:
2919 case TAG_union_type
:
2920 case TAG_enumeration_type
:
2921 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2922 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2923 add_symbol_to_list (sym
, &scope
-> symbols
);
2926 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2927 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2928 add_symbol_to_list (sym
, &scope
-> symbols
);
2931 /* Not a tag we recognize. Hopefully we aren't processing trash
2932 data, but since we must specifically ignore things we don't
2933 recognize, there is nothing else we should do at this point. */
2944 decode_mod_fund_type -- decode a modified fundamental type
2948 static struct type *decode_mod_fund_type (char *typedata)
2952 Decode a block of data containing a modified fundamental
2953 type specification. TYPEDATA is a pointer to the block,
2954 which consists of a two byte length, containing the size
2955 of the rest of the block. At the end of the block is a
2956 two byte value that gives the fundamental type. Everything
2957 in between are type modifiers.
2959 We simply compute the number of modifiers and call the general
2960 function decode_modified_type to do the actual work.
2963 static struct type
*
2964 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
2966 struct type
*typep
= NULL
;
2967 unsigned short modcount
;
2968 unsigned char *modifiers
;
2970 /* Get the total size of the block, exclusive of the size itself */
2971 (void) memcpy (&modcount
, typedata
, sizeof (short));
2972 /* Deduct the size of the fundamental type bytes at the end of the block. */
2973 modcount
-= sizeof (short);
2974 /* Skip over the two size bytes at the beginning of the block. */
2975 modifiers
= (unsigned char *) typedata
+ sizeof (short);
2976 /* Now do the actual decoding */
2977 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
2985 decode_mod_u_d_type -- decode a modified user defined type
2989 static struct type *decode_mod_u_d_type (char *typedata)
2993 Decode a block of data containing a modified user defined
2994 type specification. TYPEDATA is a pointer to the block,
2995 which consists of a two byte length, containing the size
2996 of the rest of the block. At the end of the block is a
2997 four byte value that gives a reference to a user defined type.
2998 Everything in between are type modifiers.
3000 We simply compute the number of modifiers and call the general
3001 function decode_modified_type to do the actual work.
3004 static struct type
*
3005 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3007 struct type
*typep
= NULL
;
3008 unsigned short modcount
;
3009 unsigned char *modifiers
;
3011 /* Get the total size of the block, exclusive of the size itself */
3012 (void) memcpy (&modcount
, typedata
, sizeof (short));
3013 /* Deduct the size of the reference type bytes at the end of the block. */
3014 modcount
-= sizeof (long);
3015 /* Skip over the two size bytes at the beginning of the block. */
3016 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3017 /* Now do the actual decoding */
3018 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3026 decode_modified_type -- decode modified user or fundamental type
3030 static struct type *decode_modified_type (unsigned char *modifiers,
3031 unsigned short modcount, int mtype)
3035 Decode a modified type, either a modified fundamental type or
3036 a modified user defined type. MODIFIERS is a pointer to the
3037 block of bytes that define MODCOUNT modifiers. Immediately
3038 following the last modifier is a short containing the fundamental
3039 type or a long containing the reference to the user defined
3040 type. Which one is determined by MTYPE, which is either
3041 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3042 type we are generating.
3044 We call ourself recursively to generate each modified type,`
3045 until MODCOUNT reaches zero, at which point we have consumed
3046 all the modifiers and generate either the fundamental type or
3047 user defined type. When the recursion unwinds, each modifier
3048 is applied in turn to generate the full modified type.
3052 If we find a modifier that we don't recognize, and it is not one
3053 of those reserved for application specific use, then we issue a
3054 warning and simply ignore the modifier.
3058 We currently ignore MOD_const and MOD_volatile. (FIXME)
3062 static struct type
*
3063 DEFUN(decode_modified_type
,
3064 (modifiers
, modcount
, mtype
),
3065 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3067 struct type
*typep
= NULL
;
3068 unsigned short fundtype
;
3070 unsigned char modifier
;
3076 case AT_mod_fund_type
:
3077 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3078 typep
= decode_fund_type (fundtype
);
3080 case AT_mod_u_d_type
:
3081 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3082 if ((typep
= lookup_utype (dieref
)) == NULL
)
3084 typep
= alloc_utype (dieref
, NULL
);
3088 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3089 typep
= builtin_type_int
;
3095 modifier
= *modifiers
++;
3096 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3099 case MOD_pointer_to
:
3100 typep
= lookup_pointer_type (typep
);
3102 case MOD_reference_to
:
3103 typep
= lookup_reference_type (typep
);
3106 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3109 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3112 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3114 SQUAWK (("unknown type modifier %u", modifier
));
3126 decode_fund_type -- translate basic DWARF type to gdb base type
3130 Given an integer that is one of the fundamental DWARF types,
3131 translate it to one of the basic internal gdb types and return
3132 a pointer to the appropriate gdb type (a "struct type *").
3136 If we encounter a fundamental type that we are unprepared to
3137 deal with, and it is not in the range of those types defined
3138 as application specific types, then we issue a warning and
3139 treat the type as builtin_type_int.
3142 static struct type
*
3143 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3145 struct type
*typep
= NULL
;
3151 typep
= builtin_type_void
;
3154 case FT_pointer
: /* (void *) */
3155 typep
= lookup_pointer_type (builtin_type_void
);
3159 case FT_signed_char
:
3160 typep
= builtin_type_char
;
3164 case FT_signed_short
:
3165 typep
= builtin_type_short
;
3169 case FT_signed_integer
:
3170 case FT_boolean
: /* Was FT_set in AT&T version */
3171 typep
= builtin_type_int
;
3175 case FT_signed_long
:
3176 typep
= builtin_type_long
;
3180 typep
= builtin_type_float
;
3183 case FT_dbl_prec_float
:
3184 typep
= builtin_type_double
;
3187 case FT_unsigned_char
:
3188 typep
= builtin_type_unsigned_char
;
3191 case FT_unsigned_short
:
3192 typep
= builtin_type_unsigned_short
;
3195 case FT_unsigned_integer
:
3196 typep
= builtin_type_unsigned_int
;
3199 case FT_unsigned_long
:
3200 typep
= builtin_type_unsigned_long
;
3203 case FT_ext_prec_float
:
3204 typep
= builtin_type_long_double
;
3208 typep
= builtin_type_complex
;
3211 case FT_dbl_prec_complex
:
3212 typep
= builtin_type_double_complex
;
3216 case FT_signed_long_long
:
3217 typep
= builtin_type_long_long
;
3220 case FT_unsigned_long_long
:
3221 typep
= builtin_type_unsigned_long_long
;
3226 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3228 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3229 typep
= builtin_type_void
;
3239 create_name -- allocate a fresh copy of a string on an obstack
3243 Given a pointer to a string and a pointer to an obstack, allocates
3244 a fresh copy of the string on the specified obstack.
3249 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3254 length
= strlen (name
) + 1;
3255 newname
= (char *) obstack_alloc (obstackp
, length
);
3256 (void) strcpy (newname
, name
);
3264 basicdieinfo -- extract the minimal die info from raw die data
3268 void basicdieinfo (char *diep, struct dieinfo *dip)
3272 Given a pointer to raw DIE data, and a pointer to an instance of a
3273 die info structure, this function extracts the basic information
3274 from the DIE data required to continue processing this DIE, along
3275 with some bookkeeping information about the DIE.
3277 The information we absolutely must have includes the DIE tag,
3278 and the DIE length. If we need the sibling reference, then we
3279 will have to call completedieinfo() to process all the remaining
3282 Note that since there is no guarantee that the data is properly
3283 aligned in memory for the type of access required (indirection
3284 through anything other than a char pointer), we use memcpy to
3285 shuffle data items larger than a char. Possibly inefficient, but
3288 We also take care of some other basic things at this point, such
3289 as ensuring that the instance of the die info structure starts
3290 out completely zero'd and that curdie is initialized for use
3291 in error reporting if we have a problem with the current die.
3295 All DIE's must have at least a valid length, thus the minimum
3296 DIE size is sizeof (long). In order to have a valid tag, the
3297 DIE size must be at least sizeof (short) larger, otherwise they
3298 are forced to be TAG_padding DIES.
3300 Padding DIES must be at least sizeof(long) in length, implying that
3301 if a padding DIE is used for alignment and the amount needed is less
3302 than sizeof(long) then the padding DIE has to be big enough to align
3303 to the next alignment boundry.
3307 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3310 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3312 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3313 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3314 if (dip
-> dielength
< sizeof (long))
3316 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3318 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3320 dip
-> dietag
= TAG_padding
;
3324 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3332 completedieinfo -- finish reading the information for a given DIE
3336 void completedieinfo (struct dieinfo *dip)
3340 Given a pointer to an already partially initialized die info structure,
3341 scan the raw DIE data and finish filling in the die info structure
3342 from the various attributes found.
3344 Note that since there is no guarantee that the data is properly
3345 aligned in memory for the type of access required (indirection
3346 through anything other than a char pointer), we use memcpy to
3347 shuffle data items larger than a char. Possibly inefficient, but
3352 Each time we are called, we increment the diecount variable, which
3353 keeps an approximate count of the number of dies processed for
3354 each compilation unit. This information is presented to the user
3355 if the info_verbose flag is set.
3360 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3362 char *diep
; /* Current pointer into raw DIE data */
3363 char *end
; /* Terminate DIE scan here */
3364 unsigned short attr
; /* Current attribute being scanned */
3365 unsigned short form
; /* Form of the attribute */
3366 short block2sz
; /* Size of a block2 attribute field */
3367 long block4sz
; /* Size of a block4 attribute field */
3371 end
= diep
+ dip
-> dielength
;
3372 diep
+= sizeof (long) + sizeof (short);
3375 (void) memcpy (&attr
, diep
, sizeof (short));
3376 diep
+= sizeof (short);
3380 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3383 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3386 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3389 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3392 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3395 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3396 dip
-> at_stmt_list_p
= 1;
3399 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3402 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3405 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3407 case AT_user_def_type
:
3408 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3411 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3414 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3417 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3420 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3423 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3426 dip
-> at_location
= diep
;
3428 case AT_mod_fund_type
:
3429 dip
-> at_mod_fund_type
= diep
;
3431 case AT_subscr_data
:
3432 dip
-> at_subscr_data
= diep
;
3434 case AT_mod_u_d_type
:
3435 dip
-> at_mod_u_d_type
= diep
;
3438 dip
-> at_deriv_list
= diep
;
3440 case AT_element_list
:
3441 dip
-> at_element_list
= diep
;
3443 case AT_discr_value
:
3444 dip
-> at_discr_value
= diep
;
3446 case AT_string_length
:
3447 dip
-> at_string_length
= diep
;
3450 dip
-> at_name
= diep
;
3453 dip
-> at_comp_dir
= diep
;
3456 dip
-> at_producer
= diep
;
3459 (void) memcpy (&dip
-> at_loclist
, diep
, sizeof (long));
3462 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3465 (void) memcpy (&dip
-> at_incomplete
, diep
, sizeof (short));
3467 case AT_start_scope
:
3468 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3470 case AT_stride_size
:
3471 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3474 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3477 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3480 dip
-> at_const_data
= diep
;
3482 case AT_is_external
:
3483 (void) memcpy (&dip
-> at_is_external
, diep
, sizeof (short));
3484 dip
-> at_is_external_p
= 1;
3487 /* Found an attribute that we are unprepared to handle. However
3488 it is specifically one of the design goals of DWARF that
3489 consumers should ignore unknown attributes. As long as the
3490 form is one that we recognize (so we know how to skip it),
3491 we can just ignore the unknown attribute. */
3498 diep
+= sizeof (short);
3501 diep
+= sizeof (long);
3504 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3508 diep
+= sizeof (long);
3511 (void) memcpy (&block2sz
, diep
, sizeof (short));
3512 block2sz
+= sizeof (short);
3516 (void) memcpy (&block4sz
, diep
, sizeof (long));
3517 block4sz
+= sizeof (long);
3521 diep
+= strlen (diep
) + 1;
3524 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));