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. :-)
81 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
82 #define SQUAWK(stuff) dwarfwarn stuff
87 #ifndef R_FP /* FIXME */
88 #define R_FP 14 /* Kludge to get frame pointer register number */
91 typedef unsigned int DIEREF
; /* Reference to a DIE */
93 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
94 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
96 #define STREQ(a,b) (strcmp(a,b)==0)
98 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
99 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
100 However, the Issue 2 DWARF specification from AT&T defines it as
101 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
102 For backwards compatibility with the AT&T compiler produced executables
103 we define AT_short_element_list for this variant. */
105 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
107 /* External variables referenced. */
109 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
110 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
111 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
112 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
113 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
114 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
115 extern int info_verbose
; /* From main.c; nonzero => verbose */
118 /* The DWARF debugging information consists of two major pieces,
119 one is a block of DWARF Information Entries (DIE's) and the other
120 is a line number table. The "struct dieinfo" structure contains
121 the information for a single DIE, the one currently being processed.
123 In order to make it easier to randomly access the attribute fields
124 of the current DIE, which are specifically unordered within the DIE
125 each DIE is scanned and an instance of the "struct dieinfo"
126 structure is initialized.
128 Initialization is done in two levels. The first, done by basicdieinfo(),
129 just initializes those fields that are vital to deciding whether or not
130 to use this DIE, how to skip past it, etc. The second, done by the
131 function completedieinfo(), fills in the rest of the information.
133 Attributes which have block forms are not interpreted at the time
134 the DIE is scanned, instead we just save pointers to the start
135 of their value fields.
137 Some fields have a flag <name>_p that is set when the value of the
138 field is valid (I.E. we found a matching attribute in the DIE). Since
139 we may want to test for the presence of some attributes in the DIE,
140 such as AT_low_pc, without restricting the values of the field,
141 we need someway to note that we found such an attribute.
148 char * die
; /* Pointer to the raw DIE data */
149 long dielength
; /* Length of the raw DIE data */
150 DIEREF dieref
; /* Offset of this DIE */
151 short dietag
; /* Tag for this DIE */
156 unsigned short at_fund_type
;
157 BLOCK
* at_mod_fund_type
;
158 long at_user_def_type
;
159 BLOCK
* at_mod_u_d_type
;
161 BLOCK
* at_subscr_data
;
165 BLOCK
* at_element_list
;
172 BLOCK
* at_discr_value
;
175 BLOCK
* at_string_length
;
183 unsigned int has_at_low_pc
:1;
184 unsigned int has_at_stmt_list
:1;
185 unsigned int short_element_list
:1;
188 static int diecount
; /* Approximate count of dies for compilation unit */
189 static struct dieinfo
*curdie
; /* For warnings and such */
191 static char *dbbase
; /* Base pointer to dwarf info */
192 static int dbroff
; /* Relative offset from start of .debug section */
193 static char *lnbase
; /* Base pointer to line section */
194 static int isreg
; /* Kludge to identify register variables */
196 static CORE_ADDR baseaddr
; /* Add to each symbol value */
198 /* Each partial symbol table entry contains a pointer to private data for the
199 read_symtab() function to use when expanding a partial symbol table entry
200 to a full symbol table entry. For DWARF debugging info, this data is
201 contained in the following structure and macros are provided for easy
202 access to the members given a pointer to a partial symbol table entry.
204 dbfoff Always the absolute file offset to the start of the ".debug"
205 section for the file containing the DIE's being accessed.
207 dbroff Relative offset from the start of the ".debug" access to the
208 first DIE to be accessed. When building the partial symbol
209 table, this value will be zero since we are accessing the
210 entire ".debug" section. When expanding a partial symbol
211 table entry, this value will be the offset to the first
212 DIE for the compilation unit containing the symbol that
213 triggers the expansion.
215 dblength The size of the chunk of DIE's being examined, in bytes.
217 lnfoff The absolute file offset to the line table fragment. Ignored
218 when building partial symbol tables, but used when expanding
219 them, and contains the absolute file offset to the fragment
220 of the ".line" section containing the line numbers for the
221 current compilation unit.
225 int dbfoff
; /* Absolute file offset to start of .debug section */
226 int dbroff
; /* Relative offset from start of .debug section */
227 int dblength
; /* Size of the chunk of DIE's being examined */
228 int lnfoff
; /* Absolute file offset to line table fragment */
231 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
232 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
233 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
234 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
236 /* Record the symbols defined for each context in a linked list. We don't
237 create a struct block for the context until we know how long to make it.
238 Global symbols for each file are maintained in the global_symbols list. */
240 struct pending_symbol
{
241 struct pending_symbol
*next
; /* Next pending symbol */
242 struct symbol
*symbol
; /* The actual symbol */
245 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
246 static struct block
*global_symbol_block
;
248 /* Line number entries are read into a dynamically expandable vector before
249 being added to the symbol table section. Once we know how many there are
252 static struct linetable
*line_vector
; /* Vector of line numbers. */
253 static int line_vector_index
; /* Index of next entry. */
254 static int line_vector_length
; /* Current allocation limit */
256 /* Scope information is kept in a scope tree, one node per scope. Each time
257 a new scope is started, a child node is created under the current node
258 and set to the current scope. Each time a scope is closed, the current
259 scope moves back up the tree to the parent of the current scope.
261 Each scope contains a pointer to the list of symbols defined in the scope,
262 a pointer to the block vector for the scope, a pointer to the symbol
263 that names the scope (if any), and the range of PC values that mark
264 the start and end of the scope. */
267 struct scopenode
*parent
;
268 struct scopenode
*child
;
269 struct scopenode
*sibling
;
270 struct pending_symbol
*symbols
;
272 struct symbol
*namesym
;
277 static struct scopenode
*scopetree
;
278 static struct scopenode
*scope
;
280 /* DIES which have user defined types or modified user defined types refer to
281 other DIES for the type information. Thus we need to associate the offset
282 of a DIE for a user defined type with a pointer to the type information.
284 Originally this was done using a simple but expensive algorithm, with an
285 array of unsorted structures, each containing an offset/type-pointer pair.
286 This array was scanned linearly each time a lookup was done. The result
287 was that gdb was spending over half it's startup time munging through this
288 array of pointers looking for a structure that had the right offset member.
290 The second attempt used the same array of structures, but the array was
291 sorted using qsort each time a new offset/type was recorded, and a binary
292 search was used to find the type pointer for a given DIE offset. This was
293 even slower, due to the overhead of sorting the array each time a new
294 offset/type pair was entered.
296 The third attempt uses a fixed size array of type pointers, indexed by a
297 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
298 we can divide any DIE offset by 4 to obtain a unique index into this fixed
299 size array. Since each element is a 4 byte pointer, it takes exactly as
300 much memory to hold this array as to hold the DWARF info for a given
301 compilation unit. But it gets freed as soon as we are done with it. */
303 static struct type
**utypes
; /* Pointer to array of user type pointers */
304 static int numutypes
; /* Max number of user type pointers */
306 /* Forward declarations of static functions so we don't have to worry
307 about ordering within this file. The EXFUN macro may be slightly
308 misleading. Should probably be called DCLFUN instead, or something
309 more intuitive, since it can be used for both static and external
313 EXFUN (dwarfwarn
, (char *fmt DOTS
));
316 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
319 EXFUN (scan_compilation_units
,
320 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
321 AND
unsigned int dbfoff AND
unsigned int lnoffset
322 AND
struct objfile
*objfile
));
324 static struct partial_symtab
*
325 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
326 AND
char *filename AND CORE_ADDR textlow
327 AND CORE_ADDR texthigh AND
int dbfoff
328 AND
int curoff AND
int culength AND
int lnfoff
329 AND
struct partial_symbol
*global_syms
330 AND
struct partial_symbol
*static_syms
));
332 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
335 EXFUN(add_psymbol_to_list
,
336 (struct psymbol_allocation_list
*listp AND
char *name
337 AND
enum namespace space AND
enum address_class
class
338 AND CORE_ADDR value
));
341 EXFUN(init_psymbol_list
, (int total_symbols
));
344 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
347 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
350 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
353 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
355 static struct symtab
*
356 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
360 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
363 EXFUN(read_structure_scope
,
364 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
367 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
370 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
373 EXFUN(read_array_type
, (struct dieinfo
*dip
));
376 EXFUN(read_subroutine_type
,
377 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
380 EXFUN(read_enumeration
,
381 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
385 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
388 EXFUN(enum_type
, (struct dieinfo
*dip
));
391 EXFUN(start_symtab
, (void));
395 (char *filename AND
long language AND
struct objfile
*objfile
));
398 EXFUN(scopecount
, (struct scopenode
*node
));
402 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
405 EXFUN(freescope
, (struct scopenode
*node
));
407 static struct block
*
408 EXFUN(buildblock
, (struct pending_symbol
*syms
));
411 EXFUN(closescope
, (void));
414 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
417 EXFUN(decode_line_numbers
, (char *linetable
));
420 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
423 EXFUN(decode_mod_fund_type
, (char *typedata
));
426 EXFUN(decode_mod_u_d_type
, (char *typedata
));
429 EXFUN(decode_modified_type
,
430 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
433 EXFUN(decode_fund_type
, (unsigned short fundtype
));
436 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
439 EXFUN(add_symbol_to_list
,
440 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
442 static struct block
**
443 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
445 static struct blockvector
*
446 EXFUN(make_blockvector
, (void));
449 EXFUN(lookup_utype
, (DIEREF dieref
));
452 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
454 static struct symbol
*
455 EXFUN(new_symbol
, (struct dieinfo
*dip
));
458 EXFUN(locval
, (char *loc
));
461 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
462 enum misc_function_type
));
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,
480 struct objfile *objfile)
484 This function is called upon to build partial symtabs from files
485 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
487 It is passed a file descriptor for an open file containing the DIES
488 and line number information, the corresponding filename for that
489 file, a base address for relocating the symbols, a flag indicating
490 whether or not this debugging information is from a "main symbol
491 table" rather than a shared library or dynamically linked file,
492 and file offset/size pairs for the DIE information and line number
502 DEFUN(dwarf_build_psymtabs
,
503 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
509 unsigned int dbfoff AND
510 unsigned int dbsize AND
511 unsigned int lnoffset AND
512 unsigned int lnsize AND
513 struct objfile
*objfile
)
515 struct cleanup
*back_to
;
517 dbbase
= xmalloc (dbsize
);
519 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
520 (read (desc
, dbbase
, dbsize
) != dbsize
))
523 error ("can't read DWARF data from '%s'", filename
);
525 back_to
= make_cleanup (free
, dbbase
);
527 /* If we are reinitializing, or if we have never loaded syms yet, init.
528 Since we have no idea how many DIES we are looking at, we just guess
529 some arbitrary value. */
531 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
533 init_psymbol_list (1024);
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
,
541 dbfoff
, lnoffset
, objfile
);
543 do_cleanups (back_to
);
551 record_misc_function -- add entry to miscellaneous function vector
555 static void record_misc_function (char *name, CORE_ADDR address,
556 enum misc_function_type mf_type)
560 Given a pointer to the name of a symbol that should be added to the
561 miscellaneous function vector, and the address associated with that
562 symbol, records this information for later use in building the
563 miscellaneous function vector.
568 DEFUN(record_misc_function
, (name
, address
, mf_type
),
569 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
571 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
579 dwarfwarn -- issue a DWARF related warning
583 Issue warnings about DWARF related things that aren't serious enough
584 to warrant aborting with an error, but should not be ignored either.
585 This includes things like detectable corruption in DIE's, missing
586 DIE's, unimplemented features, etc.
588 In general, running across tags or attributes that we don't recognize
589 is not considered to be a problem and we should not issue warnings
594 We mostly follow the example of the error() routine, but without
595 returning to command level. It is arguable about whether warnings
596 should be issued at all, and if so, where they should go (stdout or
599 We assume that curdie is valid and contains at least the basic
600 information for the DIE where the problem was noticed.
605 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
611 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
612 if (curdie
-> at_name
)
614 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
616 vfprintf (stderr
, fmt
, ap
);
617 fprintf (stderr
, "\n");
631 fmt
= va_arg (ap
, char *);
633 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
634 if (curdie
-> at_name
)
636 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
638 vfprintf (stderr
, fmt
, ap
);
639 fprintf (stderr
, "\n");
648 compare_psymbols -- compare two partial symbols by name
652 Given pointer to two partial symbol table entries, compare
653 them by name and return -N, 0, or +N (ala strcmp). Typically
654 used by sorting routines like qsort().
658 This is a copy from dbxread.c. It should be moved to a generic
659 gdb file and made available for all psymtab builders (FIXME).
661 Does direct compare of first two characters before punting
662 and passing to strcmp for longer compares. Note that the
663 original version had a bug whereby two null strings or two
664 identically named one character strings would return the
665 comparison of memory following the null byte.
670 DEFUN(compare_psymbols
, (s1
, s2
),
671 struct partial_symbol
*s1 AND
672 struct partial_symbol
*s2
)
674 register char *st1
= SYMBOL_NAME (s1
);
675 register char *st2
= SYMBOL_NAME (s2
);
677 if ((st1
[0] - st2
[0]) || !st1
[0])
679 return (st1
[0] - st2
[0]);
681 else if ((st1
[1] - st2
[1]) || !st1
[1])
683 return (st1
[1] - st2
[1]);
687 return (strcmp (st1
+ 2, st2
+ 2));
695 read_lexical_block_scope -- process all dies in a lexical block
699 static void read_lexical_block_scope (struct dieinfo *dip,
700 char *thisdie, char *enddie)
704 Process all the DIES contained within a lexical block scope.
705 Start a new scope, process the dies, and then close the scope.
710 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
711 struct dieinfo
*dip AND
714 struct objfile
*objfile
)
716 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
717 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
725 lookup_utype -- look up a user defined type from die reference
729 static type *lookup_utype (DIEREF dieref)
733 Given a DIE reference, lookup the user defined type associated with
734 that DIE, if it has been registered already. If not registered, then
735 return NULL. Alloc_utype() can be called to register an empty
736 type for this reference, which will be filled in later when the
737 actual referenced DIE is processed.
741 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
743 struct type
*type
= NULL
;
746 utypeidx
= (dieref
- dbroff
) / 4;
747 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
749 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
753 type
= *(utypes
+ utypeidx
);
763 alloc_utype -- add a user defined type for die reference
767 static type *alloc_utype (DIEREF dieref, struct type *utypep)
771 Given a die reference DIEREF, and a possible pointer to a user
772 defined type UTYPEP, register that this reference has a user
773 defined type and either use the specified type in UTYPEP or
774 make a new empty type that will be filled in later.
776 We should only be called after calling lookup_utype() to verify that
777 there is not currently a type registered for DIEREF.
781 DEFUN(alloc_utype
, (dieref
, utypep
),
788 utypeidx
= (dieref
- dbroff
) / 4;
789 typep
= utypes
+ utypeidx
;
790 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
792 utypep
= builtin_type_int
;
793 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
795 else if (*typep
!= NULL
)
798 SQUAWK (("internal error: dup user type allocation"));
804 utypep
= (struct type
*)
805 obstack_alloc (symbol_obstack
, sizeof (struct type
));
806 (void) memset (utypep
, 0, sizeof (struct type
));
817 decode_die_type -- return a type for a specified die
821 static struct type *decode_die_type (struct dieinfo *dip)
825 Given a pointer to a die information structure DIP, decode the
826 type of the die and return a pointer to the decoded type. All
827 dies without specific types default to type int.
831 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
833 struct type
*type
= NULL
;
835 if (dip
-> at_fund_type
!= 0)
837 type
= decode_fund_type (dip
-> at_fund_type
);
839 else if (dip
-> at_mod_fund_type
!= NULL
)
841 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
843 else if (dip
-> at_user_def_type
)
845 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
847 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
850 else if (dip
-> at_mod_u_d_type
)
852 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
856 type
= builtin_type_int
;
865 struct_type -- compute and return the type for a struct or union
869 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
874 Given pointer to a die information structure for a die which
875 defines a union or structure, and pointers to the raw die data
876 that define the range of dies which define the members, compute
877 and return the user defined type for the structure or union.
881 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
882 struct dieinfo
*dip AND
888 struct nextfield
*next
;
891 struct nextfield
*list
= NULL
;
892 struct nextfield
*new;
900 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
902 type
= alloc_utype (dip
-> dieref
, NULL
);
904 if (dip
-> dietag
== TAG_structure_type
|| dip
-> dietag
== TAG_union_type
)
906 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
907 obstack_alloc (symbol_obstack
, sizeof (struct cplus_struct_type
));
908 (void) memset (TYPE_CPLUS_SPECIFIC (type
), 0,
909 sizeof (struct cplus_struct_type
));
910 if (dip
-> dietag
== TAG_structure_type
)
912 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
917 TYPE_CODE (type
) = TYPE_CODE_UNION
;
924 SQUAWK (("missing structure or union tag"));
925 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
927 /* Some compilers try to be helpful by inventing "fake" names for anonymous
928 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
929 if (dip
-> at_name
== NULL
930 || *dip
-> at_name
== '~'
931 || *dip
-> at_name
== '.')
937 tpart2
= dip
-> at_name
;
939 if (dip
-> at_byte_size
== 0)
941 tpart3
= " <opaque>";
943 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
946 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
947 thisdie
+= dip
-> dielength
;
948 while (thisdie
< enddie
)
950 basicdieinfo (&mbr
, thisdie
);
951 completedieinfo (&mbr
);
952 if (mbr
.dielength
<= sizeof (long))
959 /* Get space to record the next field's data. */
960 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
964 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
965 list
-> field
.type
= decode_die_type (&mbr
);
966 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
967 list
-> field
.bitsize
= 0;
971 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
974 thisdie
+= mbr
.dielength
;
976 /* Now create the vector of fields, and record how big it is. */
977 TYPE_NFIELDS (type
) = nfields
;
978 TYPE_FIELDS (type
) = (struct field
*)
979 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
980 /* Copy the saved-up fields into the field vector. */
981 for (n
= nfields
; list
; list
= list
-> next
)
983 TYPE_FIELD (type
, --n
) = list
-> field
;
992 read_structure_scope -- process all dies within struct or union
996 static void read_structure_scope (struct dieinfo *dip,
997 char *thisdie, char *enddie)
1001 Called when we find the DIE that starts a structure or union
1002 scope (definition) to process all dies that define the members
1003 of the structure or union. DIP is a pointer to the die info
1004 struct for the DIE that names the structure or union.
1008 Note that we need to call struct_type regardless of whether or not
1009 we have a symbol, since we might have a structure or union without
1010 a tag name (thus no symbol for the tagname).
1014 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
1015 struct dieinfo
*dip AND
1022 type
= struct_type (dip
, thisdie
, enddie
);
1023 if ((sym
= new_symbol (dip
)) != NULL
)
1025 SYMBOL_TYPE (sym
) = type
;
1033 decode_array_element_type -- decode type of the array elements
1037 static struct type *decode_array_element_type (char *scan, char *end)
1041 As the last step in decoding the array subscript information for an
1042 array DIE, we need to decode the type of the array elements. We are
1043 passed a pointer to this last part of the subscript information and
1044 must return the appropriate type. If the type attribute is not
1045 recognized, just warn about the problem and return type int.
1048 static struct type
*
1049 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1054 unsigned short fundtype
;
1056 (void) memcpy (&attribute
, scan
, sizeof (short));
1057 scan
+= sizeof (short);
1061 (void) memcpy (&fundtype
, scan
, sizeof (short));
1062 typep
= decode_fund_type (fundtype
);
1064 case AT_mod_fund_type
:
1065 typep
= decode_mod_fund_type (scan
);
1067 case AT_user_def_type
:
1068 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1069 if ((typep
= lookup_utype (dieref
)) == NULL
)
1071 typep
= alloc_utype (dieref
, NULL
);
1074 case AT_mod_u_d_type
:
1075 typep
= decode_mod_u_d_type (scan
);
1078 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1079 typep
= builtin_type_int
;
1089 decode_subscr_data -- decode array subscript and element type data
1093 static struct type *decode_subscr_data (char *scan, char *end)
1097 The array subscripts and the data type of the elements of an
1098 array are described by a list of data items, stored as a block
1099 of contiguous bytes. There is a data item describing each array
1100 dimension, and a final data item describing the element type.
1101 The data items are ordered the same as their appearance in the
1102 source (I.E. leftmost dimension first, next to leftmost second,
1105 We are passed a pointer to the start of the block of bytes
1106 containing the data items, and a pointer to the first byte past
1107 the data. This function decodes the data and returns a type.
1110 FIXME: This code only implements the forms currently used
1111 by the AT&T and GNU C compilers.
1113 The end pointer is supplied for error checking, maybe we should
1117 static struct type
*
1118 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1120 struct type
*typep
= NULL
;
1121 struct type
*nexttype
;
1131 typep
= decode_array_element_type (scan
, end
);
1134 (void) memcpy (&fundtype
, scan
, sizeof (short));
1135 scan
+= sizeof (short);
1136 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1137 && fundtype
!= FT_unsigned_integer
)
1139 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1144 (void) memcpy (&lowbound
, scan
, sizeof (long));
1145 scan
+= sizeof (long);
1146 (void) memcpy (&highbound
, scan
, sizeof (long));
1147 scan
+= sizeof (long);
1148 nexttype
= decode_subscr_data (scan
, end
);
1149 if (nexttype
!= NULL
)
1151 typep
= (struct type
*)
1152 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1153 (void) memset (typep
, 0, sizeof (struct type
));
1154 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1155 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1156 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1157 TYPE_TARGET_TYPE (typep
) = nexttype
;
1168 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1171 SQUAWK (("unknown array subscript format %x", format
));
1181 read_array_type -- read TAG_array_type DIE
1185 static void read_array_type (struct dieinfo *dip)
1189 Extract all information from a TAG_array_type DIE and add to
1190 the user defined type vector.
1194 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1201 if (dip
-> at_ordering
!= ORD_row_major
)
1203 /* FIXME: Can gdb even handle column major arrays? */
1204 SQUAWK (("array not row major; not handled correctly"));
1206 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1208 (void) memcpy (&temp
, sub
, sizeof (short));
1209 subend
= sub
+ sizeof (short) + temp
;
1210 sub
+= sizeof (short);
1211 type
= decode_subscr_data (sub
, subend
);
1214 type
= alloc_utype (dip
-> dieref
, NULL
);
1215 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1216 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1217 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1221 type
= alloc_utype (dip
-> dieref
, type
);
1230 read_subroutine_type -- process TAG_subroutine_type dies
1234 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1239 Handle DIES due to C code like:
1242 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1248 The parameter DIES are currently ignored. See if gdb has a way to
1249 include this info in it's type system, and decode them if so. Is
1250 this what the type structure's "arg_types" field is for? (FIXME)
1254 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1255 struct dieinfo
*dip AND
1261 type
= decode_die_type (dip
);
1262 type
= lookup_function_type (type
);
1263 type
= alloc_utype (dip
-> dieref
, type
);
1270 read_enumeration -- process dies which define an enumeration
1274 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1279 Given a pointer to a die which begins an enumeration, process all
1280 the dies that define the members of the enumeration.
1284 Note that we need to call enum_type regardless of whether or not we
1285 have a symbol, since we might have an enum without a tag name (thus
1286 no symbol for the tagname).
1290 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1291 struct dieinfo
*dip AND
1298 type
= enum_type (dip
);
1299 if ((sym
= new_symbol (dip
)) != NULL
)
1301 SYMBOL_TYPE (sym
) = type
;
1309 enum_type -- decode and return a type for an enumeration
1313 static type *enum_type (struct dieinfo *dip)
1317 Given a pointer to a die information structure for the die which
1318 starts an enumeration, process all the dies that define the members
1319 of the enumeration and return a type pointer for the enumeration.
1322 static struct type
*
1323 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1327 struct nextfield
*next
;
1330 struct nextfield
*list
= NULL
;
1331 struct nextfield
*new;
1342 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1344 type
= alloc_utype (dip
-> dieref
, NULL
);
1346 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1348 /* Some compilers try to be helpful by inventing "fake" names for anonymous
1349 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
1350 if (dip
-> at_name
== NULL
1351 || *dip
-> at_name
== '~'
1352 || *dip
-> at_name
== '.')
1356 tpart2
= dip
-> at_name
;
1358 if (dip
-> at_byte_size
== 0)
1360 tpart3
= " <opaque>";
1364 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1367 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
1368 if ((scan
= dip
-> at_element_list
) != NULL
)
1370 if (dip
-> short_element_list
)
1372 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1373 listend
= scan
+ stemp
+ sizeof (stemp
);
1374 scan
+= sizeof (stemp
);
1378 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1379 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1380 scan
+= sizeof (ltemp
);
1382 while (scan
< listend
)
1384 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1387 list
-> field
.type
= NULL
;
1388 list
-> field
.bitsize
= 0;
1389 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1390 scan
+= sizeof (long);
1391 list
-> field
.name
= savestring (scan
, strlen (scan
));
1392 scan
+= strlen (scan
) + 1;
1396 /* Now create the vector of fields, and record how big it is. */
1397 TYPE_NFIELDS (type
) = nfields
;
1398 TYPE_FIELDS (type
) = (struct field
*)
1399 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1400 /* Copy the saved-up fields into the field vector. */
1401 for (n
= nfields
; list
; list
= list
-> next
)
1403 TYPE_FIELD (type
, --n
) = list
-> field
;
1412 read_func_scope -- process all dies within a function scope
1416 Process all dies within a given function scope. We are passed
1417 a die information structure pointer DIP for the die which
1418 starts the function scope, and pointers into the raw die data
1419 that define the dies within the function scope.
1421 For now, we ignore lexical block scopes within the function.
1422 The problem is that AT&T cc does not define a DWARF lexical
1423 block scope for the function itself, while gcc defines a
1424 lexical block scope for the function. We need to think about
1425 how to handle this difference, or if it is even a problem.
1430 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1431 struct dieinfo
*dip AND
1434 struct objfile
*objfile
)
1438 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1440 entry_scope_lowpc
= dip
-> at_low_pc
;
1441 entry_scope_highpc
= dip
-> at_high_pc
;
1443 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1445 main_scope_lowpc
= dip
-> at_low_pc
;
1446 main_scope_highpc
= dip
-> at_high_pc
;
1448 sym
= new_symbol (dip
);
1449 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1450 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1458 read_file_scope -- process all dies within a file scope
1462 Process all dies within a given file scope. We are passed a
1463 pointer to the die information structure for the die which
1464 starts the file scope, and pointers into the raw die data which
1465 mark the range of dies within the file scope.
1467 When the partial symbol table is built, the file offset for the line
1468 number table for each compilation unit is saved in the partial symbol
1469 table entry for that compilation unit. As the symbols for each
1470 compilation unit are read, the line number table is read into memory
1471 and the variable lnbase is set to point to it. Thus all we have to
1472 do is use lnbase to access the line number table for the current
1477 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1478 struct dieinfo
*dip AND
1481 struct objfile
*objfile
)
1483 struct cleanup
*back_to
;
1485 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1487 startup_file_start
= dip
-> at_low_pc
;
1488 startup_file_end
= dip
-> at_high_pc
;
1490 numutypes
= (enddie
- thisdie
) / 4;
1491 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1492 back_to
= make_cleanup (free
, utypes
);
1493 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1495 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1496 decode_line_numbers (lnbase
);
1497 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1499 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1500 do_cleanups (back_to
);
1509 start_symtab -- do initialization for starting new symbol table
1513 static void start_symtab (void)
1517 Called whenever we are starting to process dies for a new
1518 compilation unit, to perform initializations. Right now
1519 the only thing we really have to do is initialize storage
1520 space for the line number vector.
1525 DEFUN_VOID (start_symtab
)
1529 line_vector_index
= 0;
1530 line_vector_length
= 1000;
1531 nbytes
= sizeof (struct linetable
);
1532 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1533 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1540 process_dies -- process a range of DWARF Information Entries
1544 static void process_dies (char *thisdie, char *enddie)
1548 Process all DIE's in a specified range. May be (and almost
1549 certainly will be) called recursively.
1553 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1554 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1559 while (thisdie
< enddie
)
1561 basicdieinfo (&di
, thisdie
);
1562 if (di
.dielength
< sizeof (long))
1566 else if (di
.dietag
== TAG_padding
)
1568 nextdie
= thisdie
+ di
.dielength
;
1572 completedieinfo (&di
);
1573 if (di
.at_sibling
!= 0)
1575 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1579 nextdie
= thisdie
+ di
.dielength
;
1583 case TAG_compile_unit
:
1584 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1586 case TAG_global_subroutine
:
1587 case TAG_subroutine
:
1588 if (di
.has_at_low_pc
)
1590 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1593 case TAG_lexical_block
:
1594 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1596 case TAG_structure_type
:
1597 case TAG_union_type
:
1598 read_structure_scope (&di
, thisdie
, nextdie
);
1600 case TAG_enumeration_type
:
1601 read_enumeration (&di
, thisdie
, nextdie
);
1603 case TAG_subroutine_type
:
1604 read_subroutine_type (&di
, thisdie
, nextdie
);
1606 case TAG_array_type
:
1607 read_array_type (&di
);
1610 (void) new_symbol (&di
);
1622 end_symtab -- finish processing for a compilation unit
1626 static void end_symtab (char *filename, long language)
1630 Complete the symbol table entry for the current compilation
1631 unit. Make the struct symtab and put it on the list of all
1637 DEFUN(end_symtab
, (filename
, language
, objfile
),
1638 char *filename AND
long language AND
struct objfile
*objfile
)
1640 struct symtab
*symtab
;
1641 struct blockvector
*blockvector
;
1644 /* Ignore a file that has no functions with real debugging info. */
1645 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1649 line_vector_length
= -1;
1650 freescope (scopetree
);
1651 scope
= scopetree
= NULL
;
1654 /* Create the blockvector that points to all the file's blocks. */
1656 blockvector
= make_blockvector ();
1658 /* Now create the symtab object for this source file. */
1660 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1663 symtab
-> free_ptr
= 0;
1665 /* Fill in its components. */
1666 symtab
-> blockvector
= blockvector
;
1667 symtab
-> free_code
= free_linetable
;
1669 /* Save the line number information. */
1671 line_vector
-> nitems
= line_vector_index
;
1672 nbytes
= sizeof (struct linetable
);
1673 if (line_vector_index
> 1)
1675 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1677 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1679 /* FIXME: The following may need to be expanded for other languages */
1684 symtab
-> language
= language_c
;
1686 case LANG_C_PLUS_PLUS
:
1687 symtab
-> language
= language_cplus
;
1693 /* Link the new symtab into the list of such. */
1694 symtab
-> next
= symtab_list
;
1695 symtab_list
= symtab
;
1697 /* Recursively free the scope tree */
1698 freescope (scopetree
);
1699 scope
= scopetree
= NULL
;
1701 /* Reinitialize for beginning of new file. */
1703 line_vector_length
= -1;
1710 scopecount -- count the number of enclosed scopes
1714 static int scopecount (struct scopenode *node)
1718 Given pointer to a node, compute the size of the subtree which is
1719 rooted in this node, which also happens to be the number of scopes
1724 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1730 count
+= scopecount (node
-> child
);
1731 count
+= scopecount (node
-> sibling
);
1741 openscope -- start a new lexical block scope
1745 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1750 Start a new scope by allocating a new scopenode, adding it as the
1751 next child of the current scope (if any) or as the root of the
1752 scope tree, and then making the new node the current scope node.
1756 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1757 struct symbol
*namesym AND
1761 struct scopenode
*new;
1762 struct scopenode
*child
;
1764 new = (struct scopenode
*) xmalloc (sizeof (*new));
1765 (void) memset (new, 0, sizeof (*new));
1766 new -> namesym
= namesym
;
1767 new -> lowpc
= lowpc
;
1768 new -> highpc
= highpc
;
1773 else if ((child
= scope
-> child
) == NULL
)
1775 scope
-> child
= new;
1776 new -> parent
= scope
;
1780 while (child
-> sibling
!= NULL
)
1782 child
= child
-> sibling
;
1784 child
-> sibling
= new;
1785 new -> parent
= scope
;
1794 freescope -- free a scope tree rooted at the given node
1798 static void freescope (struct scopenode *node)
1802 Given a pointer to a node in the scope tree, free the subtree
1803 rooted at that node. First free all the children and sibling
1804 nodes, and then the node itself. Used primarily for cleaning
1805 up after ourselves and returning memory to the system.
1809 DEFUN(freescope
, (node
), struct scopenode
*node
)
1813 freescope (node
-> child
);
1814 freescope (node
-> sibling
);
1823 buildblock -- build a new block from pending symbols list
1827 static struct block *buildblock (struct pending_symbol *syms)
1831 Given a pointer to a list of symbols, build a new block and free
1832 the symbol list structure. Also check each symbol to see if it
1833 is the special symbol that flags that this block was compiled by
1834 gcc, and if so, mark the block appropriately.
1837 static struct block
*
1838 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1840 struct pending_symbol
*next
, *next1
;
1842 struct block
*newblock
;
1845 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1847 /* Allocate a new block */
1849 nbytes
= sizeof (struct block
);
1852 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1854 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1855 (void) memset (newblock
, 0, nbytes
);
1857 /* Copy the symbols into the block. */
1859 BLOCK_NSYMS (newblock
) = i
;
1860 for (next
= syms
; next
; next
= next
-> next
)
1862 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1863 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1864 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1866 BLOCK_GCC_COMPILED (newblock
) = 1;
1870 /* Now free the links of the list, and empty the list. */
1872 for (next
= syms
; next
; next
= next1
)
1874 next1
= next
-> next
;
1885 closescope -- close a lexical block scope
1889 static void closescope (void)
1893 Close the current lexical block scope. Closing the current scope
1894 is as simple as moving the current scope pointer up to the parent
1895 of the current scope pointer. But we also take this opportunity
1896 to build the block for the current scope first, since we now have
1897 all of it's symbols.
1901 DEFUN_VOID(closescope
)
1903 struct scopenode
*child
;
1907 error ("DWARF parse error, too many close scopes");
1911 if (scope
-> parent
== NULL
)
1913 global_symbol_block
= buildblock (global_symbols
);
1914 global_symbols
= NULL
;
1915 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1916 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1918 scope
-> block
= buildblock (scope
-> symbols
);
1919 scope
-> symbols
= NULL
;
1920 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1921 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1923 /* Put the local block in as the value of the symbol that names it. */
1925 if (scope
-> namesym
)
1927 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1928 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1931 /* Install this scope's local block as the superblock of all child
1934 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1936 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1939 scope
= scope
-> parent
;
1947 record_line -- record a line number entry in the line vector
1951 static void record_line (int line, CORE_ADDR pc)
1955 Given a line number and the corresponding pc value, record
1956 this pair in the line number vector, expanding the vector as
1961 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1963 struct linetable_entry
*e
;
1966 /* Make sure line vector is big enough. */
1968 if (line_vector_index
+ 2 >= line_vector_length
)
1970 line_vector_length
*= 2;
1971 nbytes
= sizeof (struct linetable
);
1972 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1973 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1975 e
= line_vector
-> item
+ line_vector_index
++;
1984 decode_line_numbers -- decode a line number table fragment
1988 static void decode_line_numbers (char *tblscan, char *tblend,
1989 long length, long base, long line, long pc)
1993 Translate the DWARF line number information to gdb form.
1995 The ".line" section contains one or more line number tables, one for
1996 each ".line" section from the objects that were linked.
1998 The AT_stmt_list attribute for each TAG_source_file entry in the
1999 ".debug" section contains the offset into the ".line" section for the
2000 start of the table for that file.
2002 The table itself has the following structure:
2004 <table length><base address><source statement entry>
2005 4 bytes 4 bytes 10 bytes
2007 The table length is the total size of the table, including the 4 bytes
2008 for the length information.
2010 The base address is the address of the first instruction generated
2011 for the source file.
2013 Each source statement entry has the following structure:
2015 <line number><statement position><address delta>
2016 4 bytes 2 bytes 4 bytes
2018 The line number is relative to the start of the file, starting with
2021 The statement position either -1 (0xFFFF) or the number of characters
2022 from the beginning of the line to the beginning of the statement.
2024 The address delta is the difference between the base address and
2025 the address of the first instruction for the statement.
2027 Note that we must copy the bytes from the packed table to our local
2028 variables before attempting to use them, to avoid alignment problems
2029 on some machines, particularly RISC processors.
2033 Does gdb expect the line numbers to be sorted? They are now by
2034 chance/luck, but are not required to be. (FIXME)
2036 The line with number 0 is unused, gdb apparently can discover the
2037 span of the last line some other way. How? (FIXME)
2041 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2050 if (linetable
!= NULL
)
2052 tblscan
= tblend
= linetable
;
2053 (void) memcpy (&length
, tblscan
, sizeof (long));
2054 tblscan
+= sizeof (long);
2056 (void) memcpy (&base
, tblscan
, sizeof (long));
2058 tblscan
+= sizeof (long);
2059 while (tblscan
< tblend
)
2061 (void) memcpy (&line
, tblscan
, sizeof (long));
2062 tblscan
+= sizeof (long) + sizeof (short);
2063 (void) memcpy (&pc
, tblscan
, sizeof (long));
2064 tblscan
+= sizeof (long);
2068 record_line (line
, pc
);
2078 add_symbol_to_list -- add a symbol to head of current symbol list
2082 static void add_symbol_to_list (struct symbol *symbol, struct
2083 pending_symbol **listhead)
2087 Given a pointer to a symbol and a pointer to a pointer to a
2088 list of symbols, add this symbol as the current head of the
2089 list. Typically used for example to add a symbol to the
2090 symbol list for the current scope.
2095 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2096 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2098 struct pending_symbol
*link
;
2102 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2103 link
-> next
= *listhead
;
2104 link
-> symbol
= symbol
;
2113 gatherblocks -- walk a scope tree and build block vectors
2117 static struct block **gatherblocks (struct block **dest,
2118 struct scopenode *node)
2122 Recursively walk a scope tree rooted in the given node, adding blocks
2123 to the array pointed to by DEST, in preorder. I.E., first we add the
2124 block for the current scope, then all the blocks for child scopes,
2125 and finally all the blocks for sibling scopes.
2128 static struct block
**
2129 DEFUN(gatherblocks
, (dest
, node
),
2130 struct block
**dest AND
struct scopenode
*node
)
2134 *dest
++ = node
-> block
;
2135 dest
= gatherblocks (dest
, node
-> child
);
2136 dest
= gatherblocks (dest
, node
-> sibling
);
2145 make_blockvector -- make a block vector from current scope tree
2149 static struct blockvector *make_blockvector (void)
2153 Make a blockvector from all the blocks in the current scope tree.
2154 The first block is always the global symbol block, followed by the
2155 block for the root of the scope tree which is the local symbol block,
2156 followed by all the remaining blocks in the scope tree, which are all
2161 Note that since the root node of the scope tree is created at the time
2162 each file scope is entered, there are always at least two blocks,
2163 neither of which may have any symbols, but always contribute a block
2164 to the block vector. So the test for number of blocks greater than 1
2165 below is unnecessary given bug free code.
2167 The resulting block structure varies slightly from that produced
2168 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2169 with dbxread.c, block 1 is a child of block 0. This does not
2170 seem to cause any problems, but probably should be fixed. (FIXME)
2173 static struct blockvector
*
2174 DEFUN_VOID(make_blockvector
)
2176 struct blockvector
*blockvector
= NULL
;
2180 /* Recursively walk down the tree, counting the number of blocks.
2181 Then add one to account for the global's symbol block */
2183 i
= scopecount (scopetree
) + 1;
2184 nbytes
= sizeof (struct blockvector
);
2187 nbytes
+= (i
- 1) * sizeof (struct block
*);
2189 blockvector
= (struct blockvector
*)
2190 obstack_alloc (symbol_obstack
, nbytes
);
2192 /* Copy the blocks into the blockvector. */
2194 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2195 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2196 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2198 return (blockvector
);
2205 locval -- compute the value of a location attribute
2209 static int locval (char *loc)
2213 Given pointer to a string of bytes that define a location, compute
2214 the location and return the value.
2216 When computing values involving the current value of the frame pointer,
2217 the value zero is used, which results in a value relative to the frame
2218 pointer, rather than the absolute value. This is what GDB wants
2221 When the result is a register number, the global isreg flag is set,
2222 otherwise it is cleared. This is a kludge until we figure out a better
2223 way to handle the problem. Gdb's design does not mesh well with the
2224 DWARF notion of a location computing interpreter, which is a shame
2225 because the flexibility goes unused.
2229 Note that stack[0] is unused except as a default error return.
2230 Note that stack overflow is not yet handled.
2234 DEFUN(locval
, (loc
), char *loc
)
2236 unsigned short nbytes
;
2242 (void) memcpy (&nbytes
, loc
, sizeof (short));
2243 end
= loc
+ sizeof (short) + nbytes
;
2247 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2255 /* push register (number) */
2256 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2260 /* push value of register (number) */
2261 /* Actually, we compute the value as if register has 0 */
2262 (void) memcpy (®no
, loc
, sizeof (long));
2265 stack
[++stacki
] = 0;
2269 stack
[++stacki
] = 0;
2270 SQUAWK (("BASEREG %d not handled!", regno
));
2274 /* push address (relocated address) */
2275 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2278 /* push constant (number) */
2279 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2282 /* pop, deref and push 2 bytes (as a long) */
2283 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2285 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2286 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2288 case OP_ADD
: /* pop top 2 items, add, push result */
2289 stack
[stacki
- 1] += stack
[stacki
];
2294 return (stack
[stacki
]);
2301 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2305 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2309 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2312 static struct symtab
*
2313 DEFUN(read_ofile_symtab
, (pst
),
2314 struct partial_symtab
*pst
)
2316 struct cleanup
*back_to
;
2319 bfd
*abfd
= pst
->objfile
->obfd
;
2321 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2322 unit, seek to the location in the file, and read in all the DIE's. */
2325 dbbase
= xmalloc (DBLENGTH(pst
));
2326 dbroff
= DBROFF(pst
);
2327 foffset
= DBFOFF(pst
) + dbroff
;
2328 if (bfd_seek (abfd
, foffset
, 0) ||
2329 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2332 error ("can't read DWARF data");
2334 back_to
= make_cleanup (free
, dbbase
);
2336 /* If there is a line number table associated with this compilation unit
2337 then read the first long word from the line number table fragment, which
2338 contains the size of the fragment in bytes (including the long word
2339 itself). Allocate a buffer for the fragment and read it in for future
2345 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2346 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2348 error ("can't read DWARF line number table size");
2350 lnbase
= xmalloc (lnsize
);
2351 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2352 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2355 error ("can't read DWARF line numbers");
2357 make_cleanup (free
, lnbase
);
2360 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2361 do_cleanups (back_to
);
2362 return (symtab_list
);
2369 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2373 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2377 Called once for each partial symbol table entry that needs to be
2378 expanded into a full symbol table entry.
2383 DEFUN(psymtab_to_symtab_1
,
2385 struct partial_symtab
*pst
)
2395 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2400 /* Read in all partial symtabs on which this one is dependent */
2401 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2402 if (!pst
-> dependencies
[i
] -> readin
)
2404 /* Inform about additional files that need to be read in. */
2407 fputs_filtered (" ", stdout
);
2409 fputs_filtered ("and ", stdout
);
2411 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2412 wrap_here (""); /* Flush output */
2415 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2418 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2420 /* Init stuff necessary for reading in symbols */
2421 pst
-> symtab
= read_ofile_symtab (pst
);
2424 printf_filtered ("%d DIE's, sorting...", diecount
);
2427 sort_symtab_syms (pst
-> symtab
);
2436 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2440 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2444 This is the DWARF support entry point for building a full symbol
2445 table entry from a partial symbol table entry. We are passed a
2446 pointer to the partial symbol table entry that needs to be expanded.
2451 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2460 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2465 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2467 /* Print the message now, before starting serious work, to avoid
2468 disconcerting pauses. */
2471 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2475 psymtab_to_symtab_1 (pst
);
2477 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2478 we need to do an equivalent or is this something peculiar to
2479 stabs/a.out format. */
2480 /* Match with global symbols. This only needs to be done once,
2481 after all of the symtabs and dependencies have been read in. */
2482 scan_file_globals ();
2485 /* Finish up the debug error message. */
2488 printf_filtered ("done.\n");
2497 init_psymbol_list -- initialize storage for partial symbols
2501 static void init_psymbol_list (int total_symbols)
2505 Initializes storage for all of the partial symbols that will be
2506 created by dwarf_build_psymtabs and subsidiaries.
2510 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2512 /* Free any previously allocated psymbol lists. */
2514 if (global_psymbols
.list
)
2516 free (global_psymbols
.list
);
2518 if (static_psymbols
.list
)
2520 free (static_psymbols
.list
);
2523 /* Current best guess is that there are approximately a twentieth
2524 of the total symbols (in a debugging file) are global or static
2527 global_psymbols
.size
= total_symbols
/ 10;
2528 static_psymbols
.size
= total_symbols
/ 10;
2529 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2530 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2531 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2532 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2539 start_psymtab -- allocate and partially fill a partial symtab entry
2543 Allocate and partially fill a partial symtab. It will be completely
2544 filled at the end of the symbol list.
2546 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2547 ADDR is the address relative to which its symbols are (incremental)
2548 or 0 (normal). FILENAME is the name of the compilation unit that
2549 these symbols were defined in, and they appear starting a address
2550 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2551 the full symbols can be read for compilation unit FILENAME.
2552 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2557 static struct partial_symtab
*
2558 DEFUN(start_psymtab
,
2559 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2560 culength
, lnfoff
, global_syms
, static_syms
),
2561 struct objfile
*objfile AND
2564 CORE_ADDR textlow AND
2565 CORE_ADDR texthigh AND
2570 struct partial_symbol
*global_syms AND
2571 struct partial_symbol
*static_syms
)
2573 struct partial_symtab
*result
;
2575 result
= (struct partial_symtab
*)
2576 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2577 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2578 result
-> addr
= addr
;
2579 result
-> objfile
= objfile
;
2580 result
-> filename
= create_name (filename
, psymbol_obstack
);
2581 result
-> textlow
= textlow
;
2582 result
-> texthigh
= texthigh
;
2583 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2584 sizeof (struct dwfinfo
));
2585 DBFOFF (result
) = dbfoff
;
2586 DBROFF (result
) = curoff
;
2587 DBLENGTH (result
) = culength
;
2588 LNFOFF (result
) = lnfoff
;
2589 result
-> readin
= 0;
2590 result
-> symtab
= NULL
;
2591 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2592 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2593 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2595 result
->n_global_syms
= 0;
2596 result
->n_static_syms
= 0;
2605 add_psymbol_to_list -- add a partial symbol to given list
2609 Add a partial symbol to one of the partial symbol vectors (pointed to
2610 by listp). The vector is grown as necessary.
2615 DEFUN(add_psymbol_to_list
,
2616 (listp
, name
, space
, class, value
),
2617 struct psymbol_allocation_list
*listp AND
2619 enum namespace space AND
2620 enum address_class
class AND
2623 struct partial_symbol
*psym
;
2626 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2628 newsize
= listp
-> size
* 2;
2629 listp
-> list
= (struct partial_symbol
*)
2630 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2631 /* Next assumes we only went one over. Should be good if program works
2633 listp
-> next
= listp
-> list
+ listp
-> size
;
2634 listp
-> size
= newsize
;
2636 psym
= listp
-> next
++;
2637 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2638 SYMBOL_NAMESPACE (psym
) = space
;
2639 SYMBOL_CLASS (psym
) = class;
2640 SYMBOL_VALUE (psym
) = value
;
2647 add_partial_symbol -- add symbol to partial symbol table
2651 Given a DIE, if it is one of the types that we want to
2652 add to a partial symbol table, finish filling in the die info
2653 and then add a partial symbol table entry for it.
2658 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2660 switch (dip
-> dietag
)
2662 case TAG_global_subroutine
:
2663 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2664 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2665 LOC_BLOCK
, dip
-> at_low_pc
);
2667 case TAG_global_variable
:
2668 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2670 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2673 case TAG_subroutine
:
2674 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2675 LOC_BLOCK
, dip
-> at_low_pc
);
2677 case TAG_local_variable
:
2678 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2682 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2685 case TAG_structure_type
:
2686 case TAG_union_type
:
2687 case TAG_enumeration_type
:
2688 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2698 scan_partial_symbols -- scan DIE's within a single compilation unit
2702 Process the DIE's within a single compilation unit, looking for
2703 interesting DIE's that contribute to the partial symbol table entry
2704 for this compilation unit. Since we cannot follow any sibling
2705 chains without reading the complete DIE info for every DIE,
2706 it is probably faster to just sequentially check each one to
2707 see if it is one of the types we are interested in, and if
2708 so, then extracting all the attributes info and generating a
2709 partial symbol table entry.
2713 Don't attempt to add anonymous structures, unions, or enumerations
2714 since they have no name. Also, for variables and subroutines,
2715 check that this is the place where the actual definition occurs,
2716 rather than just a reference to an external.
2721 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2726 while (thisdie
< enddie
)
2728 basicdieinfo (&di
, thisdie
);
2729 if (di
.dielength
< sizeof (long))
2735 nextdie
= thisdie
+ di
.dielength
;
2738 case TAG_global_subroutine
:
2739 case TAG_subroutine
:
2740 case TAG_global_variable
:
2741 case TAG_local_variable
:
2742 completedieinfo (&di
);
2743 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2745 add_partial_symbol (&di
);
2749 case TAG_structure_type
:
2750 case TAG_union_type
:
2751 case TAG_enumeration_type
:
2752 completedieinfo (&di
);
2755 add_partial_symbol (&di
);
2768 scan_compilation_units -- build a psymtab entry for each compilation
2772 This is the top level dwarf parsing routine for building partial
2775 It scans from the beginning of the DWARF table looking for the first
2776 TAG_compile_unit DIE, and then follows the sibling chain to locate
2777 each additional TAG_compile_unit DIE.
2779 For each TAG_compile_unit DIE it creates a partial symtab structure,
2780 calls a subordinate routine to collect all the compilation unit's
2781 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2782 new partial symtab structure into the partial symbol table. It also
2783 records the appropriate information in the partial symbol table entry
2784 to allow the chunk of DIE's and line number table for this compilation
2785 unit to be located and re-read later, to generate a complete symbol
2786 table entry for the compilation unit.
2788 Thus it effectively partitions up a chunk of DIE's for multiple
2789 compilation units into smaller DIE chunks and line number tables,
2790 and associates them with a partial symbol table entry.
2794 If any compilation unit has no line number table associated with
2795 it for some reason (a missing at_stmt_list attribute, rather than
2796 just one with a value of zero, which is valid) then we ensure that
2797 the recorded file offset is zero so that the routine which later
2798 reads line number table fragments knows that there is no fragment
2808 DEFUN(scan_compilation_units
,
2809 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2814 unsigned int dbfoff AND
2815 unsigned int lnoffset AND
2816 struct objfile
*objfile
)
2820 struct partial_symtab
*pst
;
2825 while (thisdie
< enddie
)
2827 basicdieinfo (&di
, thisdie
);
2828 if (di
.dielength
< sizeof (long))
2832 else if (di
.dietag
!= TAG_compile_unit
)
2834 nextdie
= thisdie
+ di
.dielength
;
2838 completedieinfo (&di
);
2839 if (di
.at_sibling
!= 0)
2841 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2845 nextdie
= thisdie
+ di
.dielength
;
2847 curoff
= thisdie
- dbbase
;
2848 culength
= nextdie
- thisdie
;
2849 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2850 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2851 di
.at_low_pc
, di
.at_high_pc
,
2852 dbfoff
, curoff
, culength
, curlnoffset
,
2853 global_psymbols
.next
,
2854 static_psymbols
.next
);
2855 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2856 pst
-> n_global_syms
= global_psymbols
.next
-
2857 (global_psymbols
.list
+ pst
-> globals_offset
);
2858 pst
-> n_static_syms
= static_psymbols
.next
-
2859 (static_psymbols
.list
+ pst
-> statics_offset
);
2860 /* Sort the global list; don't sort the static list */
2861 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2862 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2864 /* If there is already a psymtab or symtab for a file of this name,
2865 remove it. (If there is a symtab, more drastic things also
2866 happen.) This happens in VxWorks. */
2867 free_named_symtabs (pst
-> filename
);
2868 /* Place the partial symtab on the partial symtab list */
2869 pst
-> next
= partial_symtab_list
;
2870 partial_symtab_list
= pst
;
2880 new_symbol -- make a symbol table entry for a new symbol
2884 static struct symbol *new_symbol (struct dieinfo *dip)
2888 Given a pointer to a DWARF information entry, figure out if we need
2889 to make a symbol table entry for it, and if so, create a new entry
2890 and return a pointer to it.
2893 static struct symbol
*
2894 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2896 struct symbol
*sym
= NULL
;
2898 if (dip
-> at_name
!= NULL
)
2900 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2901 sizeof (struct symbol
));
2902 (void) memset (sym
, 0, sizeof (struct symbol
));
2903 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2904 /* default assumptions */
2905 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2906 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2907 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2908 switch (dip
-> dietag
)
2911 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2912 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2914 case TAG_global_subroutine
:
2915 case TAG_subroutine
:
2916 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2917 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2918 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2919 if (dip
-> dietag
== TAG_global_subroutine
)
2921 add_symbol_to_list (sym
, &global_symbols
);
2925 add_symbol_to_list (sym
, &scope
-> symbols
);
2928 case TAG_global_variable
:
2929 case TAG_local_variable
:
2930 if (dip
-> at_location
!= NULL
)
2932 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2934 if (dip
-> dietag
== TAG_global_variable
)
2936 add_symbol_to_list (sym
, &global_symbols
);
2937 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2938 SYMBOL_VALUE (sym
) += baseaddr
;
2942 add_symbol_to_list (sym
, &scope
-> symbols
);
2943 if (scope
-> parent
!= NULL
)
2947 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2951 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2956 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2957 SYMBOL_VALUE (sym
) += baseaddr
;
2961 case TAG_formal_parameter
:
2962 if (dip
-> at_location
!= NULL
)
2964 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2966 add_symbol_to_list (sym
, &scope
-> symbols
);
2969 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2973 SYMBOL_CLASS (sym
) = LOC_ARG
;
2976 case TAG_unspecified_parameters
:
2977 /* From varargs functions; gdb doesn't seem to have any interest in
2978 this information, so just ignore it for now. (FIXME?) */
2980 case TAG_structure_type
:
2981 case TAG_union_type
:
2982 case TAG_enumeration_type
:
2983 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2984 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2985 add_symbol_to_list (sym
, &scope
-> symbols
);
2988 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2989 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2990 add_symbol_to_list (sym
, &scope
-> symbols
);
2993 /* Not a tag we recognize. Hopefully we aren't processing trash
2994 data, but since we must specifically ignore things we don't
2995 recognize, there is nothing else we should do at this point. */
3006 decode_mod_fund_type -- decode a modified fundamental type
3010 static struct type *decode_mod_fund_type (char *typedata)
3014 Decode a block of data containing a modified fundamental
3015 type specification. TYPEDATA is a pointer to the block,
3016 which consists of a two byte length, containing the size
3017 of the rest of the block. At the end of the block is a
3018 two byte value that gives the fundamental type. Everything
3019 in between are type modifiers.
3021 We simply compute the number of modifiers and call the general
3022 function decode_modified_type to do the actual work.
3025 static struct type
*
3026 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3028 struct type
*typep
= NULL
;
3029 unsigned short modcount
;
3030 unsigned char *modifiers
;
3032 /* Get the total size of the block, exclusive of the size itself */
3033 (void) memcpy (&modcount
, typedata
, sizeof (short));
3034 /* Deduct the size of the fundamental type bytes at the end of the block. */
3035 modcount
-= sizeof (short);
3036 /* Skip over the two size bytes at the beginning of the block. */
3037 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3038 /* Now do the actual decoding */
3039 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3047 decode_mod_u_d_type -- decode a modified user defined type
3051 static struct type *decode_mod_u_d_type (char *typedata)
3055 Decode a block of data containing a modified user defined
3056 type specification. TYPEDATA is a pointer to the block,
3057 which consists of a two byte length, containing the size
3058 of the rest of the block. At the end of the block is a
3059 four byte value that gives a reference to a user defined type.
3060 Everything in between are type modifiers.
3062 We simply compute the number of modifiers and call the general
3063 function decode_modified_type to do the actual work.
3066 static struct type
*
3067 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3069 struct type
*typep
= NULL
;
3070 unsigned short modcount
;
3071 unsigned char *modifiers
;
3073 /* Get the total size of the block, exclusive of the size itself */
3074 (void) memcpy (&modcount
, typedata
, sizeof (short));
3075 /* Deduct the size of the reference type bytes at the end of the block. */
3076 modcount
-= sizeof (long);
3077 /* Skip over the two size bytes at the beginning of the block. */
3078 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3079 /* Now do the actual decoding */
3080 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3088 decode_modified_type -- decode modified user or fundamental type
3092 static struct type *decode_modified_type (unsigned char *modifiers,
3093 unsigned short modcount, int mtype)
3097 Decode a modified type, either a modified fundamental type or
3098 a modified user defined type. MODIFIERS is a pointer to the
3099 block of bytes that define MODCOUNT modifiers. Immediately
3100 following the last modifier is a short containing the fundamental
3101 type or a long containing the reference to the user defined
3102 type. Which one is determined by MTYPE, which is either
3103 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3104 type we are generating.
3106 We call ourself recursively to generate each modified type,`
3107 until MODCOUNT reaches zero, at which point we have consumed
3108 all the modifiers and generate either the fundamental type or
3109 user defined type. When the recursion unwinds, each modifier
3110 is applied in turn to generate the full modified type.
3114 If we find a modifier that we don't recognize, and it is not one
3115 of those reserved for application specific use, then we issue a
3116 warning and simply ignore the modifier.
3120 We currently ignore MOD_const and MOD_volatile. (FIXME)
3124 static struct type
*
3125 DEFUN(decode_modified_type
,
3126 (modifiers
, modcount
, mtype
),
3127 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3129 struct type
*typep
= NULL
;
3130 unsigned short fundtype
;
3132 unsigned char modifier
;
3138 case AT_mod_fund_type
:
3139 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3140 typep
= decode_fund_type (fundtype
);
3142 case AT_mod_u_d_type
:
3143 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3144 if ((typep
= lookup_utype (dieref
)) == NULL
)
3146 typep
= alloc_utype (dieref
, NULL
);
3150 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3151 typep
= builtin_type_int
;
3157 modifier
= *modifiers
++;
3158 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3161 case MOD_pointer_to
:
3162 typep
= lookup_pointer_type (typep
);
3164 case MOD_reference_to
:
3165 typep
= lookup_reference_type (typep
);
3168 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3171 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3174 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3176 SQUAWK (("unknown type modifier %u", modifier
));
3188 decode_fund_type -- translate basic DWARF type to gdb base type
3192 Given an integer that is one of the fundamental DWARF types,
3193 translate it to one of the basic internal gdb types and return
3194 a pointer to the appropriate gdb type (a "struct type *").
3198 If we encounter a fundamental type that we are unprepared to
3199 deal with, and it is not in the range of those types defined
3200 as application specific types, then we issue a warning and
3201 treat the type as builtin_type_int.
3204 static struct type
*
3205 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3207 struct type
*typep
= NULL
;
3213 typep
= builtin_type_void
;
3216 case FT_pointer
: /* (void *) */
3217 typep
= lookup_pointer_type (builtin_type_void
);
3221 case FT_signed_char
:
3222 typep
= builtin_type_char
;
3226 case FT_signed_short
:
3227 typep
= builtin_type_short
;
3231 case FT_signed_integer
:
3232 case FT_boolean
: /* Was FT_set in AT&T version */
3233 typep
= builtin_type_int
;
3237 case FT_signed_long
:
3238 typep
= builtin_type_long
;
3242 typep
= builtin_type_float
;
3245 case FT_dbl_prec_float
:
3246 typep
= builtin_type_double
;
3249 case FT_unsigned_char
:
3250 typep
= builtin_type_unsigned_char
;
3253 case FT_unsigned_short
:
3254 typep
= builtin_type_unsigned_short
;
3257 case FT_unsigned_integer
:
3258 typep
= builtin_type_unsigned_int
;
3261 case FT_unsigned_long
:
3262 typep
= builtin_type_unsigned_long
;
3265 case FT_ext_prec_float
:
3266 typep
= builtin_type_long_double
;
3270 typep
= builtin_type_complex
;
3273 case FT_dbl_prec_complex
:
3274 typep
= builtin_type_double_complex
;
3278 case FT_signed_long_long
:
3279 typep
= builtin_type_long_long
;
3282 case FT_unsigned_long_long
:
3283 typep
= builtin_type_unsigned_long_long
;
3288 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3290 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3291 typep
= builtin_type_void
;
3301 create_name -- allocate a fresh copy of a string on an obstack
3305 Given a pointer to a string and a pointer to an obstack, allocates
3306 a fresh copy of the string on the specified obstack.
3311 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3316 length
= strlen (name
) + 1;
3317 newname
= (char *) obstack_alloc (obstackp
, length
);
3318 (void) strcpy (newname
, name
);
3326 basicdieinfo -- extract the minimal die info from raw die data
3330 void basicdieinfo (char *diep, struct dieinfo *dip)
3334 Given a pointer to raw DIE data, and a pointer to an instance of a
3335 die info structure, this function extracts the basic information
3336 from the DIE data required to continue processing this DIE, along
3337 with some bookkeeping information about the DIE.
3339 The information we absolutely must have includes the DIE tag,
3340 and the DIE length. If we need the sibling reference, then we
3341 will have to call completedieinfo() to process all the remaining
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
3350 We also take care of some other basic things at this point, such
3351 as ensuring that the instance of the die info structure starts
3352 out completely zero'd and that curdie is initialized for use
3353 in error reporting if we have a problem with the current die.
3357 All DIE's must have at least a valid length, thus the minimum
3358 DIE size is sizeof (long). In order to have a valid tag, the
3359 DIE size must be at least sizeof (short) larger, otherwise they
3360 are forced to be TAG_padding DIES.
3362 Padding DIES must be at least sizeof(long) in length, implying that
3363 if a padding DIE is used for alignment and the amount needed is less
3364 than sizeof(long) then the padding DIE has to be big enough to align
3365 to the next alignment boundry.
3369 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3372 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3374 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3375 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3376 if (dip
-> dielength
< sizeof (long))
3378 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3380 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3382 dip
-> dietag
= TAG_padding
;
3386 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3394 completedieinfo -- finish reading the information for a given DIE
3398 void completedieinfo (struct dieinfo *dip)
3402 Given a pointer to an already partially initialized die info structure,
3403 scan the raw DIE data and finish filling in the die info structure
3404 from the various attributes found.
3406 Note that since there is no guarantee that the data is properly
3407 aligned in memory for the type of access required (indirection
3408 through anything other than a char pointer), we use memcpy to
3409 shuffle data items larger than a char. Possibly inefficient, but
3414 Each time we are called, we increment the diecount variable, which
3415 keeps an approximate count of the number of dies processed for
3416 each compilation unit. This information is presented to the user
3417 if the info_verbose flag is set.
3422 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3424 char *diep
; /* Current pointer into raw DIE data */
3425 char *end
; /* Terminate DIE scan here */
3426 unsigned short attr
; /* Current attribute being scanned */
3427 unsigned short form
; /* Form of the attribute */
3428 short block2sz
; /* Size of a block2 attribute field */
3429 long block4sz
; /* Size of a block4 attribute field */
3433 end
= diep
+ dip
-> dielength
;
3434 diep
+= sizeof (long) + sizeof (short);
3437 (void) memcpy (&attr
, diep
, sizeof (short));
3438 diep
+= sizeof (short);
3442 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3445 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3448 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3451 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3454 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3457 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3458 dip
-> has_at_stmt_list
= 1;
3461 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3462 dip
-> has_at_low_pc
= 1;
3465 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3468 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3470 case AT_user_def_type
:
3471 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3474 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3477 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3480 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3483 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3486 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3489 dip
-> at_location
= diep
;
3491 case AT_mod_fund_type
:
3492 dip
-> at_mod_fund_type
= diep
;
3494 case AT_subscr_data
:
3495 dip
-> at_subscr_data
= diep
;
3497 case AT_mod_u_d_type
:
3498 dip
-> at_mod_u_d_type
= diep
;
3500 case AT_element_list
:
3501 dip
-> at_element_list
= diep
;
3502 dip
-> short_element_list
= 0;
3504 case AT_short_element_list
:
3505 dip
-> at_element_list
= diep
;
3506 dip
-> short_element_list
= 1;
3508 case AT_discr_value
:
3509 dip
-> at_discr_value
= diep
;
3511 case AT_string_length
:
3512 dip
-> at_string_length
= diep
;
3515 dip
-> at_name
= diep
;
3518 dip
-> at_comp_dir
= diep
;
3521 dip
-> at_producer
= diep
;
3524 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3526 case AT_start_scope
:
3527 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3529 case AT_stride_size
:
3530 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3533 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3536 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3539 /* Found an attribute that we are unprepared to handle. However
3540 it is specifically one of the design goals of DWARF that
3541 consumers should ignore unknown attributes. As long as the
3542 form is one that we recognize (so we know how to skip it),
3543 we can just ignore the unknown attribute. */
3550 diep
+= sizeof (short);
3553 diep
+= sizeof (long);
3556 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3560 diep
+= sizeof (long);
3563 (void) memcpy (&block2sz
, diep
, sizeof (short));
3564 block2sz
+= sizeof (short);
3568 (void) memcpy (&block4sz
, diep
, sizeof (long));
3569 block4sz
+= sizeof (long);
3573 diep
+= strlen (diep
) + 1;
3576 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));