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. :-)
82 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
83 #define SQUAWK(stuff) dwarfwarn stuff
88 #ifndef R_FP /* FIXME */
89 #define R_FP 14 /* Kludge to get frame pointer register number */
92 typedef unsigned int DIEREF
; /* Reference to a DIE */
94 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
95 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
97 #define STREQ(a,b) (strcmp(a,b)==0)
99 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
100 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
101 However, the Issue 2 DWARF specification from AT&T defines it as
102 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
103 For backwards compatibility with the AT&T compiler produced executables
104 we define AT_short_element_list for this variant. */
106 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
108 /* External variables referenced. */
110 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
111 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
112 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
113 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
114 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
115 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
116 extern int info_verbose
; /* From main.c; nonzero => verbose */
119 /* The DWARF debugging information consists of two major pieces,
120 one is a block of DWARF Information Entries (DIE's) and the other
121 is a line number table. The "struct dieinfo" structure contains
122 the information for a single DIE, the one currently being processed.
124 In order to make it easier to randomly access the attribute fields
125 of the current DIE, which are specifically unordered within the DIE
126 each DIE is scanned and an instance of the "struct dieinfo"
127 structure is initialized.
129 Initialization is done in two levels. The first, done by basicdieinfo(),
130 just initializes those fields that are vital to deciding whether or not
131 to use this DIE, how to skip past it, etc. The second, done by the
132 function completedieinfo(), fills in the rest of the information.
134 Attributes which have block forms are not interpreted at the time
135 the DIE is scanned, instead we just save pointers to the start
136 of their value fields.
138 Some fields have a flag <name>_p that is set when the value of the
139 field is valid (I.E. we found a matching attribute in the DIE). Since
140 we may want to test for the presence of some attributes in the DIE,
141 such as AT_low_pc, without restricting the values of the field,
142 we need someway to note that we found such an attribute.
149 char * die
; /* Pointer to the raw DIE data */
150 long dielength
; /* Length of the raw DIE data */
151 DIEREF dieref
; /* Offset of this DIE */
152 short dietag
; /* Tag for this DIE */
157 unsigned short at_fund_type
;
158 BLOCK
* at_mod_fund_type
;
159 long at_user_def_type
;
160 BLOCK
* at_mod_u_d_type
;
162 BLOCK
* at_subscr_data
;
166 BLOCK
* at_element_list
;
173 BLOCK
* at_discr_value
;
176 BLOCK
* at_string_length
;
184 unsigned int has_at_low_pc
:1;
185 unsigned int has_at_stmt_list
:1;
186 unsigned int short_element_list
:1;
189 static int diecount
; /* Approximate count of dies for compilation unit */
190 static struct dieinfo
*curdie
; /* For warnings and such */
192 static char *dbbase
; /* Base pointer to dwarf info */
193 static int dbroff
; /* Relative offset from start of .debug section */
194 static char *lnbase
; /* Base pointer to line section */
195 static int isreg
; /* Kludge to identify register variables */
197 static CORE_ADDR baseaddr
; /* Add to each symbol value */
199 /* Each partial symbol table entry contains a pointer to private data for the
200 read_symtab() function to use when expanding a partial symbol table entry
201 to a full symbol table entry. For DWARF debugging info, this data is
202 contained in the following structure and macros are provided for easy
203 access to the members given a pointer to a partial symbol table entry.
205 dbfoff Always the absolute file offset to the start of the ".debug"
206 section for the file containing the DIE's being accessed.
208 dbroff Relative offset from the start of the ".debug" access to the
209 first DIE to be accessed. When building the partial symbol
210 table, this value will be zero since we are accessing the
211 entire ".debug" section. When expanding a partial symbol
212 table entry, this value will be the offset to the first
213 DIE for the compilation unit containing the symbol that
214 triggers the expansion.
216 dblength The size of the chunk of DIE's being examined, in bytes.
218 lnfoff The absolute file offset to the line table fragment. Ignored
219 when building partial symbol tables, but used when expanding
220 them, and contains the absolute file offset to the fragment
221 of the ".line" section containing the line numbers for the
222 current compilation unit.
226 int dbfoff
; /* Absolute file offset to start of .debug section */
227 int dbroff
; /* Relative offset from start of .debug section */
228 int dblength
; /* Size of the chunk of DIE's being examined */
229 int lnfoff
; /* Absolute file offset to line table fragment */
232 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
233 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
234 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
235 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
237 /* Record the symbols defined for each context in a linked list. We don't
238 create a struct block for the context until we know how long to make it.
239 Global symbols for each file are maintained in the global_symbols list. */
241 struct pending_symbol
{
242 struct pending_symbol
*next
; /* Next pending symbol */
243 struct symbol
*symbol
; /* The actual symbol */
246 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
247 static struct block
*global_symbol_block
;
249 /* Line number entries are read into a dynamically expandable vector before
250 being added to the symbol table section. Once we know how many there are
253 static struct linetable
*line_vector
; /* Vector of line numbers. */
254 static int line_vector_index
; /* Index of next entry. */
255 static int line_vector_length
; /* Current allocation limit */
257 /* Scope information is kept in a scope tree, one node per scope. Each time
258 a new scope is started, a child node is created under the current node
259 and set to the current scope. Each time a scope is closed, the current
260 scope moves back up the tree to the parent of the current scope.
262 Each scope contains a pointer to the list of symbols defined in the scope,
263 a pointer to the block vector for the scope, a pointer to the symbol
264 that names the scope (if any), and the range of PC values that mark
265 the start and end of the scope. */
268 struct scopenode
*parent
;
269 struct scopenode
*child
;
270 struct scopenode
*sibling
;
271 struct pending_symbol
*symbols
;
273 struct symbol
*namesym
;
278 static struct scopenode
*scopetree
;
279 static struct scopenode
*scope
;
281 /* DIES which have user defined types or modified user defined types refer to
282 other DIES for the type information. Thus we need to associate the offset
283 of a DIE for a user defined type with a pointer to the type information.
285 Originally this was done using a simple but expensive algorithm, with an
286 array of unsorted structures, each containing an offset/type-pointer pair.
287 This array was scanned linearly each time a lookup was done. The result
288 was that gdb was spending over half it's startup time munging through this
289 array of pointers looking for a structure that had the right offset member.
291 The second attempt used the same array of structures, but the array was
292 sorted using qsort each time a new offset/type was recorded, and a binary
293 search was used to find the type pointer for a given DIE offset. This was
294 even slower, due to the overhead of sorting the array each time a new
295 offset/type pair was entered.
297 The third attempt uses a fixed size array of type pointers, indexed by a
298 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
299 we can divide any DIE offset by 4 to obtain a unique index into this fixed
300 size array. Since each element is a 4 byte pointer, it takes exactly as
301 much memory to hold this array as to hold the DWARF info for a given
302 compilation unit. But it gets freed as soon as we are done with it. */
304 static struct type
**utypes
; /* Pointer to array of user type pointers */
305 static int numutypes
; /* Max number of user type pointers */
307 /* Forward declarations of static functions so we don't have to worry
308 about ordering within this file. The EXFUN macro may be slightly
309 misleading. Should probably be called DCLFUN instead, or something
310 more intuitive, since it can be used for both static and external
314 EXFUN (dwarfwarn
, (char *fmt DOTS
));
317 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
320 EXFUN (scan_compilation_units
,
321 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
322 AND
unsigned int dbfoff AND
unsigned int lnoffset
323 AND
struct objfile
*objfile
));
325 static struct partial_symtab
*
326 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
327 AND
char *filename AND CORE_ADDR textlow
328 AND CORE_ADDR texthigh AND
int dbfoff
329 AND
int curoff AND
int culength AND
int lnfoff
330 AND
struct partial_symbol
*global_syms
331 AND
struct partial_symbol
*static_syms
));
333 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
336 EXFUN(add_psymbol_to_list
,
337 (struct psymbol_allocation_list
*listp AND
char *name
338 AND
enum namespace space AND
enum address_class
class
339 AND CORE_ADDR value
));
342 EXFUN(init_psymbol_list
, (int total_symbols
));
345 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
348 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
351 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
354 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
356 static struct symtab
*
357 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
361 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
364 EXFUN(read_structure_scope
,
365 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
368 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
371 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
374 EXFUN(read_array_type
, (struct dieinfo
*dip
));
377 EXFUN(read_subroutine_type
,
378 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
381 EXFUN(read_enumeration
,
382 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
386 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
389 EXFUN(enum_type
, (struct dieinfo
*dip
));
392 EXFUN(start_symtab
, (void));
396 (char *filename AND
long language AND
struct objfile
*objfile
));
399 EXFUN(scopecount
, (struct scopenode
*node
));
403 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
406 EXFUN(freescope
, (struct scopenode
*node
));
408 static struct block
*
409 EXFUN(buildblock
, (struct pending_symbol
*syms
));
412 EXFUN(closescope
, (void));
415 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
418 EXFUN(decode_line_numbers
, (char *linetable
));
421 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
424 EXFUN(decode_mod_fund_type
, (char *typedata
));
427 EXFUN(decode_mod_u_d_type
, (char *typedata
));
430 EXFUN(decode_modified_type
,
431 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
434 EXFUN(decode_fund_type
, (unsigned short fundtype
));
437 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
440 EXFUN(add_symbol_to_list
,
441 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
443 static struct block
**
444 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
446 static struct blockvector
*
447 EXFUN(make_blockvector
, (void));
450 EXFUN(lookup_utype
, (DIEREF dieref
));
453 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
455 static struct symbol
*
456 EXFUN(new_symbol
, (struct dieinfo
*dip
));
459 EXFUN(locval
, (char *loc
));
462 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
463 enum misc_function_type
));
466 EXFUN(compare_psymbols
,
467 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
474 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
478 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
479 int mainline, unsigned int dbfoff, unsigned int dbsize,
480 unsigned int lnoffset, unsigned int lnsize,
481 struct objfile *objfile)
485 This function is called upon to build partial symtabs from files
486 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
488 It is passed a file descriptor for an open file containing the DIES
489 and line number information, the corresponding filename for that
490 file, a base address for relocating the symbols, a flag indicating
491 whether or not this debugging information is from a "main symbol
492 table" rather than a shared library or dynamically linked file,
493 and file offset/size pairs for the DIE information and line number
503 DEFUN(dwarf_build_psymtabs
,
504 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
510 unsigned int dbfoff AND
511 unsigned int dbsize AND
512 unsigned int lnoffset AND
513 unsigned int lnsize AND
514 struct objfile
*objfile
)
516 struct cleanup
*back_to
;
518 dbbase
= xmalloc (dbsize
);
520 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
521 (read (desc
, dbbase
, dbsize
) != dbsize
))
524 error ("can't read DWARF data from '%s'", filename
);
526 back_to
= make_cleanup (free
, dbbase
);
528 /* If we are reinitializing, or if we have never loaded syms yet, init.
529 Since we have no idea how many DIES we are looking at, we just guess
530 some arbitrary value. */
532 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
534 init_psymbol_list (1024);
537 /* Follow the compilation unit sibling chain, building a partial symbol
538 table entry for each one. Save enough information about each compilation
539 unit to locate the full DWARF information later. */
541 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
542 dbfoff
, lnoffset
, objfile
);
544 do_cleanups (back_to
);
552 record_misc_function -- add entry to miscellaneous function vector
556 static void record_misc_function (char *name, CORE_ADDR address,
557 enum misc_function_type mf_type)
561 Given a pointer to the name of a symbol that should be added to the
562 miscellaneous function vector, and the address associated with that
563 symbol, records this information for later use in building the
564 miscellaneous function vector.
569 DEFUN(record_misc_function
, (name
, address
, mf_type
),
570 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
572 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
580 dwarfwarn -- issue a DWARF related warning
584 Issue warnings about DWARF related things that aren't serious enough
585 to warrant aborting with an error, but should not be ignored either.
586 This includes things like detectable corruption in DIE's, missing
587 DIE's, unimplemented features, etc.
589 In general, running across tags or attributes that we don't recognize
590 is not considered to be a problem and we should not issue warnings
595 We mostly follow the example of the error() routine, but without
596 returning to command level. It is arguable about whether warnings
597 should be issued at all, and if so, where they should go (stdout or
600 We assume that curdie is valid and contains at least the basic
601 information for the DIE where the problem was noticed.
606 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
612 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
613 if (curdie
-> at_name
)
615 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
617 vfprintf (stderr
, fmt
, ap
);
618 fprintf (stderr
, "\n");
632 fmt
= va_arg (ap
, char *);
634 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
635 if (curdie
-> at_name
)
637 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
639 vfprintf (stderr
, fmt
, ap
);
640 fprintf (stderr
, "\n");
649 compare_psymbols -- compare two partial symbols by name
653 Given pointer to two partial symbol table entries, compare
654 them by name and return -N, 0, or +N (ala strcmp). Typically
655 used by sorting routines like qsort().
659 This is a copy from dbxread.c. It should be moved to a generic
660 gdb file and made available for all psymtab builders (FIXME).
662 Does direct compare of first two characters before punting
663 and passing to strcmp for longer compares. Note that the
664 original version had a bug whereby two null strings or two
665 identically named one character strings would return the
666 comparison of memory following the null byte.
671 DEFUN(compare_psymbols
, (s1
, s2
),
672 struct partial_symbol
*s1 AND
673 struct partial_symbol
*s2
)
675 register char *st1
= SYMBOL_NAME (s1
);
676 register char *st2
= SYMBOL_NAME (s2
);
678 if ((st1
[0] - st2
[0]) || !st1
[0])
680 return (st1
[0] - st2
[0]);
682 else if ((st1
[1] - st2
[1]) || !st1
[1])
684 return (st1
[1] - st2
[1]);
688 return (strcmp (st1
+ 2, st2
+ 2));
696 read_lexical_block_scope -- process all dies in a lexical block
700 static void read_lexical_block_scope (struct dieinfo *dip,
701 char *thisdie, char *enddie)
705 Process all the DIES contained within a lexical block scope.
706 Start a new scope, process the dies, and then close the scope.
711 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
712 struct dieinfo
*dip AND
715 struct objfile
*objfile
)
717 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
718 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
726 lookup_utype -- look up a user defined type from die reference
730 static type *lookup_utype (DIEREF dieref)
734 Given a DIE reference, lookup the user defined type associated with
735 that DIE, if it has been registered already. If not registered, then
736 return NULL. Alloc_utype() can be called to register an empty
737 type for this reference, which will be filled in later when the
738 actual referenced DIE is processed.
742 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
744 struct type
*type
= NULL
;
747 utypeidx
= (dieref
- dbroff
) / 4;
748 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
750 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
754 type
= *(utypes
+ utypeidx
);
764 alloc_utype -- add a user defined type for die reference
768 static type *alloc_utype (DIEREF dieref, struct type *utypep)
772 Given a die reference DIEREF, and a possible pointer to a user
773 defined type UTYPEP, register that this reference has a user
774 defined type and either use the specified type in UTYPEP or
775 make a new empty type that will be filled in later.
777 We should only be called after calling lookup_utype() to verify that
778 there is not currently a type registered for DIEREF.
782 DEFUN(alloc_utype
, (dieref
, utypep
),
789 utypeidx
= (dieref
- dbroff
) / 4;
790 typep
= utypes
+ utypeidx
;
791 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
793 utypep
= builtin_type_int
;
794 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
796 else if (*typep
!= NULL
)
799 SQUAWK (("internal error: dup user type allocation"));
805 utypep
= (struct type
*)
806 obstack_alloc (symbol_obstack
, sizeof (struct type
));
807 (void) memset (utypep
, 0, sizeof (struct type
));
818 decode_die_type -- return a type for a specified die
822 static struct type *decode_die_type (struct dieinfo *dip)
826 Given a pointer to a die information structure DIP, decode the
827 type of the die and return a pointer to the decoded type. All
828 dies without specific types default to type int.
832 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
834 struct type
*type
= NULL
;
836 if (dip
-> at_fund_type
!= 0)
838 type
= decode_fund_type (dip
-> at_fund_type
);
840 else if (dip
-> at_mod_fund_type
!= NULL
)
842 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
844 else if (dip
-> at_user_def_type
)
846 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
848 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
851 else if (dip
-> at_mod_u_d_type
)
853 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
857 type
= builtin_type_int
;
866 struct_type -- compute and return the type for a struct or union
870 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
875 Given pointer to a die information structure for a die which
876 defines a union or structure, and pointers to the raw die data
877 that define the range of dies which define the members, compute
878 and return the user defined type for the structure or union.
882 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
883 struct dieinfo
*dip AND
889 struct nextfield
*next
;
892 struct nextfield
*list
= NULL
;
893 struct nextfield
*new;
901 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
903 type
= alloc_utype (dip
-> dieref
, NULL
);
905 switch (dip
-> dietag
)
907 case TAG_structure_type
:
908 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
909 TYPE_CPLUS_SPECIFIC (type
)
910 = (struct cplus_struct_type
*) obstack_alloc (symbol_obstack
, sizeof (struct cplus_struct_type
));
911 bzero (TYPE_CPLUS_SPECIFIC (type
), sizeof (struct cplus_struct_type
));
915 TYPE_CODE (type
) = TYPE_CODE_UNION
;
920 SQUAWK (("missing structure or union tag"));
921 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
924 /* Some compilers try to be helpful by inventing "fake" names for anonymous
925 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
926 if (dip
-> at_name
== NULL
|| *dip
-> at_name
== '~')
932 tpart2
= dip
-> at_name
;
934 if (dip
-> at_byte_size
== 0)
936 tpart3
= " <opaque>";
938 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
941 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
942 thisdie
+= dip
-> dielength
;
943 while (thisdie
< enddie
)
945 basicdieinfo (&mbr
, thisdie
);
946 completedieinfo (&mbr
);
947 if (mbr
.dielength
<= sizeof (long))
954 /* Get space to record the next field's data. */
955 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
959 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
960 list
-> field
.type
= decode_die_type (&mbr
);
961 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
962 list
-> field
.bitsize
= 0;
966 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
969 thisdie
+= mbr
.dielength
;
971 /* Now create the vector of fields, and record how big it is. */
972 TYPE_NFIELDS (type
) = nfields
;
973 TYPE_FIELDS (type
) = (struct field
*)
974 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
975 /* Copy the saved-up fields into the field vector. */
976 for (n
= nfields
; list
; list
= list
-> next
)
978 TYPE_FIELD (type
, --n
) = list
-> field
;
987 read_structure_scope -- process all dies within struct or union
991 static void read_structure_scope (struct dieinfo *dip,
992 char *thisdie, char *enddie)
996 Called when we find the DIE that starts a structure or union
997 scope (definition) to process all dies that define the members
998 of the structure or union. DIP is a pointer to the die info
999 struct for the DIE that names the structure or union.
1003 Note that we need to call struct_type regardless of whether or not
1004 we have a symbol, since we might have a structure or union without
1005 a tag name (thus no symbol for the tagname).
1009 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
1010 struct dieinfo
*dip AND
1017 type
= struct_type (dip
, thisdie
, enddie
);
1018 if ((sym
= new_symbol (dip
)) != NULL
)
1020 SYMBOL_TYPE (sym
) = type
;
1028 decode_array_element_type -- decode type of the array elements
1032 static struct type *decode_array_element_type (char *scan, char *end)
1036 As the last step in decoding the array subscript information for an
1037 array DIE, we need to decode the type of the array elements. We are
1038 passed a pointer to this last part of the subscript information and
1039 must return the appropriate type. If the type attribute is not
1040 recognized, just warn about the problem and return type int.
1043 static struct type
*
1044 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1049 unsigned short fundtype
;
1051 (void) memcpy (&attribute
, scan
, sizeof (short));
1052 scan
+= sizeof (short);
1056 (void) memcpy (&fundtype
, scan
, sizeof (short));
1057 typep
= decode_fund_type (fundtype
);
1059 case AT_mod_fund_type
:
1060 typep
= decode_mod_fund_type (scan
);
1062 case AT_user_def_type
:
1063 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1064 if ((typep
= lookup_utype (dieref
)) == NULL
)
1066 typep
= alloc_utype (dieref
, NULL
);
1069 case AT_mod_u_d_type
:
1070 typep
= decode_mod_u_d_type (scan
);
1073 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1074 typep
= builtin_type_int
;
1084 decode_subscr_data -- decode array subscript and element type data
1088 static struct type *decode_subscr_data (char *scan, char *end)
1092 The array subscripts and the data type of the elements of an
1093 array are described by a list of data items, stored as a block
1094 of contiguous bytes. There is a data item describing each array
1095 dimension, and a final data item describing the element type.
1096 The data items are ordered the same as their appearance in the
1097 source (I.E. leftmost dimension first, next to leftmost second,
1100 We are passed a pointer to the start of the block of bytes
1101 containing the data items, and a pointer to the first byte past
1102 the data. This function decodes the data and returns a type.
1105 FIXME: This code only implements the forms currently used
1106 by the AT&T and GNU C compilers.
1108 The end pointer is supplied for error checking, maybe we should
1112 static struct type
*
1113 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1115 struct type
*typep
= NULL
;
1116 struct type
*nexttype
;
1126 typep
= decode_array_element_type (scan
, end
);
1129 (void) memcpy (&fundtype
, scan
, sizeof (short));
1130 scan
+= sizeof (short);
1131 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1132 && fundtype
!= FT_unsigned_integer
)
1134 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1139 (void) memcpy (&lowbound
, scan
, sizeof (long));
1140 scan
+= sizeof (long);
1141 (void) memcpy (&highbound
, scan
, sizeof (long));
1142 scan
+= sizeof (long);
1143 nexttype
= decode_subscr_data (scan
, end
);
1144 if (nexttype
!= NULL
)
1146 typep
= (struct type
*)
1147 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1148 (void) memset (typep
, 0, sizeof (struct type
));
1149 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1150 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1151 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1152 TYPE_TARGET_TYPE (typep
) = nexttype
;
1163 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1166 SQUAWK (("unknown array subscript format %x", format
));
1176 read_array_type -- read TAG_array_type DIE
1180 static void read_array_type (struct dieinfo *dip)
1184 Extract all information from a TAG_array_type DIE and add to
1185 the user defined type vector.
1189 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1196 if (dip
-> at_ordering
!= ORD_row_major
)
1198 /* FIXME: Can gdb even handle column major arrays? */
1199 SQUAWK (("array not row major; not handled correctly"));
1201 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1203 (void) memcpy (&temp
, sub
, sizeof (short));
1204 subend
= sub
+ sizeof (short) + temp
;
1205 sub
+= sizeof (short);
1206 type
= decode_subscr_data (sub
, subend
);
1209 type
= alloc_utype (dip
-> dieref
, NULL
);
1210 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1211 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1212 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1216 type
= alloc_utype (dip
-> dieref
, type
);
1225 read_subroutine_type -- process TAG_subroutine_type dies
1229 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1234 Handle DIES due to C code like:
1237 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1243 The parameter DIES are currently ignored. See if gdb has a way to
1244 include this info in it's type system, and decode them if so. Is
1245 this what the type structure's "arg_types" field is for? (FIXME)
1249 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1250 struct dieinfo
*dip AND
1256 type
= decode_die_type (dip
);
1257 type
= lookup_function_type (type
);
1258 type
= alloc_utype (dip
-> dieref
, type
);
1265 read_enumeration -- process dies which define an enumeration
1269 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1274 Given a pointer to a die which begins an enumeration, process all
1275 the dies that define the members of the enumeration.
1279 Note that we need to call enum_type regardless of whether or not we
1280 have a symbol, since we might have an enum without a tag name (thus
1281 no symbol for the tagname).
1285 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1286 struct dieinfo
*dip AND
1293 type
= enum_type (dip
);
1294 if ((sym
= new_symbol (dip
)) != NULL
)
1296 SYMBOL_TYPE (sym
) = type
;
1304 enum_type -- decode and return a type for an enumeration
1308 static type *enum_type (struct dieinfo *dip)
1312 Given a pointer to a die information structure for the die which
1313 starts an enumeration, process all the dies that define the members
1314 of the enumeration and return a type pointer for the enumeration.
1317 static struct type
*
1318 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1322 struct nextfield
*next
;
1325 struct nextfield
*list
= NULL
;
1326 struct nextfield
*new;
1337 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1339 type
= alloc_utype (dip
-> dieref
, NULL
);
1341 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1343 /* Some compilers try to be helpful by inventing "fake" names for anonymous
1344 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
1345 if (dip
-> at_name
== NULL
|| *dip
-> at_name
== '~')
1349 tpart2
= dip
-> at_name
;
1351 if (dip
-> at_byte_size
== 0)
1353 tpart3
= " <opaque>";
1357 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1360 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
1361 if ((scan
= dip
-> at_element_list
) != NULL
)
1363 if (dip
-> short_element_list
)
1365 (void) memcpy (&stemp
, scan
, sizeof (stemp
));
1366 listend
= scan
+ stemp
+ sizeof (stemp
);
1367 scan
+= sizeof (stemp
);
1371 (void) memcpy (<emp
, scan
, sizeof (ltemp
));
1372 listend
= scan
+ ltemp
+ sizeof (ltemp
);
1373 scan
+= sizeof (ltemp
);
1375 while (scan
< listend
)
1377 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1380 list
-> field
.type
= NULL
;
1381 list
-> field
.bitsize
= 0;
1382 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1383 scan
+= sizeof (long);
1384 list
-> field
.name
= savestring (scan
, strlen (scan
));
1385 scan
+= strlen (scan
) + 1;
1389 /* Now create the vector of fields, and record how big it is. */
1390 TYPE_NFIELDS (type
) = nfields
;
1391 TYPE_FIELDS (type
) = (struct field
*)
1392 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1393 /* Copy the saved-up fields into the field vector. */
1394 for (n
= nfields
; list
; list
= list
-> next
)
1396 TYPE_FIELD (type
, --n
) = list
-> field
;
1405 read_func_scope -- process all dies within a function scope
1409 Process all dies within a given function scope. We are passed
1410 a die information structure pointer DIP for the die which
1411 starts the function scope, and pointers into the raw die data
1412 that define the dies within the function scope.
1414 For now, we ignore lexical block scopes within the function.
1415 The problem is that AT&T cc does not define a DWARF lexical
1416 block scope for the function itself, while gcc defines a
1417 lexical block scope for the function. We need to think about
1418 how to handle this difference, or if it is even a problem.
1423 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1424 struct dieinfo
*dip AND
1427 struct objfile
*objfile
)
1431 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1433 entry_scope_lowpc
= dip
-> at_low_pc
;
1434 entry_scope_highpc
= dip
-> at_high_pc
;
1436 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1438 main_scope_lowpc
= dip
-> at_low_pc
;
1439 main_scope_highpc
= dip
-> at_high_pc
;
1441 sym
= new_symbol (dip
);
1442 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1443 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1451 read_file_scope -- process all dies within a file scope
1455 Process all dies within a given file scope. We are passed a
1456 pointer to the die information structure for the die which
1457 starts the file scope, and pointers into the raw die data which
1458 mark the range of dies within the file scope.
1460 When the partial symbol table is built, the file offset for the line
1461 number table for each compilation unit is saved in the partial symbol
1462 table entry for that compilation unit. As the symbols for each
1463 compilation unit are read, the line number table is read into memory
1464 and the variable lnbase is set to point to it. Thus all we have to
1465 do is use lnbase to access the line number table for the current
1470 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1471 struct dieinfo
*dip AND
1474 struct objfile
*objfile
)
1476 struct cleanup
*back_to
;
1478 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1480 startup_file_start
= dip
-> at_low_pc
;
1481 startup_file_end
= dip
-> at_high_pc
;
1483 numutypes
= (enddie
- thisdie
) / 4;
1484 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1485 back_to
= make_cleanup (free
, utypes
);
1486 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1488 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1489 decode_line_numbers (lnbase
);
1490 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1492 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1493 do_cleanups (back_to
);
1502 start_symtab -- do initialization for starting new symbol table
1506 static void start_symtab (void)
1510 Called whenever we are starting to process dies for a new
1511 compilation unit, to perform initializations. Right now
1512 the only thing we really have to do is initialize storage
1513 space for the line number vector.
1518 DEFUN_VOID (start_symtab
)
1522 line_vector_index
= 0;
1523 line_vector_length
= 1000;
1524 nbytes
= sizeof (struct linetable
);
1525 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1526 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1533 process_dies -- process a range of DWARF Information Entries
1537 static void process_dies (char *thisdie, char *enddie)
1541 Process all DIE's in a specified range. May be (and almost
1542 certainly will be) called recursively.
1546 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1547 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1552 while (thisdie
< enddie
)
1554 basicdieinfo (&di
, thisdie
);
1555 if (di
.dielength
< sizeof (long))
1559 else if (di
.dietag
== TAG_padding
)
1561 nextdie
= thisdie
+ di
.dielength
;
1565 completedieinfo (&di
);
1566 if (di
.at_sibling
!= 0)
1568 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1572 nextdie
= thisdie
+ di
.dielength
;
1576 case TAG_compile_unit
:
1577 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1579 case TAG_global_subroutine
:
1580 case TAG_subroutine
:
1581 if (di
.has_at_low_pc
)
1583 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1586 case TAG_lexical_block
:
1587 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1589 case TAG_structure_type
:
1590 case TAG_union_type
:
1591 read_structure_scope (&di
, thisdie
, nextdie
);
1593 case TAG_enumeration_type
:
1594 read_enumeration (&di
, thisdie
, nextdie
);
1596 case TAG_subroutine_type
:
1597 read_subroutine_type (&di
, thisdie
, nextdie
);
1599 case TAG_array_type
:
1600 read_array_type (&di
);
1603 (void) new_symbol (&di
);
1615 end_symtab -- finish processing for a compilation unit
1619 static void end_symtab (char *filename, long language)
1623 Complete the symbol table entry for the current compilation
1624 unit. Make the struct symtab and put it on the list of all
1630 DEFUN(end_symtab
, (filename
, language
, objfile
),
1631 char *filename AND
long language AND
struct objfile
*objfile
)
1633 struct symtab
*symtab
;
1634 struct blockvector
*blockvector
;
1637 /* Ignore a file that has no functions with real debugging info. */
1638 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1642 line_vector_length
= -1;
1643 freescope (scopetree
);
1644 scope
= scopetree
= NULL
;
1647 /* Create the blockvector that points to all the file's blocks. */
1649 blockvector
= make_blockvector ();
1651 /* Now create the symtab object for this source file. */
1653 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1656 symtab
-> free_ptr
= 0;
1658 /* Fill in its components. */
1659 symtab
-> blockvector
= blockvector
;
1660 symtab
-> free_code
= free_linetable
;
1662 /* Save the line number information. */
1664 line_vector
-> nitems
= line_vector_index
;
1665 nbytes
= sizeof (struct linetable
);
1666 if (line_vector_index
> 1)
1668 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1670 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1672 /* FIXME: The following may need to be expanded for other languages */
1677 symtab
-> language
= language_c
;
1679 case LANG_C_PLUS_PLUS
:
1680 symtab
-> language
= language_cplus
;
1686 /* Link the new symtab into the list of such. */
1687 symtab
-> next
= symtab_list
;
1688 symtab_list
= symtab
;
1690 /* Recursively free the scope tree */
1691 freescope (scopetree
);
1692 scope
= scopetree
= NULL
;
1694 /* Reinitialize for beginning of new file. */
1696 line_vector_length
= -1;
1703 scopecount -- count the number of enclosed scopes
1707 static int scopecount (struct scopenode *node)
1711 Given pointer to a node, compute the size of the subtree which is
1712 rooted in this node, which also happens to be the number of scopes
1717 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1723 count
+= scopecount (node
-> child
);
1724 count
+= scopecount (node
-> sibling
);
1734 openscope -- start a new lexical block scope
1738 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1743 Start a new scope by allocating a new scopenode, adding it as the
1744 next child of the current scope (if any) or as the root of the
1745 scope tree, and then making the new node the current scope node.
1749 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1750 struct symbol
*namesym AND
1754 struct scopenode
*new;
1755 struct scopenode
*child
;
1757 new = (struct scopenode
*) xmalloc (sizeof (*new));
1758 (void) memset (new, 0, sizeof (*new));
1759 new -> namesym
= namesym
;
1760 new -> lowpc
= lowpc
;
1761 new -> highpc
= highpc
;
1766 else if ((child
= scope
-> child
) == NULL
)
1768 scope
-> child
= new;
1769 new -> parent
= scope
;
1773 while (child
-> sibling
!= NULL
)
1775 child
= child
-> sibling
;
1777 child
-> sibling
= new;
1778 new -> parent
= scope
;
1787 freescope -- free a scope tree rooted at the given node
1791 static void freescope (struct scopenode *node)
1795 Given a pointer to a node in the scope tree, free the subtree
1796 rooted at that node. First free all the children and sibling
1797 nodes, and then the node itself. Used primarily for cleaning
1798 up after ourselves and returning memory to the system.
1802 DEFUN(freescope
, (node
), struct scopenode
*node
)
1806 freescope (node
-> child
);
1807 freescope (node
-> sibling
);
1816 buildblock -- build a new block from pending symbols list
1820 static struct block *buildblock (struct pending_symbol *syms)
1824 Given a pointer to a list of symbols, build a new block and free
1825 the symbol list structure. Also check each symbol to see if it
1826 is the special symbol that flags that this block was compiled by
1827 gcc, and if so, mark the block appropriately.
1830 static struct block
*
1831 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1833 struct pending_symbol
*next
, *next1
;
1835 struct block
*newblock
;
1838 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1840 /* Allocate a new block */
1842 nbytes
= sizeof (struct block
);
1845 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1847 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1848 (void) memset (newblock
, 0, nbytes
);
1850 /* Copy the symbols into the block. */
1852 BLOCK_NSYMS (newblock
) = i
;
1853 for (next
= syms
; next
; next
= next
-> next
)
1855 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1856 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1857 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1859 BLOCK_GCC_COMPILED (newblock
) = 1;
1863 /* Now free the links of the list, and empty the list. */
1865 for (next
= syms
; next
; next
= next1
)
1867 next1
= next
-> next
;
1878 closescope -- close a lexical block scope
1882 static void closescope (void)
1886 Close the current lexical block scope. Closing the current scope
1887 is as simple as moving the current scope pointer up to the parent
1888 of the current scope pointer. But we also take this opportunity
1889 to build the block for the current scope first, since we now have
1890 all of it's symbols.
1894 DEFUN_VOID(closescope
)
1896 struct scopenode
*child
;
1900 error ("DWARF parse error, too many close scopes");
1904 if (scope
-> parent
== NULL
)
1906 global_symbol_block
= buildblock (global_symbols
);
1907 global_symbols
= NULL
;
1908 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1909 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1911 scope
-> block
= buildblock (scope
-> symbols
);
1912 scope
-> symbols
= NULL
;
1913 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1914 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1916 /* Put the local block in as the value of the symbol that names it. */
1918 if (scope
-> namesym
)
1920 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1921 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1924 /* Install this scope's local block as the superblock of all child
1927 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1929 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1932 scope
= scope
-> parent
;
1940 record_line -- record a line number entry in the line vector
1944 static void record_line (int line, CORE_ADDR pc)
1948 Given a line number and the corresponding pc value, record
1949 this pair in the line number vector, expanding the vector as
1954 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1956 struct linetable_entry
*e
;
1959 /* Make sure line vector is big enough. */
1961 if (line_vector_index
+ 2 >= line_vector_length
)
1963 line_vector_length
*= 2;
1964 nbytes
= sizeof (struct linetable
);
1965 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1966 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1968 e
= line_vector
-> item
+ line_vector_index
++;
1977 decode_line_numbers -- decode a line number table fragment
1981 static void decode_line_numbers (char *tblscan, char *tblend,
1982 long length, long base, long line, long pc)
1986 Translate the DWARF line number information to gdb form.
1988 The ".line" section contains one or more line number tables, one for
1989 each ".line" section from the objects that were linked.
1991 The AT_stmt_list attribute for each TAG_source_file entry in the
1992 ".debug" section contains the offset into the ".line" section for the
1993 start of the table for that file.
1995 The table itself has the following structure:
1997 <table length><base address><source statement entry>
1998 4 bytes 4 bytes 10 bytes
2000 The table length is the total size of the table, including the 4 bytes
2001 for the length information.
2003 The base address is the address of the first instruction generated
2004 for the source file.
2006 Each source statement entry has the following structure:
2008 <line number><statement position><address delta>
2009 4 bytes 2 bytes 4 bytes
2011 The line number is relative to the start of the file, starting with
2014 The statement position either -1 (0xFFFF) or the number of characters
2015 from the beginning of the line to the beginning of the statement.
2017 The address delta is the difference between the base address and
2018 the address of the first instruction for the statement.
2020 Note that we must copy the bytes from the packed table to our local
2021 variables before attempting to use them, to avoid alignment problems
2022 on some machines, particularly RISC processors.
2026 Does gdb expect the line numbers to be sorted? They are now by
2027 chance/luck, but are not required to be. (FIXME)
2029 The line with number 0 is unused, gdb apparently can discover the
2030 span of the last line some other way. How? (FIXME)
2034 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2043 if (linetable
!= NULL
)
2045 tblscan
= tblend
= linetable
;
2046 (void) memcpy (&length
, tblscan
, sizeof (long));
2047 tblscan
+= sizeof (long);
2049 (void) memcpy (&base
, tblscan
, sizeof (long));
2051 tblscan
+= sizeof (long);
2052 while (tblscan
< tblend
)
2054 (void) memcpy (&line
, tblscan
, sizeof (long));
2055 tblscan
+= sizeof (long) + sizeof (short);
2056 (void) memcpy (&pc
, tblscan
, sizeof (long));
2057 tblscan
+= sizeof (long);
2061 record_line (line
, pc
);
2071 add_symbol_to_list -- add a symbol to head of current symbol list
2075 static void add_symbol_to_list (struct symbol *symbol, struct
2076 pending_symbol **listhead)
2080 Given a pointer to a symbol and a pointer to a pointer to a
2081 list of symbols, add this symbol as the current head of the
2082 list. Typically used for example to add a symbol to the
2083 symbol list for the current scope.
2088 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2089 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2091 struct pending_symbol
*link
;
2095 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2096 link
-> next
= *listhead
;
2097 link
-> symbol
= symbol
;
2106 gatherblocks -- walk a scope tree and build block vectors
2110 static struct block **gatherblocks (struct block **dest,
2111 struct scopenode *node)
2115 Recursively walk a scope tree rooted in the given node, adding blocks
2116 to the array pointed to by DEST, in preorder. I.E., first we add the
2117 block for the current scope, then all the blocks for child scopes,
2118 and finally all the blocks for sibling scopes.
2121 static struct block
**
2122 DEFUN(gatherblocks
, (dest
, node
),
2123 struct block
**dest AND
struct scopenode
*node
)
2127 *dest
++ = node
-> block
;
2128 dest
= gatherblocks (dest
, node
-> child
);
2129 dest
= gatherblocks (dest
, node
-> sibling
);
2138 make_blockvector -- make a block vector from current scope tree
2142 static struct blockvector *make_blockvector (void)
2146 Make a blockvector from all the blocks in the current scope tree.
2147 The first block is always the global symbol block, followed by the
2148 block for the root of the scope tree which is the local symbol block,
2149 followed by all the remaining blocks in the scope tree, which are all
2154 Note that since the root node of the scope tree is created at the time
2155 each file scope is entered, there are always at least two blocks,
2156 neither of which may have any symbols, but always contribute a block
2157 to the block vector. So the test for number of blocks greater than 1
2158 below is unnecessary given bug free code.
2160 The resulting block structure varies slightly from that produced
2161 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2162 with dbxread.c, block 1 is a child of block 0. This does not
2163 seem to cause any problems, but probably should be fixed. (FIXME)
2166 static struct blockvector
*
2167 DEFUN_VOID(make_blockvector
)
2169 struct blockvector
*blockvector
= NULL
;
2173 /* Recursively walk down the tree, counting the number of blocks.
2174 Then add one to account for the global's symbol block */
2176 i
= scopecount (scopetree
) + 1;
2177 nbytes
= sizeof (struct blockvector
);
2180 nbytes
+= (i
- 1) * sizeof (struct block
*);
2182 blockvector
= (struct blockvector
*)
2183 obstack_alloc (symbol_obstack
, nbytes
);
2185 /* Copy the blocks into the blockvector. */
2187 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2188 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2189 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2191 return (blockvector
);
2198 locval -- compute the value of a location attribute
2202 static int locval (char *loc)
2206 Given pointer to a string of bytes that define a location, compute
2207 the location and return the value.
2209 When computing values involving the current value of the frame pointer,
2210 the value zero is used, which results in a value relative to the frame
2211 pointer, rather than the absolute value. This is what GDB wants
2214 When the result is a register number, the global isreg flag is set,
2215 otherwise it is cleared. This is a kludge until we figure out a better
2216 way to handle the problem. Gdb's design does not mesh well with the
2217 DWARF notion of a location computing interpreter, which is a shame
2218 because the flexibility goes unused.
2222 Note that stack[0] is unused except as a default error return.
2223 Note that stack overflow is not yet handled.
2227 DEFUN(locval
, (loc
), char *loc
)
2229 unsigned short nbytes
;
2235 (void) memcpy (&nbytes
, loc
, sizeof (short));
2236 end
= loc
+ sizeof (short) + nbytes
;
2240 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2248 /* push register (number) */
2249 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2253 /* push value of register (number) */
2254 /* Actually, we compute the value as if register has 0 */
2255 (void) memcpy (®no
, loc
, sizeof (long));
2258 stack
[++stacki
] = 0;
2262 stack
[++stacki
] = 0;
2263 SQUAWK (("BASEREG %d not handled!", regno
));
2267 /* push address (relocated address) */
2268 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2271 /* push constant (number) */
2272 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2275 /* pop, deref and push 2 bytes (as a long) */
2276 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2278 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2279 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2281 case OP_ADD
: /* pop top 2 items, add, push result */
2282 stack
[stacki
- 1] += stack
[stacki
];
2287 return (stack
[stacki
]);
2294 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2298 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2302 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2305 static struct symtab
*
2306 DEFUN(read_ofile_symtab
, (pst
),
2307 struct partial_symtab
*pst
)
2309 struct cleanup
*back_to
;
2312 bfd
*abfd
= pst
->objfile
->obfd
;
2314 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2315 unit, seek to the location in the file, and read in all the DIE's. */
2318 dbbase
= xmalloc (DBLENGTH(pst
));
2319 dbroff
= DBROFF(pst
);
2320 foffset
= DBFOFF(pst
) + dbroff
;
2321 if (bfd_seek (abfd
, foffset
, 0) ||
2322 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2325 error ("can't read DWARF data");
2327 back_to
= make_cleanup (free
, dbbase
);
2329 /* If there is a line number table associated with this compilation unit
2330 then read the first long word from the line number table fragment, which
2331 contains the size of the fragment in bytes (including the long word
2332 itself). Allocate a buffer for the fragment and read it in for future
2338 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2339 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2341 error ("can't read DWARF line number table size");
2343 lnbase
= xmalloc (lnsize
);
2344 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2345 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2348 error ("can't read DWARF line numbers");
2350 make_cleanup (free
, lnbase
);
2353 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2354 do_cleanups (back_to
);
2355 return (symtab_list
);
2362 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2366 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2370 Called once for each partial symbol table entry that needs to be
2371 expanded into a full symbol table entry.
2376 DEFUN(psymtab_to_symtab_1
,
2378 struct partial_symtab
*pst
)
2388 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2393 /* Read in all partial symtabs on which this one is dependent */
2394 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2395 if (!pst
-> dependencies
[i
] -> readin
)
2397 /* Inform about additional files that need to be read in. */
2400 fputs_filtered (" ", stdout
);
2402 fputs_filtered ("and ", stdout
);
2404 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2405 wrap_here (""); /* Flush output */
2408 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2411 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2413 /* Init stuff necessary for reading in symbols */
2414 pst
-> symtab
= read_ofile_symtab (pst
);
2417 printf_filtered ("%d DIE's, sorting...", diecount
);
2420 sort_symtab_syms (pst
-> symtab
);
2429 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2433 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2437 This is the DWARF support entry point for building a full symbol
2438 table entry from a partial symbol table entry. We are passed a
2439 pointer to the partial symbol table entry that needs to be expanded.
2444 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2455 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2460 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2462 /* Print the message now, before starting serious work, to avoid
2463 disconcerting pauses. */
2466 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2470 psymtab_to_symtab_1 (pst
);
2472 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2473 we need to do an equivalent or is this something peculiar to
2474 stabs/a.out format. */
2475 /* Match with global symbols. This only needs to be done once,
2476 after all of the symtabs and dependencies have been read in. */
2477 scan_file_globals ();
2480 /* Finish up the debug error message. */
2483 printf_filtered ("done.\n");
2492 init_psymbol_list -- initialize storage for partial symbols
2496 static void init_psymbol_list (int total_symbols)
2500 Initializes storage for all of the partial symbols that will be
2501 created by dwarf_build_psymtabs and subsidiaries.
2505 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2507 /* Free any previously allocated psymbol lists. */
2509 if (global_psymbols
.list
)
2511 free (global_psymbols
.list
);
2513 if (static_psymbols
.list
)
2515 free (static_psymbols
.list
);
2518 /* Current best guess is that there are approximately a twentieth
2519 of the total symbols (in a debugging file) are global or static
2522 global_psymbols
.size
= total_symbols
/ 10;
2523 static_psymbols
.size
= total_symbols
/ 10;
2524 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2525 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2526 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2527 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2534 start_psymtab -- allocate and partially fill a partial symtab entry
2538 Allocate and partially fill a partial symtab. It will be completely
2539 filled at the end of the symbol list.
2541 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2542 ADDR is the address relative to which its symbols are (incremental)
2543 or 0 (normal). FILENAME is the name of the compilation unit that
2544 these symbols were defined in, and they appear starting a address
2545 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2546 the full symbols can be read for compilation unit FILENAME.
2547 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2552 static struct partial_symtab
*
2553 DEFUN(start_psymtab
,
2554 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2555 culength
, lnfoff
, global_syms
, static_syms
),
2556 struct objfile
*objfile AND
2559 CORE_ADDR textlow AND
2560 CORE_ADDR texthigh AND
2565 struct partial_symbol
*global_syms AND
2566 struct partial_symbol
*static_syms
)
2568 struct partial_symtab
*result
;
2570 result
= (struct partial_symtab
*)
2571 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2572 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2573 result
-> addr
= addr
;
2574 result
-> objfile
= objfile
;
2575 result
-> filename
= create_name (filename
, psymbol_obstack
);
2576 result
-> textlow
= textlow
;
2577 result
-> texthigh
= texthigh
;
2578 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2579 sizeof (struct dwfinfo
));
2580 DBFOFF (result
) = dbfoff
;
2581 DBROFF (result
) = curoff
;
2582 DBLENGTH (result
) = culength
;
2583 LNFOFF (result
) = lnfoff
;
2584 result
-> readin
= 0;
2585 result
-> symtab
= NULL
;
2586 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2587 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2588 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2590 result
->n_global_syms
= 0;
2591 result
->n_static_syms
= 0;
2600 add_psymbol_to_list -- add a partial symbol to given list
2604 Add a partial symbol to one of the partial symbol vectors (pointed to
2605 by listp). The vector is grown as necessary.
2610 DEFUN(add_psymbol_to_list
,
2611 (listp
, name
, space
, class, value
),
2612 struct psymbol_allocation_list
*listp AND
2614 enum namespace space AND
2615 enum address_class
class AND
2618 struct partial_symbol
*psym
;
2621 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2623 newsize
= listp
-> size
* 2;
2624 listp
-> list
= (struct partial_symbol
*)
2625 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2626 /* Next assumes we only went one over. Should be good if program works
2628 listp
-> next
= listp
-> list
+ listp
-> size
;
2629 listp
-> size
= newsize
;
2631 psym
= listp
-> next
++;
2632 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2633 SYMBOL_NAMESPACE (psym
) = space
;
2634 SYMBOL_CLASS (psym
) = class;
2635 SYMBOL_VALUE (psym
) = value
;
2642 add_partial_symbol -- add symbol to partial symbol table
2646 Given a DIE, if it is one of the types that we want to
2647 add to a partial symbol table, finish filling in the die info
2648 and then add a partial symbol table entry for it.
2653 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2655 switch (dip
-> dietag
)
2657 case TAG_global_subroutine
:
2658 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2659 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2660 LOC_BLOCK
, dip
-> at_low_pc
);
2662 case TAG_global_variable
:
2663 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2665 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2668 case TAG_subroutine
:
2669 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2670 LOC_BLOCK
, dip
-> at_low_pc
);
2672 case TAG_local_variable
:
2673 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2677 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2680 case TAG_structure_type
:
2681 case TAG_union_type
:
2682 case TAG_enumeration_type
:
2683 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2693 scan_partial_symbols -- scan DIE's within a single compilation unit
2697 Process the DIE's within a single compilation unit, looking for
2698 interesting DIE's that contribute to the partial symbol table entry
2699 for this compilation unit. Since we cannot follow any sibling
2700 chains without reading the complete DIE info for every DIE,
2701 it is probably faster to just sequentially check each one to
2702 see if it is one of the types we are interested in, and if
2703 so, then extracting all the attributes info and generating a
2704 partial symbol table entry.
2708 Don't attempt to add anonymous structures, unions, or enumerations
2709 since they have no name. Also, for variables and subroutines,
2710 check that this is the place where the actual definition occurs,
2711 rather than just a reference to an external.
2716 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2721 while (thisdie
< enddie
)
2723 basicdieinfo (&di
, thisdie
);
2724 if (di
.dielength
< sizeof (long))
2730 nextdie
= thisdie
+ di
.dielength
;
2733 case TAG_global_subroutine
:
2734 case TAG_subroutine
:
2735 case TAG_global_variable
:
2736 case TAG_local_variable
:
2737 completedieinfo (&di
);
2738 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2740 add_partial_symbol (&di
);
2744 case TAG_structure_type
:
2745 case TAG_union_type
:
2746 case TAG_enumeration_type
:
2747 completedieinfo (&di
);
2750 add_partial_symbol (&di
);
2763 scan_compilation_units -- build a psymtab entry for each compilation
2767 This is the top level dwarf parsing routine for building partial
2770 It scans from the beginning of the DWARF table looking for the first
2771 TAG_compile_unit DIE, and then follows the sibling chain to locate
2772 each additional TAG_compile_unit DIE.
2774 For each TAG_compile_unit DIE it creates a partial symtab structure,
2775 calls a subordinate routine to collect all the compilation unit's
2776 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2777 new partial symtab structure into the partial symbol table. It also
2778 records the appropriate information in the partial symbol table entry
2779 to allow the chunk of DIE's and line number table for this compilation
2780 unit to be located and re-read later, to generate a complete symbol
2781 table entry for the compilation unit.
2783 Thus it effectively partitions up a chunk of DIE's for multiple
2784 compilation units into smaller DIE chunks and line number tables,
2785 and associates them with a partial symbol table entry.
2789 If any compilation unit has no line number table associated with
2790 it for some reason (a missing at_stmt_list attribute, rather than
2791 just one with a value of zero, which is valid) then we ensure that
2792 the recorded file offset is zero so that the routine which later
2793 reads line number table fragments knows that there is no fragment
2803 DEFUN(scan_compilation_units
,
2804 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2809 unsigned int dbfoff AND
2810 unsigned int lnoffset AND
2811 struct objfile
*objfile
)
2815 struct partial_symtab
*pst
;
2820 while (thisdie
< enddie
)
2822 basicdieinfo (&di
, thisdie
);
2823 if (di
.dielength
< sizeof (long))
2827 else if (di
.dietag
!= TAG_compile_unit
)
2829 nextdie
= thisdie
+ di
.dielength
;
2833 completedieinfo (&di
);
2834 if (di
.at_sibling
!= 0)
2836 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2840 nextdie
= thisdie
+ di
.dielength
;
2842 curoff
= thisdie
- dbbase
;
2843 culength
= nextdie
- thisdie
;
2844 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2845 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2846 di
.at_low_pc
, di
.at_high_pc
,
2847 dbfoff
, curoff
, culength
, curlnoffset
,
2848 global_psymbols
.next
,
2849 static_psymbols
.next
);
2850 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2851 pst
-> n_global_syms
= global_psymbols
.next
-
2852 (global_psymbols
.list
+ pst
-> globals_offset
);
2853 pst
-> n_static_syms
= static_psymbols
.next
-
2854 (static_psymbols
.list
+ pst
-> statics_offset
);
2855 /* Sort the global list; don't sort the static list */
2856 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2857 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2859 /* If there is already a psymtab or symtab for a file of this name,
2860 remove it. (If there is a symtab, more drastic things also
2861 happen.) This happens in VxWorks. */
2862 free_named_symtabs (pst
-> filename
);
2863 /* Place the partial symtab on the partial symtab list */
2864 pst
-> next
= partial_symtab_list
;
2865 partial_symtab_list
= pst
;
2875 new_symbol -- make a symbol table entry for a new symbol
2879 static struct symbol *new_symbol (struct dieinfo *dip)
2883 Given a pointer to a DWARF information entry, figure out if we need
2884 to make a symbol table entry for it, and if so, create a new entry
2885 and return a pointer to it.
2888 static struct symbol
*
2889 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2891 struct symbol
*sym
= NULL
;
2893 if (dip
-> at_name
!= NULL
)
2895 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2896 sizeof (struct symbol
));
2897 (void) memset (sym
, 0, sizeof (struct symbol
));
2898 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2899 /* default assumptions */
2900 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2901 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2902 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2903 switch (dip
-> dietag
)
2906 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2907 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2909 case TAG_global_subroutine
:
2910 case TAG_subroutine
:
2911 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2912 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2913 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2914 if (dip
-> dietag
== TAG_global_subroutine
)
2916 add_symbol_to_list (sym
, &global_symbols
);
2920 add_symbol_to_list (sym
, &scope
-> symbols
);
2923 case TAG_global_variable
:
2924 case TAG_local_variable
:
2925 if (dip
-> at_location
!= NULL
)
2927 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2929 if (dip
-> dietag
== TAG_global_variable
)
2931 add_symbol_to_list (sym
, &global_symbols
);
2932 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2933 SYMBOL_VALUE (sym
) += baseaddr
;
2937 add_symbol_to_list (sym
, &scope
-> symbols
);
2938 if (scope
-> parent
!= NULL
)
2942 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2946 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2951 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2952 SYMBOL_VALUE (sym
) += baseaddr
;
2956 case TAG_formal_parameter
:
2957 if (dip
-> at_location
!= NULL
)
2959 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2961 add_symbol_to_list (sym
, &scope
-> symbols
);
2964 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2968 SYMBOL_CLASS (sym
) = LOC_ARG
;
2971 case TAG_unspecified_parameters
:
2972 /* From varargs functions; gdb doesn't seem to have any interest in
2973 this information, so just ignore it for now. (FIXME?) */
2975 case TAG_structure_type
:
2976 case TAG_union_type
:
2977 case TAG_enumeration_type
:
2978 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2979 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2980 add_symbol_to_list (sym
, &scope
-> symbols
);
2983 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2984 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2985 add_symbol_to_list (sym
, &scope
-> symbols
);
2988 /* Not a tag we recognize. Hopefully we aren't processing trash
2989 data, but since we must specifically ignore things we don't
2990 recognize, there is nothing else we should do at this point. */
3001 decode_mod_fund_type -- decode a modified fundamental type
3005 static struct type *decode_mod_fund_type (char *typedata)
3009 Decode a block of data containing a modified fundamental
3010 type specification. TYPEDATA is a pointer to the block,
3011 which consists of a two byte length, containing the size
3012 of the rest of the block. At the end of the block is a
3013 two byte value that gives the fundamental type. Everything
3014 in between are type modifiers.
3016 We simply compute the number of modifiers and call the general
3017 function decode_modified_type to do the actual work.
3020 static struct type
*
3021 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3023 struct type
*typep
= NULL
;
3024 unsigned short modcount
;
3025 unsigned char *modifiers
;
3027 /* Get the total size of the block, exclusive of the size itself */
3028 (void) memcpy (&modcount
, typedata
, sizeof (short));
3029 /* Deduct the size of the fundamental type bytes at the end of the block. */
3030 modcount
-= sizeof (short);
3031 /* Skip over the two size bytes at the beginning of the block. */
3032 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3033 /* Now do the actual decoding */
3034 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3042 decode_mod_u_d_type -- decode a modified user defined type
3046 static struct type *decode_mod_u_d_type (char *typedata)
3050 Decode a block of data containing a modified user defined
3051 type specification. TYPEDATA is a pointer to the block,
3052 which consists of a two byte length, containing the size
3053 of the rest of the block. At the end of the block is a
3054 four byte value that gives a reference to a user defined type.
3055 Everything in between are type modifiers.
3057 We simply compute the number of modifiers and call the general
3058 function decode_modified_type to do the actual work.
3061 static struct type
*
3062 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3064 struct type
*typep
= NULL
;
3065 unsigned short modcount
;
3066 unsigned char *modifiers
;
3068 /* Get the total size of the block, exclusive of the size itself */
3069 (void) memcpy (&modcount
, typedata
, sizeof (short));
3070 /* Deduct the size of the reference type bytes at the end of the block. */
3071 modcount
-= sizeof (long);
3072 /* Skip over the two size bytes at the beginning of the block. */
3073 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3074 /* Now do the actual decoding */
3075 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3083 decode_modified_type -- decode modified user or fundamental type
3087 static struct type *decode_modified_type (unsigned char *modifiers,
3088 unsigned short modcount, int mtype)
3092 Decode a modified type, either a modified fundamental type or
3093 a modified user defined type. MODIFIERS is a pointer to the
3094 block of bytes that define MODCOUNT modifiers. Immediately
3095 following the last modifier is a short containing the fundamental
3096 type or a long containing the reference to the user defined
3097 type. Which one is determined by MTYPE, which is either
3098 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3099 type we are generating.
3101 We call ourself recursively to generate each modified type,`
3102 until MODCOUNT reaches zero, at which point we have consumed
3103 all the modifiers and generate either the fundamental type or
3104 user defined type. When the recursion unwinds, each modifier
3105 is applied in turn to generate the full modified type.
3109 If we find a modifier that we don't recognize, and it is not one
3110 of those reserved for application specific use, then we issue a
3111 warning and simply ignore the modifier.
3115 We currently ignore MOD_const and MOD_volatile. (FIXME)
3119 static struct type
*
3120 DEFUN(decode_modified_type
,
3121 (modifiers
, modcount
, mtype
),
3122 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3124 struct type
*typep
= NULL
;
3125 unsigned short fundtype
;
3127 unsigned char modifier
;
3133 case AT_mod_fund_type
:
3134 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3135 typep
= decode_fund_type (fundtype
);
3137 case AT_mod_u_d_type
:
3138 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3139 if ((typep
= lookup_utype (dieref
)) == NULL
)
3141 typep
= alloc_utype (dieref
, NULL
);
3145 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3146 typep
= builtin_type_int
;
3152 modifier
= *modifiers
++;
3153 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3156 case MOD_pointer_to
:
3157 typep
= lookup_pointer_type (typep
);
3159 case MOD_reference_to
:
3160 typep
= lookup_reference_type (typep
);
3163 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3166 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3169 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3171 SQUAWK (("unknown type modifier %u", modifier
));
3183 decode_fund_type -- translate basic DWARF type to gdb base type
3187 Given an integer that is one of the fundamental DWARF types,
3188 translate it to one of the basic internal gdb types and return
3189 a pointer to the appropriate gdb type (a "struct type *").
3193 If we encounter a fundamental type that we are unprepared to
3194 deal with, and it is not in the range of those types defined
3195 as application specific types, then we issue a warning and
3196 treat the type as builtin_type_int.
3199 static struct type
*
3200 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3202 struct type
*typep
= NULL
;
3208 typep
= builtin_type_void
;
3211 case FT_pointer
: /* (void *) */
3212 typep
= lookup_pointer_type (builtin_type_void
);
3216 case FT_signed_char
:
3217 typep
= builtin_type_char
;
3221 case FT_signed_short
:
3222 typep
= builtin_type_short
;
3226 case FT_signed_integer
:
3227 case FT_boolean
: /* Was FT_set in AT&T version */
3228 typep
= builtin_type_int
;
3232 case FT_signed_long
:
3233 typep
= builtin_type_long
;
3237 typep
= builtin_type_float
;
3240 case FT_dbl_prec_float
:
3241 typep
= builtin_type_double
;
3244 case FT_unsigned_char
:
3245 typep
= builtin_type_unsigned_char
;
3248 case FT_unsigned_short
:
3249 typep
= builtin_type_unsigned_short
;
3252 case FT_unsigned_integer
:
3253 typep
= builtin_type_unsigned_int
;
3256 case FT_unsigned_long
:
3257 typep
= builtin_type_unsigned_long
;
3260 case FT_ext_prec_float
:
3261 typep
= builtin_type_long_double
;
3265 typep
= builtin_type_complex
;
3268 case FT_dbl_prec_complex
:
3269 typep
= builtin_type_double_complex
;
3273 case FT_signed_long_long
:
3274 typep
= builtin_type_long_long
;
3277 case FT_unsigned_long_long
:
3278 typep
= builtin_type_unsigned_long_long
;
3283 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3285 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3286 typep
= builtin_type_void
;
3296 create_name -- allocate a fresh copy of a string on an obstack
3300 Given a pointer to a string and a pointer to an obstack, allocates
3301 a fresh copy of the string on the specified obstack.
3306 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3311 length
= strlen (name
) + 1;
3312 newname
= (char *) obstack_alloc (obstackp
, length
);
3313 (void) strcpy (newname
, name
);
3321 basicdieinfo -- extract the minimal die info from raw die data
3325 void basicdieinfo (char *diep, struct dieinfo *dip)
3329 Given a pointer to raw DIE data, and a pointer to an instance of a
3330 die info structure, this function extracts the basic information
3331 from the DIE data required to continue processing this DIE, along
3332 with some bookkeeping information about the DIE.
3334 The information we absolutely must have includes the DIE tag,
3335 and the DIE length. If we need the sibling reference, then we
3336 will have to call completedieinfo() to process all the remaining
3339 Note that since there is no guarantee that the data is properly
3340 aligned in memory for the type of access required (indirection
3341 through anything other than a char pointer), we use memcpy to
3342 shuffle data items larger than a char. Possibly inefficient, but
3345 We also take care of some other basic things at this point, such
3346 as ensuring that the instance of the die info structure starts
3347 out completely zero'd and that curdie is initialized for use
3348 in error reporting if we have a problem with the current die.
3352 All DIE's must have at least a valid length, thus the minimum
3353 DIE size is sizeof (long). In order to have a valid tag, the
3354 DIE size must be at least sizeof (short) larger, otherwise they
3355 are forced to be TAG_padding DIES.
3357 Padding DIES must be at least sizeof(long) in length, implying that
3358 if a padding DIE is used for alignment and the amount needed is less
3359 than sizeof(long) then the padding DIE has to be big enough to align
3360 to the next alignment boundry.
3364 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3367 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3369 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3370 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3371 if (dip
-> dielength
< sizeof (long))
3373 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3375 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3377 dip
-> dietag
= TAG_padding
;
3381 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3389 completedieinfo -- finish reading the information for a given DIE
3393 void completedieinfo (struct dieinfo *dip)
3397 Given a pointer to an already partially initialized die info structure,
3398 scan the raw DIE data and finish filling in the die info structure
3399 from the various attributes found.
3401 Note that since there is no guarantee that the data is properly
3402 aligned in memory for the type of access required (indirection
3403 through anything other than a char pointer), we use memcpy to
3404 shuffle data items larger than a char. Possibly inefficient, but
3409 Each time we are called, we increment the diecount variable, which
3410 keeps an approximate count of the number of dies processed for
3411 each compilation unit. This information is presented to the user
3412 if the info_verbose flag is set.
3417 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3419 char *diep
; /* Current pointer into raw DIE data */
3420 char *end
; /* Terminate DIE scan here */
3421 unsigned short attr
; /* Current attribute being scanned */
3422 unsigned short form
; /* Form of the attribute */
3423 short block2sz
; /* Size of a block2 attribute field */
3424 long block4sz
; /* Size of a block4 attribute field */
3428 end
= diep
+ dip
-> dielength
;
3429 diep
+= sizeof (long) + sizeof (short);
3432 (void) memcpy (&attr
, diep
, sizeof (short));
3433 diep
+= sizeof (short);
3437 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3440 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3443 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3446 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3449 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3452 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3453 dip
-> has_at_stmt_list
= 1;
3456 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3457 dip
-> has_at_low_pc
= 1;
3460 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3463 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3465 case AT_user_def_type
:
3466 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3469 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3472 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3475 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3478 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3481 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3484 dip
-> at_location
= diep
;
3486 case AT_mod_fund_type
:
3487 dip
-> at_mod_fund_type
= diep
;
3489 case AT_subscr_data
:
3490 dip
-> at_subscr_data
= diep
;
3492 case AT_mod_u_d_type
:
3493 dip
-> at_mod_u_d_type
= diep
;
3495 case AT_element_list
:
3496 dip
-> at_element_list
= diep
;
3497 dip
-> short_element_list
= 0;
3499 case AT_short_element_list
:
3500 dip
-> at_element_list
= diep
;
3501 dip
-> short_element_list
= 1;
3503 case AT_discr_value
:
3504 dip
-> at_discr_value
= diep
;
3506 case AT_string_length
:
3507 dip
-> at_string_length
= diep
;
3510 dip
-> at_name
= diep
;
3513 dip
-> at_comp_dir
= diep
;
3516 dip
-> at_producer
= diep
;
3519 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3521 case AT_start_scope
:
3522 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3524 case AT_stride_size
:
3525 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3528 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3531 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3534 /* Found an attribute that we are unprepared to handle. However
3535 it is specifically one of the design goals of DWARF that
3536 consumers should ignore unknown attributes. As long as the
3537 form is one that we recognize (so we know how to skip it),
3538 we can just ignore the unknown attribute. */
3545 diep
+= sizeof (short);
3548 diep
+= sizeof (long);
3551 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3555 diep
+= sizeof (long);
3558 (void) memcpy (&block2sz
, diep
, sizeof (short));
3559 block2sz
+= sizeof (short);
3563 (void) memcpy (&block4sz
, diep
, sizeof (long));
3564 block4sz
+= sizeof (long);
3568 diep
+= strlen (diep
) + 1;
3571 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));