1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support, portions based on dbxread.c,
4 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 FIXME: Figure out how to get the frame pointer register number in the
25 execution environment of the target. Remove R_FP kludge
27 FIXME: Add generation of dependencies list to partial symtab code.
29 FIXME: Currently we ignore host/target byte ordering and integer size
30 differences. Should remap data from external form to an internal form
31 before trying to use it.
33 FIXME: Resolve minor differences between what information we put in the
34 partial symbol table and what dbxread puts in. For example, we don't yet
35 put enum constants there. And dbxread seems to invent a lot of typedefs
36 we never see. Use the new printpsym command to see the partial symbol table
39 FIXME: Change forward declarations of static functions to allow for compilers
42 FIXME: Figure out a better way to tell gdb (all the debug reading routines)
43 the names of the gccX_compiled flags.
45 FIXME: Figure out a better way to tell gdb about the name of the function
46 contain the user's entry point (I.E. main())
48 FIXME: The current DWARF specification has a very strong bias towards
49 machines with 32-bit integers, as it assumes that many attributes of the
50 program (such as an address) will fit in such an integer. There are many
51 references in the spec to things that are 2, 4, or 8 bytes long. Given that
52 we will probably run into problems on machines where some of these assumptions
53 are invalid (64-bit ints for example), we don't bother at this time to try to
54 make this code more flexible and just use shorts, ints, and longs (and their
55 sizes) where it seems appropriate. I.E. we use a short int to hold DWARF
56 tags, and assume that the tag size in the file is the same as sizeof(short).
58 FIXME: Figure out how to get the name of the symbol indicating that a module
59 has been compiled with gcc (gcc_compiledXX) in a more portable way than
60 hardcoding it into the object file readers.
62 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
63 other things to work on, if you get bored. :-)
79 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
80 #define SQUAWK(stuff) dwarfwarn stuff
85 #ifndef R_FP /* FIXME */
86 #define R_FP 14 /* Kludge to get frame pointer register number */
89 typedef unsigned int DIEREF
; /* Reference to a DIE */
91 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled%" /* FIXME */
92 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled%" /* FIXME */
94 #define STREQ(a,b) (strcmp(a,b)==0)
96 extern CORE_ADDR entry_point
; /* Process entry point */
97 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
98 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
99 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
100 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
101 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
102 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
103 extern int info_verbose
; /* From main.c; nonzero => verbose */
106 /* The DWARF debugging information consists of two major pieces,
107 one is a block of DWARF Information Entries (DIE's) and the other
108 is a line number table. The "struct dieinfo" structure contains
109 the information for a single DIE, the one currently being processed.
111 In order to make it easier to randomly access the attribute fields
112 of the current DIE, which are specifically unordered within the DIE
113 each DIE is scanned and an instance of the "struct dieinfo"
114 structure is initialized.
116 Initialization is done in two levels. The first, done by basicdieinfo(),
117 just initializes those fields that are vital to deciding whether or not
118 to use this DIE, how to skip past it, etc. The second, done by the
119 function completedieinfo(), fills in the rest of the information.
121 Attributes which have block forms are not interpreted at the time
122 the DIE is scanned, instead we just save pointers to the start
123 of their value fields.
125 Some fields have a flag <name>_p that is set when the value of the
126 field is valid (I.E. we found a matching attribute in the DIE). Since
127 we may want to test for the presence of some attributes in the DIE,
128 such as AT_is_external, without restricting the values of the field,
129 we need someway to note that we found such an attribute.
136 char * die
; /* Pointer to the raw DIE data */
137 long dielength
; /* Length of the raw DIE data */
138 DIEREF dieref
; /* Offset of this DIE */
139 short dietag
; /* Tag for this DIE */
144 unsigned short at_fund_type
;
145 BLOCK
* at_mod_fund_type
;
146 long at_user_def_type
;
147 BLOCK
* at_mod_u_d_type
;
149 BLOCK
* at_subscr_data
;
153 BLOCK
* at_deriv_list
;
154 BLOCK
* at_element_list
;
161 BLOCK
* at_discr_value
;
164 BLOCK
* at_string_length
;
174 BLOCK
* at_const_data
;
175 short at_is_external
;
176 unsigned int at_is_external_p
:1;
177 unsigned int at_stmt_list_p
:1;
180 static int diecount
; /* Approximate count of dies for compilation unit */
181 static struct dieinfo
*curdie
; /* For warnings and such */
183 static char *dbbase
; /* Base pointer to dwarf info */
184 static int dbroff
; /* Relative offset from start of .debug section */
185 static char *lnbase
; /* Base pointer to line section */
186 static int isreg
; /* Kludge to identify register variables */
188 static CORE_ADDR baseaddr
; /* Add to each symbol value */
190 /* Each partial symbol table entry contains a pointer to private data for the
191 read_symtab() function to use when expanding a partial symbol table entry
192 to a full symbol table entry. For DWARF debugging info, this data is
193 contained in the following structure and macros are provided for easy
194 access to the members given a pointer to a partial symbol table entry.
196 dbfoff Always the absolute file offset to the start of the ".debug"
197 section for the file containing the DIE's being accessed.
199 dbroff Relative offset from the start of the ".debug" access to the
200 first DIE to be accessed. When building the partial symbol
201 table, this value will be zero since we are accessing the
202 entire ".debug" section. When expanding a partial symbol
203 table entry, this value will be the offset to the first
204 DIE for the compilation unit containing the symbol that
205 triggers the expansion.
207 dblength The size of the chunk of DIE's being examined, in bytes.
209 lnfoff The absolute file offset to the line table fragment. Ignored
210 when building partial symbol tables, but used when expanding
211 them, and contains the absolute file offset to the fragment
212 of the ".line" section containing the line numbers for the
213 current compilation unit.
217 int dbfoff
; /* Absolute file offset to start of .debug section */
218 int dbroff
; /* Relative offset from start of .debug section */
219 int dblength
; /* Size of the chunk of DIE's being examined */
220 int lnfoff
; /* Absolute file offset to line table fragment */
223 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
224 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
225 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
226 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
228 /* Record the symbols defined for each context in a linked list. We don't
229 create a struct block for the context until we know how long to make it.
230 Global symbols for each file are maintained in the global_symbols list. */
232 struct pending_symbol
{
233 struct pending_symbol
*next
; /* Next pending symbol */
234 struct symbol
*symbol
; /* The actual symbol */
237 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
238 static struct block
*global_symbol_block
;
240 /* Line number entries are read into a dynamically expandable vector before
241 being added to the symbol table section. Once we know how many there are
244 static struct linetable
*line_vector
; /* Vector of line numbers. */
245 static int line_vector_index
; /* Index of next entry. */
246 static int line_vector_length
; /* Current allocation limit */
248 /* Scope information is kept in a scope tree, one node per scope. Each time
249 a new scope is started, a child node is created under the current node
250 and set to the current scope. Each time a scope is closed, the current
251 scope moves back up the tree to the parent of the current scope.
253 Each scope contains a pointer to the list of symbols defined in the scope,
254 a pointer to the block vector for the scope, a pointer to the symbol
255 that names the scope (if any), and the range of PC values that mark
256 the start and end of the scope. */
259 struct scopenode
*parent
;
260 struct scopenode
*child
;
261 struct scopenode
*sibling
;
262 struct pending_symbol
*symbols
;
264 struct symbol
*namesym
;
269 static struct scopenode
*scopetree
;
270 static struct scopenode
*scope
;
272 /* DIES which have user defined types or modified user defined types refer to
273 other DIES for the type information. Thus we need to associate the offset
274 of a DIE for a user defined type with a pointer to the type information.
276 Originally this was done using a simple but expensive algorithm, with an
277 array of unsorted structures, each containing an offset/type-pointer pair.
278 This array was scanned linearly each time a lookup was done. The result
279 was that gdb was spending over half it's startup time munging through this
280 array of pointers looking for a structure that had the right offset member.
282 The second attempt used the same array of structures, but the array was
283 sorted using qsort each time a new offset/type was recorded, and a binary
284 search was used to find the type pointer for a given DIE offset. This was
285 even slower, due to the overhead of sorting the array each time a new
286 offset/type pair was entered.
288 The third attempt uses a fixed size array of type pointers, indexed by a
289 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
290 we can divide any DIE offset by 4 to obtain a unique index into this fixed
291 size array. Since each element is a 4 byte pointer, it takes exactly as
292 much memory to hold this array as to hold the DWARF info for a given
293 compilation unit. But it gets freed as soon as we are done with it. */
295 static struct type
**utypes
; /* Pointer to array of user type pointers */
296 static int numutypes
; /* Max number of user type pointers */
298 /* Forward declarations of static functions so we don't have to worry
299 about ordering within this file. The EXFUN macro may be slightly
300 misleading. Should probably be called DCLFUN instead, or something
301 more intuitive, since it can be used for both static and external
304 static void dwarfwarn (); /* EXFUN breaks with <varargs.h> (FIXME)*/
307 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
310 EXFUN (scan_compilation_units
,
311 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
312 AND
unsigned int dbfoff AND
unsigned int lnoffset
));
314 static struct partial_symtab
*
315 EXFUN(start_psymtab
, (char *symfile_name AND CORE_ADDR addr
316 AND
char *filename AND CORE_ADDR textlow
317 AND CORE_ADDR texthigh AND
int dbfoff
318 AND
int curoff AND
int culength AND
int lnfoff
319 AND
struct partial_symbol
*global_syms
320 AND
struct partial_symbol
*static_syms
));
322 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
325 EXFUN(add_psymbol_to_list
,
326 (struct psymbol_allocation_list
*listp AND
char *name
327 AND
enum namespace space AND
enum address_class
class
328 AND CORE_ADDR value
));
331 EXFUN(init_psymbol_list
, (int total_symbols
));
334 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
337 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
340 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
343 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst AND
int desc
));
345 static struct symtab
*
346 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst AND
int desc
));
349 EXFUN(process_dies
, (char *thisdie AND
char *enddie
));
352 EXFUN(read_lexical_block_scope
,
353 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
356 EXFUN(read_structure_scope
,
357 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
360 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
363 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
366 EXFUN(read_array_type
, (struct dieinfo
*dip
));
369 EXFUN(read_subroutine_type
,
370 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
373 EXFUN(read_enumeration
,
374 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
378 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
381 EXFUN(enum_type
, (struct dieinfo
*dip
));
384 EXFUN(read_func_scope
,
385 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
388 EXFUN(read_file_scope
,
389 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
392 EXFUN(start_symtab
, (void));
395 EXFUN(end_symtab
, (char *filename AND
long language
));
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
));
464 EXFUN(compare_psymbols
,
465 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
472 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
476 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
477 int mainline, unsigned int dbfoff, unsigned int dbsize,
478 unsigned int lnoffset, unsigned int lnsize)
482 This function is called upon to build partial symtabs from files
483 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
485 It is passed a file descriptor for an open file containing the DIES
486 and line number information, the corresponding filename for that
487 file, a base address for relocating the symbols, a flag indicating
488 whether or not this debugging information is from a "main symbol
489 table" rather than a shared library or dynamically linked file,
490 and file offset/size pairs for the DIE information and line number
500 DEFUN(dwarf_build_psymtabs
,
501 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
),
506 unsigned int dbfoff AND
507 unsigned int dbsize AND
508 unsigned int lnoffset AND
511 struct cleanup
*back_to
;
513 dbbase
= xmalloc (dbsize
);
515 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
516 (read (desc
, dbbase
, dbsize
) != dbsize
))
519 error ("can't read DWARF data from '%s'", filename
);
521 back_to
= make_cleanup (free
, dbbase
);
523 /* If we are reinitializing, or if we have never loaded syms yet, init.
524 Since we have no idea how many DIES we are looking at, we just guess
525 some arbitrary value. */
527 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
529 init_psymbol_list (1024);
532 init_misc_bunches ();
533 make_cleanup (discard_misc_bunches
, 0);
535 /* Follow the compilation unit sibling chain, building a partial symbol
536 table entry for each one. Save enough information about each compilation
537 unit to locate the full DWARF information later. */
539 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
542 /* Go over the miscellaneous functions and install them in the miscellaneous
545 condense_misc_bunches (!mainline
);
546 do_cleanups (back_to
);
554 record_misc_function -- add entry to miscellaneous function vector
558 static void record_misc_function (char *name, CORE_ADDR address)
562 Given a pointer to the name of a symbol that should be added to the
563 miscellaneous function vector, and the address associated with that
564 symbol, records this information for later use in building the
565 miscellaneous function vector.
569 FIXME: For now we just use mf_text as the type. This should be
574 DEFUN(record_misc_function
, (name
, address
), char *name AND CORE_ADDR address
)
576 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
584 dwarfwarn -- issue a DWARF related warning
588 Issue warnings about DWARF related things that aren't serious enough
589 to warrant aborting with an error, but should not be ignored either.
590 This includes things like detectable corruption in DIE's, missing
591 DIE's, unimplemented features, etc.
593 In general, running across tags or attributes that we don't recognize
594 is not considered to be a problem and we should not issue warnings
599 We mostly follow the example of the error() routine, but without
600 returning to command level. It is arguable about whether warnings
601 should be issued at all, and if so, where they should go (stdout or
604 We assume that curdie is valid and contains at least the basic
605 information for the DIE where the problem was noticed.
616 fmt
= va_arg (ap
, char *);
618 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
619 if (curdie
-> at_name
)
621 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
623 vfprintf (stderr
, fmt
, ap
);
624 fprintf (stderr
, "\n");
633 compare_psymbols -- compare two partial symbols by name
637 Given pointer to two partial symbol table entries, compare
638 them by name and return -N, 0, or +N (ala strcmp). Typically
639 used by sorting routines like qsort().
643 This is a copy from dbxread.c. It should be moved to a generic
644 gdb file and made available for all psymtab builders (FIXME).
646 Does direct compare of first two characters before punting
647 and passing to strcmp for longer compares. Note that the
648 original version had a bug whereby two null strings or two
649 identically named one character strings would return the
650 comparison of memory following the null byte.
655 DEFUN(compare_psymbols
, (s1
, s2
),
656 struct partial_symbol
*s1 AND
657 struct partial_symbol
*s2
)
659 register char *st1
= SYMBOL_NAME (s1
);
660 register char *st2
= SYMBOL_NAME (s2
);
662 if ((st1
[0] - st2
[0]) || !st1
[0])
664 return (st1
[0] - st2
[0]);
666 else if ((st1
[1] - st2
[1]) || !st1
[1])
668 return (st1
[1] - st2
[1]);
672 return (strcmp (st1
+ 2, st2
+ 2));
680 read_lexical_block_scope -- process all dies in a lexical block
684 static void read_lexical_block_scope (struct dieinfo *dip,
685 char *thisdie, char *enddie)
689 Process all the DIES contained within a lexical block scope.
690 Start a new scope, process the dies, and then close the scope.
695 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
),
696 struct dieinfo
*dip AND
700 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
701 process_dies (thisdie
+ dip
-> dielength
, enddie
);
709 lookup_utype -- look up a user defined type from die reference
713 static type *lookup_utype (DIEREF dieref)
717 Given a DIE reference, lookup the user defined type associated with
718 that DIE, if it has been registered already. If not registered, then
719 return NULL. Alloc_utype() can be called to register an empty
720 type for this reference, which will be filled in later when the
721 actual referenced DIE is processed.
725 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
727 struct type
*type
= NULL
;
730 utypeidx
= (dieref
- dbroff
) / 4;
731 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
733 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
737 type
= *(utypes
+ utypeidx
);
747 alloc_utype -- add a user defined type for die reference
751 static type *alloc_utype (DIEREF dieref, struct type *utypep)
755 Given a die reference DIEREF, and a possible pointer to a user
756 defined type UTYPEP, register that this reference has a user
757 defined type and either use the specified type in UTYPEP or
758 make a new empty type that will be filled in later.
760 We should only be called after calling lookup_utype() to verify that
761 there is not currently a type registered for DIEREF.
765 DEFUN(alloc_utype
, (dieref
, utypep
),
772 utypeidx
= (dieref
- dbroff
) / 4;
773 typep
= utypes
+ utypeidx
;
774 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
776 utypep
= builtin_type_int
;
777 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
779 else if (*typep
!= NULL
)
782 SQUAWK (("internal error: dup user type allocation"));
788 utypep
= (struct type
*)
789 obstack_alloc (symbol_obstack
, sizeof (struct type
));
790 (void) memset (utypep
, 0, sizeof (struct type
));
801 decode_die_type -- return a type for a specified die
805 static struct type *decode_die_type (struct dieinfo *dip)
809 Given a pointer to a die information structure DIP, decode the
810 type of the die and return a pointer to the decoded type. All
811 dies without specific types default to type int.
815 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
817 struct type
*type
= NULL
;
819 if (dip
-> at_fund_type
!= 0)
821 type
= decode_fund_type (dip
-> at_fund_type
);
823 else if (dip
-> at_mod_fund_type
!= NULL
)
825 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
827 else if (dip
-> at_user_def_type
)
829 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
831 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
834 else if (dip
-> at_mod_u_d_type
)
836 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
840 type
= builtin_type_int
;
849 struct_type -- compute and return the type for a struct or union
853 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
858 Given pointer to a die information structure for a die which
859 defines a union or structure, and pointers to the raw die data
860 that define the range of dies which define the members, compute
861 and return the user defined type for the structure or union.
865 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
866 struct dieinfo
*dip AND
872 struct nextfield
*next
;
875 struct nextfield
*list
= NULL
;
876 struct nextfield
*new;
884 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
886 type
= alloc_utype (dip
-> dieref
, NULL
);
888 switch (dip
-> dietag
)
890 case TAG_structure_type
:
891 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
895 TYPE_CODE (type
) = TYPE_CODE_UNION
;
900 SQUAWK (("missing structure or union tag"));
901 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
904 if (dip
-> at_name
== NULL
)
910 tpart2
= dip
-> at_name
;
912 if (dip
-> at_byte_size
== 0)
914 tpart3
= " <opaque>";
916 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
919 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
);
920 thisdie
+= dip
-> dielength
;
921 while (thisdie
< enddie
)
923 basicdieinfo (&mbr
, thisdie
);
924 completedieinfo (&mbr
);
925 if (mbr
.dielength
<= sizeof (long))
932 /* Get space to record the next field's data. */
933 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
937 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
938 list
-> field
.type
= decode_die_type (&mbr
);
939 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
940 list
-> field
.bitsize
= 0;
944 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
947 thisdie
+= mbr
.dielength
;
949 /* Now create the vector of fields, and record how big it is. */
950 TYPE_NFIELDS (type
) = nfields
;
951 TYPE_FIELDS (type
) = (struct field
*)
952 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
953 /* Copy the saved-up fields into the field vector. */
954 for (n
= nfields
; list
; list
= list
-> next
)
956 TYPE_FIELD (type
, --n
) = list
-> field
;
965 read_structure_scope -- process all dies within struct or union
969 static void read_structure_scope (struct dieinfo *dip,
970 char *thisdie, char *enddie)
974 Called when we find the DIE that starts a structure or union
975 scope (definition) to process all dies that define the members
976 of the structure or union. DIP is a pointer to the die info
977 struct for the DIE that names the structure or union.
981 Note that we need to call struct_type regardless of whether or not
982 we have a symbol, since we might have a structure or union without
983 a tag name (thus no symbol for the tagname).
987 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
988 struct dieinfo
*dip AND
995 type
= struct_type (dip
, thisdie
, enddie
);
996 if ((sym
= new_symbol (dip
)) != NULL
)
998 SYMBOL_TYPE (sym
) = type
;
1006 decode_array_element_type -- decode type of the array elements
1010 static struct type *decode_array_element_type (char *scan, char *end)
1014 As the last step in decoding the array subscript information for an
1015 array DIE, we need to decode the type of the array elements. We are
1016 passed a pointer to this last part of the subscript information and
1017 must return the appropriate type. If the type attribute is not
1018 recognized, just warn about the problem and return type int.
1021 static struct type
*
1022 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1027 unsigned short fundtype
;
1029 (void) memcpy (&attribute
, scan
, sizeof (short));
1030 scan
+= sizeof (short);
1034 (void) memcpy (&fundtype
, scan
, sizeof (short));
1035 typep
= decode_fund_type (fundtype
);
1037 case AT_mod_fund_type
:
1038 typep
= decode_mod_fund_type (scan
);
1040 case AT_user_def_type
:
1041 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1042 if ((typep
= lookup_utype (dieref
)) == NULL
)
1044 typep
= alloc_utype (dieref
, NULL
);
1047 case AT_mod_u_d_type
:
1048 typep
= decode_mod_u_d_type (scan
);
1051 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1052 typep
= builtin_type_int
;
1062 decode_subscr_data -- decode array subscript and element type data
1066 static struct type *decode_subscr_data (char *scan, char *end)
1070 The array subscripts and the data type of the elements of an
1071 array are described by a list of data items, stored as a block
1072 of contiguous bytes. There is a data item describing each array
1073 dimension, and a final data item describing the element type.
1074 The data items are ordered the same as their appearance in the
1075 source (I.E. leftmost dimension first, next to leftmost second,
1078 We are passed a pointer to the start of the block of bytes
1079 containing the data items, and a pointer to the first byte past
1080 the data. This function decodes the data and returns a type.
1083 FIXME: This code only implements the forms currently used
1084 by the AT&T and GNU C compilers.
1086 The end pointer is supplied for error checking, maybe we should
1090 static struct type
*
1091 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1093 struct type
*typep
= NULL
;
1094 struct type
*nexttype
;
1104 typep
= decode_array_element_type (scan
, end
);
1107 (void) memcpy (&fundtype
, scan
, sizeof (short));
1108 scan
+= sizeof (short);
1109 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1110 && fundtype
!= FT_unsigned_integer
)
1112 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1117 (void) memcpy (&lowbound
, scan
, sizeof (long));
1118 scan
+= sizeof (long);
1119 (void) memcpy (&highbound
, scan
, sizeof (long));
1120 scan
+= sizeof (long);
1121 nexttype
= decode_subscr_data (scan
, end
);
1122 if (nexttype
!= NULL
)
1124 typep
= (struct type
*)
1125 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1126 (void) memset (typep
, 0, sizeof (struct type
));
1127 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1128 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1129 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1130 TYPE_TARGET_TYPE (typep
) = nexttype
;
1141 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1144 SQUAWK (("unknown array subscript format %x", format
));
1154 read_array_type -- read TAG_array_type DIE
1158 static void read_array_type (struct dieinfo *dip)
1162 Extract all information from a TAG_array_type DIE and add to
1163 the user defined type vector.
1167 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1174 if (dip
-> at_ordering
!= ORD_row_major
)
1176 /* FIXME: Can gdb even handle column major arrays? */
1177 SQUAWK (("array not row major; not handled correctly"));
1179 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1181 (void) memcpy (&temp
, sub
, sizeof (short));
1182 subend
= sub
+ sizeof (short) + temp
;
1183 sub
+= sizeof (short);
1184 type
= decode_subscr_data (sub
, subend
);
1187 type
= alloc_utype (dip
-> dieref
, NULL
);
1188 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1189 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1190 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1194 type
= alloc_utype (dip
-> dieref
, type
);
1203 read_subroutine_type -- process TAG_subroutine_type dies
1207 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1212 Handle DIES due to C code like:
1215 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1221 The parameter DIES are currently ignored. See if gdb has a way to
1222 include this info in it's type system, and decode them if so. Is
1223 this what the type structure's "arg_types" field is for? (FIXME)
1227 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1228 struct dieinfo
*dip AND
1234 type
= decode_die_type (dip
);
1235 type
= lookup_function_type (type
);
1236 type
= alloc_utype (dip
-> dieref
, type
);
1243 read_enumeration -- process dies which define an enumeration
1247 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1252 Given a pointer to a die which begins an enumeration, process all
1253 the dies that define the members of the enumeration.
1257 Note that we need to call enum_type regardless of whether or not we
1258 have a symbol, since we might have an enum without a tag name (thus
1259 no symbol for the tagname).
1263 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1264 struct dieinfo
*dip AND
1271 type
= enum_type (dip
);
1272 if ((sym
= new_symbol (dip
)) != NULL
)
1274 SYMBOL_TYPE (sym
) = type
;
1282 enum_type -- decode and return a type for an enumeration
1286 static type *enum_type (struct dieinfo *dip)
1290 Given a pointer to a die information structure for the die which
1291 starts an enumeration, process all the dies that define the members
1292 of the enumeration and return a type pointer for the enumeration.
1295 static struct type
*
1296 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1300 struct nextfield
*next
;
1303 struct nextfield
*list
= NULL
;
1304 struct nextfield
*new;
1314 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1316 type
= alloc_utype (dip
-> dieref
, NULL
);
1318 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1320 if (dip
-> at_name
== NULL
)
1324 tpart2
= dip
-> at_name
;
1326 if (dip
-> at_byte_size
== 0)
1328 tpart3
= " <opaque>";
1332 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1335 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
);
1336 if ((scan
= dip
-> at_element_list
) != NULL
)
1338 (void) memcpy (&temp
, scan
, sizeof (temp
));
1339 listend
= scan
+ temp
+ sizeof (temp
);
1340 scan
+= sizeof (temp
);
1341 while (scan
< listend
)
1343 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1346 list
-> field
.type
= NULL
;
1347 list
-> field
.bitsize
= 0;
1348 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1349 scan
+= sizeof (long);
1350 list
-> field
.name
= savestring (scan
, strlen (scan
));
1351 scan
+= strlen (scan
) + 1;
1355 /* Now create the vector of fields, and record how big it is. */
1356 TYPE_NFIELDS (type
) = nfields
;
1357 TYPE_FIELDS (type
) = (struct field
*)
1358 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1359 /* Copy the saved-up fields into the field vector. */
1360 for (n
= nfields
; list
; list
= list
-> next
)
1362 TYPE_FIELD (type
, --n
) = list
-> field
;
1371 read_func_scope -- process all dies within a function scope
1375 static void read_func_scope (struct dieinfo dip, char *thisdie,
1380 Process all dies within a given function scope. We are passed
1381 a die information structure pointer DIP for the die which
1382 starts the function scope, and pointers into the raw die data
1383 that define the dies within the function scope.
1385 For now, we ignore lexical block scopes within the function.
1386 The problem is that AT&T cc does not define a DWARF lexical
1387 block scope for the function itself, while gcc defines a
1388 lexical block scope for the function. We need to think about
1389 how to handle this difference, or if it is even a problem.
1394 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
),
1395 struct dieinfo
*dip AND
1401 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1403 entry_scope_lowpc
= dip
-> at_low_pc
;
1404 entry_scope_highpc
= dip
-> at_high_pc
;
1406 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1408 main_scope_lowpc
= dip
-> at_low_pc
;
1409 main_scope_highpc
= dip
-> at_high_pc
;
1411 sym
= new_symbol (dip
);
1412 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1413 process_dies (thisdie
+ dip
-> dielength
, enddie
);
1421 read_file_scope -- process all dies within a file scope
1425 static void read_file_scope (struct dieinfo *dip, char *thisdie
1430 Process all dies within a given file scope. We are passed a
1431 pointer to the die information structure for the die which
1432 starts the file scope, and pointers into the raw die data which
1433 mark the range of dies within the file scope.
1435 When the partial symbol table is built, the file offset for the line
1436 number table for each compilation unit is saved in the partial symbol
1437 table entry for that compilation unit. As the symbols for each
1438 compilation unit are read, the line number table is read into memory
1439 and the variable lnbase is set to point to it. Thus all we have to
1440 do is use lnbase to access the line number table for the current
1445 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
),
1446 struct dieinfo
*dip AND
1450 struct cleanup
*back_to
;
1452 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1454 startup_file_start
= dip
-> at_low_pc
;
1455 startup_file_end
= dip
-> at_high_pc
;
1457 numutypes
= (enddie
- thisdie
) / 4;
1458 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1459 back_to
= make_cleanup (free
, utypes
);
1460 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1462 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1463 decode_line_numbers (lnbase
);
1464 process_dies (thisdie
+ dip
-> dielength
, enddie
);
1466 end_symtab (dip
-> at_name
, dip
-> at_language
);
1467 do_cleanups (back_to
);
1476 start_symtab -- do initialization for starting new symbol table
1480 static void start_symtab (void)
1484 Called whenever we are starting to process dies for a new
1485 compilation unit, to perform initializations. Right now
1486 the only thing we really have to do is initialize storage
1487 space for the line number vector.
1492 DEFUN_VOID (start_symtab
)
1496 line_vector_index
= 0;
1497 line_vector_length
= 1000;
1498 nbytes
= sizeof (struct linetable
);
1499 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1500 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1507 process_dies -- process a range of DWARF Information Entries
1511 static void process_dies (char *thisdie, char *enddie)
1515 Process all DIE's in a specified range. May be (and almost
1516 certainly will be) called recursively.
1520 DEFUN(process_dies
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
1525 while (thisdie
< enddie
)
1527 basicdieinfo (&di
, thisdie
);
1528 if (di
.dielength
< sizeof (long))
1532 else if (di
.dietag
== TAG_padding
)
1534 nextdie
= thisdie
+ di
.dielength
;
1538 completedieinfo (&di
);
1539 if (di
.at_sibling
!= 0)
1541 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1545 nextdie
= thisdie
+ di
.dielength
;
1549 case TAG_compile_unit
:
1550 read_file_scope (&di
, thisdie
, nextdie
);
1552 case TAG_global_subroutine
:
1553 case TAG_subroutine
:
1554 if (!di
.at_is_external_p
)
1556 read_func_scope (&di
, thisdie
, nextdie
);
1559 case TAG_lexical_block
:
1560 read_lexical_block_scope (&di
, thisdie
, nextdie
);
1562 case TAG_structure_type
:
1563 case TAG_union_type
:
1564 read_structure_scope (&di
, thisdie
, nextdie
);
1566 case TAG_enumeration_type
:
1567 read_enumeration (&di
, thisdie
, nextdie
);
1569 case TAG_subroutine_type
:
1570 read_subroutine_type (&di
, thisdie
, nextdie
);
1572 case TAG_array_type
:
1573 read_array_type (&di
);
1576 (void) new_symbol (&di
);
1588 end_symtab -- finish processing for a compilation unit
1592 static void end_symtab (char *filename, long language)
1596 Complete the symbol table entry for the current compilation
1597 unit. Make the struct symtab and put it on the list of all
1603 DEFUN(end_symtab
, (filename
, language
), char *filename AND
long language
)
1605 struct symtab
*symtab
;
1606 struct blockvector
*blockvector
;
1609 /* Ignore a file that has no functions with real debugging info. */
1610 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1614 line_vector_length
= -1;
1615 freescope (scopetree
);
1616 scope
= scopetree
= NULL
;
1619 /* Create the blockvector that points to all the file's blocks. */
1621 blockvector
= make_blockvector ();
1623 /* Now create the symtab object for this source file. */
1625 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
1626 (void) memset (symtab
, 0, sizeof (struct symtab
));
1628 symtab
-> free_ptr
= 0;
1630 /* Fill in its components. */
1631 symtab
-> blockvector
= blockvector
;
1632 symtab
-> free_code
= free_linetable
;
1633 symtab
-> filename
= savestring (filename
, strlen (filename
));
1635 /* Save the line number information. */
1637 line_vector
-> nitems
= line_vector_index
;
1638 nbytes
= sizeof (struct linetable
);
1639 if (line_vector_index
> 1)
1641 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1643 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1644 symtab
-> nlines
= 0;
1645 symtab
-> line_charpos
= 0;
1647 /* FIXME: The following may need to be expanded for other languages */
1648 if (language
== LANG_C89
|| language
== LANG_C
)
1650 symtab
-> language
= language_c
;
1653 /* Link the new symtab into the list of such. */
1654 symtab
-> next
= symtab_list
;
1655 symtab_list
= symtab
;
1657 /* Recursively free the scope tree */
1658 freescope (scopetree
);
1659 scope
= scopetree
= NULL
;
1661 /* Reinitialize for beginning of new file. */
1663 line_vector_length
= -1;
1670 scopecount -- count the number of enclosed scopes
1674 static int scopecount (struct scopenode *node)
1678 Given pointer to a node, compute the size of the subtree which is
1679 rooted in this node, which also happens to be the number of scopes
1684 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1690 count
+= scopecount (node
-> child
);
1691 count
+= scopecount (node
-> sibling
);
1701 openscope -- start a new lexical block scope
1705 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1710 Start a new scope by allocating a new scopenode, adding it as the
1711 next child of the current scope (if any) or as the root of the
1712 scope tree, and then making the new node the current scope node.
1716 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1717 struct symbol
*namesym AND
1721 struct scopenode
*new;
1722 struct scopenode
*child
;
1724 new = (struct scopenode
*) xmalloc (sizeof (*new));
1725 (void) memset (new, 0, sizeof (*new));
1726 new -> namesym
= namesym
;
1727 new -> lowpc
= lowpc
;
1728 new -> highpc
= highpc
;
1733 else if ((child
= scope
-> child
) == NULL
)
1735 scope
-> child
= new;
1736 new -> parent
= scope
;
1740 while (child
-> sibling
!= NULL
)
1742 child
= child
-> sibling
;
1744 child
-> sibling
= new;
1745 new -> parent
= scope
;
1754 freescope -- free a scope tree rooted at the given node
1758 static void freescope (struct scopenode *node)
1762 Given a pointer to a node in the scope tree, free the subtree
1763 rooted at that node. First free all the children and sibling
1764 nodes, and then the node itself. Used primarily for cleaning
1765 up after ourselves and returning memory to the system.
1769 DEFUN(freescope
, (node
), struct scopenode
*node
)
1773 freescope (node
-> child
);
1774 freescope (node
-> sibling
);
1783 buildblock -- build a new block from pending symbols list
1787 static struct block *buildblock (struct pending_symbol *syms)
1791 Given a pointer to a list of symbols, build a new block and free
1792 the symbol list structure. Also check each symbol to see if it
1793 is the special symbol that flags that this block was compiled by
1794 gcc, and if so, mark the block appropriately.
1797 static struct block
*
1798 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1800 struct pending_symbol
*next
, *next1
;
1802 struct block
*newblock
;
1805 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1807 /* Allocate a new block */
1809 nbytes
= sizeof (struct block
);
1812 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1814 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1815 (void) memset (newblock
, 0, nbytes
);
1817 /* Copy the symbols into the block. */
1819 BLOCK_NSYMS (newblock
) = i
;
1820 for (next
= syms
; next
; next
= next
-> next
)
1822 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1823 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1824 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1826 BLOCK_GCC_COMPILED (newblock
) = 1;
1830 /* Now free the links of the list, and empty the list. */
1832 for (next
= syms
; next
; next
= next1
)
1834 next1
= next
-> next
;
1845 closescope -- close a lexical block scope
1849 static void closescope (void)
1853 Close the current lexical block scope. Closing the current scope
1854 is as simple as moving the current scope pointer up to the parent
1855 of the current scope pointer. But we also take this opportunity
1856 to build the block for the current scope first, since we now have
1857 all of it's symbols.
1861 DEFUN_VOID(closescope
)
1863 struct scopenode
*child
;
1867 error ("DWARF parse error, too many close scopes");
1871 if (scope
-> parent
== NULL
)
1873 global_symbol_block
= buildblock (global_symbols
);
1874 global_symbols
= NULL
;
1875 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1876 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1878 scope
-> block
= buildblock (scope
-> symbols
);
1879 scope
-> symbols
= NULL
;
1880 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1881 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1883 /* Put the local block in as the value of the symbol that names it. */
1885 if (scope
-> namesym
)
1887 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1888 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1891 /* Install this scope's local block as the superblock of all child
1894 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1896 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1899 scope
= scope
-> parent
;
1907 record_line -- record a line number entry in the line vector
1911 static void record_line (int line, CORE_ADDR pc)
1915 Given a line number and the corresponding pc value, record
1916 this pair in the line number vector, expanding the vector as
1921 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1923 struct linetable_entry
*e
;
1926 /* Make sure line vector is big enough. */
1928 if (line_vector_index
+ 2 >= line_vector_length
)
1930 line_vector_length
*= 2;
1931 nbytes
= sizeof (struct linetable
);
1932 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1933 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1935 e
= line_vector
-> item
+ line_vector_index
++;
1944 decode_line_numbers -- decode a line number table fragment
1948 static void decode_line_numbers (char *tblscan, char *tblend,
1949 long length, long base, long line, long pc)
1953 Translate the DWARF line number information to gdb form.
1955 The ".line" section contains one or more line number tables, one for
1956 each ".line" section from the objects that were linked.
1958 The AT_stmt_list attribute for each TAG_source_file entry in the
1959 ".debug" section contains the offset into the ".line" section for the
1960 start of the table for that file.
1962 The table itself has the following structure:
1964 <table length><base address><source statement entry>
1965 4 bytes 4 bytes 10 bytes
1967 The table length is the total size of the table, including the 4 bytes
1968 for the length information.
1970 The base address is the address of the first instruction generated
1971 for the source file.
1973 Each source statement entry has the following structure:
1975 <line number><statement position><address delta>
1976 4 bytes 2 bytes 4 bytes
1978 The line number is relative to the start of the file, starting with
1981 The statement position either -1 (0xFFFF) or the number of characters
1982 from the beginning of the line to the beginning of the statement.
1984 The address delta is the difference between the base address and
1985 the address of the first instruction for the statement.
1987 Note that we must copy the bytes from the packed table to our local
1988 variables before attempting to use them, to avoid alignment problems
1989 on some machines, particularly RISC processors.
1993 Does gdb expect the line numbers to be sorted? They are now by
1994 chance/luck, but are not required to be. (FIXME)
1996 The line with number 0 is unused, gdb apparently can discover the
1997 span of the last line some other way. How? (FIXME)
2001 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2010 if (linetable
!= NULL
)
2012 tblscan
= tblend
= linetable
;
2013 (void) memcpy (&length
, tblscan
, sizeof (long));
2014 tblscan
+= sizeof (long);
2016 (void) memcpy (&base
, tblscan
, sizeof (long));
2018 tblscan
+= sizeof (long);
2019 while (tblscan
< tblend
)
2021 (void) memcpy (&line
, tblscan
, sizeof (long));
2022 tblscan
+= sizeof (long) + sizeof (short);
2023 (void) memcpy (&pc
, tblscan
, sizeof (long));
2024 tblscan
+= sizeof (long);
2028 record_line (line
, pc
);
2038 add_symbol_to_list -- add a symbol to head of current symbol list
2042 static void add_symbol_to_list (struct symbol *symbol, struct
2043 pending_symbol **listhead)
2047 Given a pointer to a symbol and a pointer to a pointer to a
2048 list of symbols, add this symbol as the current head of the
2049 list. Typically used for example to add a symbol to the
2050 symbol list for the current scope.
2055 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2056 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2058 struct pending_symbol
*link
;
2062 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2063 link
-> next
= *listhead
;
2064 link
-> symbol
= symbol
;
2073 gatherblocks -- walk a scope tree and build block vectors
2077 static struct block **gatherblocks (struct block **dest,
2078 struct scopenode *node)
2082 Recursively walk a scope tree rooted in the given node, adding blocks
2083 to the array pointed to by DEST, in preorder. I.E., first we add the
2084 block for the current scope, then all the blocks for child scopes,
2085 and finally all the blocks for sibling scopes.
2088 static struct block
**
2089 DEFUN(gatherblocks
, (dest
, node
),
2090 struct block
**dest AND
struct scopenode
*node
)
2094 *dest
++ = node
-> block
;
2095 dest
= gatherblocks (dest
, node
-> child
);
2096 dest
= gatherblocks (dest
, node
-> sibling
);
2105 make_blockvector -- make a block vector from current scope tree
2109 static struct blockvector *make_blockvector (void)
2113 Make a blockvector from all the blocks in the current scope tree.
2114 The first block is always the global symbol block, followed by the
2115 block for the root of the scope tree which is the local symbol block,
2116 followed by all the remaining blocks in the scope tree, which are all
2121 Note that since the root node of the scope tree is created at the time
2122 each file scope is entered, there are always at least two blocks,
2123 neither of which may have any symbols, but always contribute a block
2124 to the block vector. So the test for number of blocks greater than 1
2125 below is unnecessary given bug free code.
2127 The resulting block structure varies slightly from that produced
2128 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2129 with dbxread.c, block 1 is a child of block 0. This does not
2130 seem to cause any problems, but probably should be fixed. (FIXME)
2133 static struct blockvector
*
2134 DEFUN_VOID(make_blockvector
)
2136 struct blockvector
*blockvector
= NULL
;
2140 /* Recursively walk down the tree, counting the number of blocks.
2141 Then add one to account for the global's symbol block */
2143 i
= scopecount (scopetree
) + 1;
2144 nbytes
= sizeof (struct blockvector
);
2147 nbytes
+= (i
- 1) * sizeof (struct block
*);
2149 blockvector
= (struct blockvector
*)
2150 obstack_alloc (symbol_obstack
, nbytes
);
2152 /* Copy the blocks into the blockvector. */
2154 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2155 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2156 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2158 return (blockvector
);
2165 locval -- compute the value of a location attribute
2169 static int locval (char *loc)
2173 Given pointer to a string of bytes that define a location, compute
2174 the location and return the value.
2176 When computing values involving the current value of the frame pointer,
2177 the value zero is used, which results in a value relative to the frame
2178 pointer, rather than the absolute value. This is what GDB wants
2181 When the result is a register number, the global isreg flag is set,
2182 otherwise it is cleared. This is a kludge until we figure out a better
2183 way to handle the problem. Gdb's design does not mesh well with the
2184 DWARF notion of a location computing interpreter, which is a shame
2185 because the flexibility goes unused.
2189 Note that stack[0] is unused except as a default error return.
2190 Note that stack overflow is not yet handled.
2194 DEFUN(locval
, (loc
), char *loc
)
2196 unsigned short nbytes
;
2202 (void) memcpy (&nbytes
, loc
, sizeof (short));
2203 end
= loc
+ sizeof (short) + nbytes
;
2207 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2215 /* push register (number) */
2216 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2220 /* push value of register (number) */
2221 /* Actually, we compute the value as if register has 0 */
2222 (void) memcpy (®no
, loc
, sizeof (long));
2225 stack
[++stacki
] = 0;
2229 stack
[++stacki
] = 0;
2230 SQUAWK (("BASEREG %d not handled!", regno
));
2234 /* push address (relocated address) */
2235 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2238 /* push constant (number) */
2239 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2242 /* pop, deref and push 2 bytes (as a long) */
2243 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2245 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2246 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2248 case OP_ADD
: /* pop top 2 items, add, push result */
2249 stack
[stacki
- 1] += stack
[stacki
];
2254 return (stack
[stacki
]);
2261 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2265 static struct symtab *read_ofile_symtab (struct partial_symtab *pst,
2270 DESC is the file descriptor for the file, positioned at the
2271 beginning of the symtab
2272 SYM_SIZE is the size of the symbol section to read
2273 TEXT_OFFSET is the beginning of the text segment we are reading
2275 TEXT_SIZE is the size of the text segment read in.
2276 OFFSET is a relocation offset which gets added to each symbol
2280 static struct symtab
*
2281 DEFUN(read_ofile_symtab
, (pst
, desc
),
2282 struct partial_symtab
*pst AND
2285 struct cleanup
*back_to
;
2289 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2290 unit, seek to the location in the file, and read in all the DIE's. */
2293 dbbase
= xmalloc (DBLENGTH(pst
));
2294 dbroff
= DBROFF(pst
);
2295 foffset
= DBFOFF(pst
) + dbroff
;
2296 if ((lseek (desc
, foffset
, 0) != foffset
) ||
2297 (read (desc
, dbbase
, DBLENGTH(pst
)) != DBLENGTH(pst
)))
2300 error ("can't read DWARF data");
2302 back_to
= make_cleanup (free
, dbbase
);
2304 /* If there is a line number table associated with this compilation unit
2305 then read the first long word from the line number table fragment, which
2306 contains the size of the fragment in bytes (including the long word
2307 itself). Allocate a buffer for the fragment and read it in for future
2313 if ((lseek (desc
, LNFOFF (pst
), 0) != LNFOFF (pst
)) ||
2314 (read (desc
, &lnsize
, sizeof(long)) != sizeof(long)))
2316 error ("can't read DWARF line number table size");
2318 lnbase
= xmalloc (lnsize
);
2319 if ((lseek (desc
, LNFOFF (pst
), 0) != LNFOFF (pst
)) ||
2320 (read (desc
, lnbase
, lnsize
) != lnsize
))
2323 error ("can't read DWARF line numbers");
2325 make_cleanup (free
, lnbase
);
2328 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
));
2329 do_cleanups (back_to
);
2330 return (symtab_list
);
2337 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2341 static void psymtab_to_symtab_1 (struct partial_symtab *pst, int desc)
2345 Called once for each partial symbol table entry that needs to be
2346 expanded into a full symbol table entry.
2351 DEFUN(psymtab_to_symtab_1
,
2353 struct partial_symtab
*pst AND
2364 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2369 /* Read in all partial symtabs on which this one is dependent */
2370 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2371 if (!pst
-> dependencies
[i
] -> readin
)
2373 /* Inform about additional files that need to be read in. */
2376 fputs_filtered (" ", stdout
);
2378 fputs_filtered ("and ", stdout
);
2380 printf_filtered ("%s...", pst
-> dependencies
[i
] -> filename
);
2381 wrap_here (""); /* Flush output */
2384 psymtab_to_symtab_1 (pst
-> dependencies
[i
], desc
);
2387 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2389 /* Init stuff necessary for reading in symbols */
2390 pst
-> symtab
= read_ofile_symtab (pst
, desc
);
2393 printf_filtered ("%d DIE's, sorting...", diecount
);
2396 sort_symtab_syms (pst
-> symtab
);
2405 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2409 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2413 This is the DWARF support entry point for building a full symbol
2414 table entry from a partial symbol table entry. We are passed a
2415 pointer to the partial symbol table entry that needs to be expanded.
2420 DEFUN(dwarf_psymtab_to_symtab
, (pst
), struct partial_symtab
*pst
)
2423 struct cleanup
*old_chain
;
2432 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2437 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2439 /* Print the message now, before starting serious work, to avoid
2440 disconcerting pauses. */
2443 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2447 /* Open symbol file. Symbol_file_command guarantees that the symbol
2448 file name will be absolute, so there is no need for openp. */
2449 desc
= open (pst
-> symfile_name
, O_RDONLY
, 0);
2453 perror_with_name (pst
-> symfile_name
);
2456 sym_bfd
= bfd_fdopenr (pst
-> symfile_name
, NULL
, desc
);
2459 (void) close (desc
);
2460 error ("Could not open `%s' to read symbols: %s",
2461 pst
-> symfile_name
, bfd_errmsg (bfd_error
));
2463 old_chain
= make_cleanup (bfd_close
, sym_bfd
);
2464 if (!bfd_check_format (sym_bfd
, bfd_object
))
2466 error ("\"%s\": can't read symbols: %s.",
2467 pst
-> symfile_name
, bfd_errmsg (bfd_error
));
2470 psymtab_to_symtab_1 (pst
, desc
);
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 do_cleanups (old_chain
);
2482 /* Finish up the debug error message. */
2485 printf_filtered ("done.\n");
2494 init_psymbol_list -- initialize storage for partial symbols
2498 static void init_psymbol_list (int total_symbols)
2502 Initializes storage for all of the partial symbols that will be
2503 created by dwarf_build_psymtabs and subsidiaries.
2507 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2509 /* Free any previously allocated psymbol lists. */
2511 if (global_psymbols
.list
)
2513 free (global_psymbols
.list
);
2515 if (static_psymbols
.list
)
2517 free (static_psymbols
.list
);
2520 /* Current best guess is that there are approximately a twentieth
2521 of the total symbols (in a debugging file) are global or static
2524 global_psymbols
.size
= total_symbols
/ 10;
2525 static_psymbols
.size
= total_symbols
/ 10;
2526 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2527 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2528 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2529 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2536 start_psymtab -- allocate and partially fill a partial symtab entry
2540 Allocate and partially fill a partial symtab. It will be completely
2541 filled at the end of the symbol list.
2543 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2544 ADDR is the address relative to which its symbols are (incremental)
2545 or 0 (normal). FILENAME is the name of the compilation unit that
2546 these symbols were defined in, and they appear starting a address
2547 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2548 the full symbols can be read for compilation unit FILENAME.
2549 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2554 static struct partial_symtab
*
2555 DEFUN(start_psymtab
,
2556 (symfile_name
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2557 culength
, lnfoff
, global_syms
, static_syms
),
2558 char *symfile_name AND
2561 CORE_ADDR textlow AND
2562 CORE_ADDR texthigh AND
2567 struct partial_symbol
*global_syms AND
2568 struct partial_symbol
*static_syms
)
2570 struct partial_symtab
*result
;
2572 result
= (struct partial_symtab
*)
2573 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2574 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2575 result
-> addr
= addr
;
2576 result
-> symfile_name
= create_name (symfile_name
, psymbol_obstack
);
2577 result
-> filename
= create_name (filename
, psymbol_obstack
);
2578 result
-> textlow
= textlow
;
2579 result
-> texthigh
= texthigh
;
2580 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2581 sizeof (struct dwfinfo
));
2582 DBFOFF (result
) = dbfoff
;
2583 DBROFF (result
) = curoff
;
2584 DBLENGTH (result
) = culength
;
2585 LNFOFF (result
) = lnfoff
;
2586 result
-> readin
= 0;
2587 result
-> symtab
= NULL
;
2588 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2589 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2590 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2592 result
->n_global_syms
= 0;
2593 result
->n_static_syms
= 0;
2602 add_psymbol_to_list -- add a partial symbol to given list
2606 Add a partial symbol to one of the partial symbol vectors (pointed to
2607 by listp). The vector is grown as necessary.
2612 DEFUN(add_psymbol_to_list
,
2613 (listp
, name
, space
, class, value
),
2614 struct psymbol_allocation_list
*listp AND
2616 enum namespace space AND
2617 enum address_class
class AND
2620 struct partial_symbol
*psym
;
2623 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2625 newsize
= listp
-> size
* 2;
2626 listp
-> list
= (struct partial_symbol
*)
2627 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2628 /* Next assumes we only went one over. Should be good if program works
2630 listp
-> next
= listp
-> list
+ listp
-> size
;
2631 listp
-> size
= newsize
;
2633 psym
= listp
-> next
++;
2634 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2635 SYMBOL_NAMESPACE (psym
) = space
;
2636 SYMBOL_CLASS (psym
) = class;
2637 SYMBOL_VALUE (psym
) = value
;
2644 add_partial_symbol -- add symbol to partial symbol table
2648 Given a DIE, if it is one of the types that we want to
2649 add to a partial symbol table, finish filling in the die info
2650 and then add a partial symbol table entry for it.
2655 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2657 switch (dip
-> dietag
)
2659 case TAG_global_subroutine
:
2660 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
);
2661 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2662 LOC_BLOCK
, dip
-> at_low_pc
);
2664 case TAG_global_variable
:
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.
2709 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2714 while (thisdie
< enddie
)
2716 basicdieinfo (&di
, thisdie
);
2717 if (di
.dielength
< sizeof (long))
2723 nextdie
= thisdie
+ di
.dielength
;
2726 case TAG_global_subroutine
:
2727 case TAG_global_variable
:
2728 case TAG_subroutine
:
2729 case TAG_local_variable
:
2731 case TAG_structure_type
:
2732 case TAG_union_type
:
2733 case TAG_enumeration_type
:
2734 completedieinfo (&di
);
2735 /* Don't attempt to add anonymous structures, unions, or
2736 enumerations since they have no name. Also check that
2737 this is the place where the actual definition occurs,
2738 rather than just a reference to an external. */
2739 if (di
.at_name
!= NULL
&& !di
.at_is_external_p
)
2741 add_partial_symbol (&di
);
2754 scan_compilation_units -- build a psymtab entry for each compilation
2758 This is the top level dwarf parsing routine for building partial
2761 It scans from the beginning of the DWARF table looking for the first
2762 TAG_compile_unit DIE, and then follows the sibling chain to locate
2763 each additional TAG_compile_unit DIE.
2765 For each TAG_compile_unit DIE it creates a partial symtab structure,
2766 calls a subordinate routine to collect all the compilation unit's
2767 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2768 new partial symtab structure into the partial symbol table. It also
2769 records the appropriate information in the partial symbol table entry
2770 to allow the chunk of DIE's and line number table for this compilation
2771 unit to be located and re-read later, to generate a complete symbol
2772 table entry for the compilation unit.
2774 Thus it effectively partitions up a chunk of DIE's for multiple
2775 compilation units into smaller DIE chunks and line number tables,
2776 and associates them with a partial symbol table entry.
2780 If any compilation unit has no line number table associated with
2781 it for some reason (a missing at_stmt_list attribute, rather than
2782 just one with a value of zero, which is valid) then we ensure that
2783 the recorded file offset is zero so that the routine which later
2784 reads line number table fragments knows that there is no fragment
2794 DEFUN(scan_compilation_units
,
2795 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
),
2800 unsigned int dbfoff AND
2801 unsigned int lnoffset
)
2805 struct partial_symtab
*pst
;
2810 while (thisdie
< enddie
)
2812 basicdieinfo (&di
, thisdie
);
2813 if (di
.dielength
< sizeof (long))
2817 else if (di
.dietag
!= TAG_compile_unit
)
2819 nextdie
= thisdie
+ di
.dielength
;
2823 completedieinfo (&di
);
2824 if (di
.at_sibling
!= 0)
2826 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2830 nextdie
= thisdie
+ di
.dielength
;
2832 curoff
= thisdie
- dbbase
;
2833 culength
= nextdie
- thisdie
;
2834 curlnoffset
= di
.at_stmt_list_p
? lnoffset
+ di
.at_stmt_list
: 0;
2835 pst
= start_psymtab (filename
, addr
, di
.at_name
,
2836 di
.at_low_pc
, di
.at_high_pc
,
2837 dbfoff
, curoff
, culength
, curlnoffset
,
2838 global_psymbols
.next
,
2839 static_psymbols
.next
);
2840 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2841 pst
-> n_global_syms
= global_psymbols
.next
-
2842 (global_psymbols
.list
+ pst
-> globals_offset
);
2843 pst
-> n_static_syms
= static_psymbols
.next
-
2844 (static_psymbols
.list
+ pst
-> statics_offset
);
2845 /* Sort the global list; don't sort the static list */
2846 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2847 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2849 /* If there is already a psymtab or symtab for a file of this name,
2850 remove it. (If there is a symtab, more drastic things also
2851 happen.) This happens in VxWorks. */
2852 free_named_symtabs (pst
-> filename
);
2853 /* Place the partial symtab on the partial symtab list */
2854 pst
-> next
= partial_symtab_list
;
2855 partial_symtab_list
= pst
;
2865 new_symbol -- make a symbol table entry for a new symbol
2869 static struct symbol *new_symbol (struct dieinfo *dip)
2873 Given a pointer to a DWARF information entry, figure out if we need
2874 to make a symbol table entry for it, and if so, create a new entry
2875 and return a pointer to it.
2878 static struct symbol
*
2879 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2881 struct symbol
*sym
= NULL
;
2883 if (dip
-> at_name
!= NULL
)
2885 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2886 sizeof (struct symbol
));
2887 (void) memset (sym
, 0, sizeof (struct symbol
));
2888 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2889 /* default assumptions */
2890 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2891 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2892 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2893 switch (dip
-> dietag
)
2896 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2897 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2899 case TAG_global_subroutine
:
2900 case TAG_subroutine
:
2901 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2902 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2903 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2904 if (dip
-> dietag
== TAG_global_subroutine
)
2906 add_symbol_to_list (sym
, &global_symbols
);
2910 add_symbol_to_list (sym
, &scope
-> symbols
);
2913 case TAG_global_variable
:
2914 case TAG_local_variable
:
2915 if (dip
-> at_location
!= NULL
)
2917 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2919 if (dip
-> dietag
== TAG_global_variable
)
2921 add_symbol_to_list (sym
, &global_symbols
);
2922 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2923 SYMBOL_VALUE (sym
) += baseaddr
;
2927 add_symbol_to_list (sym
, &scope
-> symbols
);
2928 if (scope
-> parent
!= NULL
)
2932 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2936 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2941 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2942 SYMBOL_VALUE (sym
) += baseaddr
;
2946 case TAG_formal_parameter
:
2947 if (dip
-> at_location
!= NULL
)
2949 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2951 add_symbol_to_list (sym
, &scope
-> symbols
);
2954 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2958 SYMBOL_CLASS (sym
) = LOC_ARG
;
2961 case TAG_unspecified_parameters
:
2962 /* From varargs functions; gdb doesn't seem to have any interest in
2963 this information, so just ignore it for now. (FIXME?) */
2965 case TAG_structure_type
:
2966 case TAG_union_type
:
2967 case TAG_enumeration_type
:
2968 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2969 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2970 add_symbol_to_list (sym
, &scope
-> symbols
);
2973 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2974 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2975 add_symbol_to_list (sym
, &scope
-> symbols
);
2978 /* Not a tag we recognize. Hopefully we aren't processing trash
2979 data, but since we must specifically ignore things we don't
2980 recognize, there is nothing else we should do at this point. */
2991 decode_mod_fund_type -- decode a modified fundamental type
2995 static struct type *decode_mod_fund_type (char *typedata)
2999 Decode a block of data containing a modified fundamental
3000 type specification. TYPEDATA is a pointer to the block,
3001 which consists of a two byte length, containing the size
3002 of the rest of the block. At the end of the block is a
3003 two byte value that gives the fundamental type. Everything
3004 in between are type modifiers.
3006 We simply compute the number of modifiers and call the general
3007 function decode_modified_type to do the actual work.
3010 static struct type
*
3011 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
3013 struct type
*typep
= NULL
;
3014 unsigned short modcount
;
3015 unsigned char *modifiers
;
3017 /* Get the total size of the block, exclusive of the size itself */
3018 (void) memcpy (&modcount
, typedata
, sizeof (short));
3019 /* Deduct the size of the fundamental type bytes at the end of the block. */
3020 modcount
-= sizeof (short);
3021 /* Skip over the two size bytes at the beginning of the block. */
3022 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3023 /* Now do the actual decoding */
3024 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3032 decode_mod_u_d_type -- decode a modified user defined type
3036 static struct type *decode_mod_u_d_type (char *typedata)
3040 Decode a block of data containing a modified user defined
3041 type specification. TYPEDATA is a pointer to the block,
3042 which consists of a two byte length, containing the size
3043 of the rest of the block. At the end of the block is a
3044 four byte value that gives a reference to a user defined type.
3045 Everything in between are type modifiers.
3047 We simply compute the number of modifiers and call the general
3048 function decode_modified_type to do the actual work.
3051 static struct type
*
3052 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3054 struct type
*typep
= NULL
;
3055 unsigned short modcount
;
3056 unsigned char *modifiers
;
3058 /* Get the total size of the block, exclusive of the size itself */
3059 (void) memcpy (&modcount
, typedata
, sizeof (short));
3060 /* Deduct the size of the reference type bytes at the end of the block. */
3061 modcount
-= sizeof (long);
3062 /* Skip over the two size bytes at the beginning of the block. */
3063 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3064 /* Now do the actual decoding */
3065 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3073 decode_modified_type -- decode modified user or fundamental type
3077 static struct type *decode_modified_type (unsigned char *modifiers,
3078 unsigned short modcount, int mtype)
3082 Decode a modified type, either a modified fundamental type or
3083 a modified user defined type. MODIFIERS is a pointer to the
3084 block of bytes that define MODCOUNT modifiers. Immediately
3085 following the last modifier is a short containing the fundamental
3086 type or a long containing the reference to the user defined
3087 type. Which one is determined by MTYPE, which is either
3088 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3089 type we are generating.
3091 We call ourself recursively to generate each modified type,`
3092 until MODCOUNT reaches zero, at which point we have consumed
3093 all the modifiers and generate either the fundamental type or
3094 user defined type. When the recursion unwinds, each modifier
3095 is applied in turn to generate the full modified type.
3099 If we find a modifier that we don't recognize, and it is not one
3100 of those reserved for application specific use, then we issue a
3101 warning and simply ignore the modifier.
3105 We currently ignore MOD_const and MOD_volatile. (FIXME)
3109 static struct type
*
3110 DEFUN(decode_modified_type
,
3111 (modifiers
, modcount
, mtype
),
3112 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3114 struct type
*typep
= NULL
;
3115 unsigned short fundtype
;
3117 unsigned char modifier
;
3123 case AT_mod_fund_type
:
3124 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3125 typep
= decode_fund_type (fundtype
);
3127 case AT_mod_u_d_type
:
3128 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3129 if ((typep
= lookup_utype (dieref
)) == NULL
)
3131 typep
= alloc_utype (dieref
, NULL
);
3135 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3136 typep
= builtin_type_int
;
3142 modifier
= *modifiers
++;
3143 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3146 case MOD_pointer_to
:
3147 typep
= lookup_pointer_type (typep
);
3149 case MOD_reference_to
:
3150 typep
= lookup_reference_type (typep
);
3153 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3156 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3159 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3161 SQUAWK (("unknown type modifier %u", modifier
));
3173 decode_fund_type -- translate basic DWARF type to gdb base type
3177 Given an integer that is one of the fundamental DWARF types,
3178 translate it to one of the basic internal gdb types and return
3179 a pointer to the appropriate gdb type (a "struct type *").
3183 If we encounter a fundamental type that we are unprepared to
3184 deal with, and it is not in the range of those types defined
3185 as application specific types, then we issue a warning and
3186 treat the type as builtin_type_int.
3189 static struct type
*
3190 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3192 struct type
*typep
= NULL
;
3198 typep
= builtin_type_void
;
3201 case FT_pointer
: /* (void *) */
3202 typep
= lookup_pointer_type (builtin_type_void
);
3206 case FT_signed_char
:
3207 typep
= builtin_type_char
;
3211 case FT_signed_short
:
3212 typep
= builtin_type_short
;
3216 case FT_signed_integer
:
3217 case FT_boolean
: /* Was FT_set in AT&T version */
3218 typep
= builtin_type_int
;
3222 case FT_signed_long
:
3223 typep
= builtin_type_long
;
3227 typep
= builtin_type_float
;
3230 case FT_dbl_prec_float
:
3231 typep
= builtin_type_double
;
3234 case FT_unsigned_char
:
3235 typep
= builtin_type_unsigned_char
;
3238 case FT_unsigned_short
:
3239 typep
= builtin_type_unsigned_short
;
3242 case FT_unsigned_integer
:
3243 typep
= builtin_type_unsigned_int
;
3246 case FT_unsigned_long
:
3247 typep
= builtin_type_unsigned_long
;
3250 case FT_ext_prec_float
:
3251 typep
= builtin_type_long_double
;
3255 typep
= builtin_type_complex
;
3258 case FT_dbl_prec_complex
:
3259 typep
= builtin_type_double_complex
;
3263 case FT_signed_long_long
:
3264 typep
= builtin_type_long_long
;
3267 case FT_unsigned_long_long
:
3268 typep
= builtin_type_unsigned_long_long
;
3273 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3275 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3276 typep
= builtin_type_void
;
3286 create_name -- allocate a fresh copy of a string on an obstack
3290 Given a pointer to a string and a pointer to an obstack, allocates
3291 a fresh copy of the string on the specified obstack.
3296 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3301 length
= strlen (name
) + 1;
3302 newname
= (char *) obstack_alloc (obstackp
, length
);
3303 (void) strcpy (newname
, name
);
3311 basicdieinfo -- extract the minimal die info from raw die data
3315 void basicdieinfo (char *diep, struct dieinfo *dip)
3319 Given a pointer to raw DIE data, and a pointer to an instance of a
3320 die info structure, this function extracts the basic information
3321 from the DIE data required to continue processing this DIE, along
3322 with some bookkeeping information about the DIE.
3324 The information we absolutely must have includes the DIE tag,
3325 and the DIE length. If we need the sibling reference, then we
3326 will have to call completedieinfo() to process all the remaining
3329 Note that since there is no guarantee that the data is properly
3330 aligned in memory for the type of access required (indirection
3331 through anything other than a char pointer), we use memcpy to
3332 shuffle data items larger than a char. Possibly inefficient, but
3335 We also take care of some other basic things at this point, such
3336 as ensuring that the instance of the die info structure starts
3337 out completely zero'd and that curdie is initialized for use
3338 in error reporting if we have a problem with the current die.
3342 All DIE's must have at least a valid length, thus the minimum
3343 DIE size is sizeof (long). In order to have a valid tag, the
3344 DIE size must be at least sizeof (short) larger, otherwise they
3345 are forced to be TAG_padding DIES.
3347 Padding DIES must be at least sizeof(long) in length, implying that
3348 if a padding DIE is used for alignment and the amount needed is less
3349 than sizeof(long) then the padding DIE has to be big enough to align
3350 to the next alignment boundry.
3354 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3357 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3359 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3360 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3361 if (dip
-> dielength
< sizeof (long))
3363 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3365 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3367 dip
-> dietag
= TAG_padding
;
3371 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3379 completedieinfo -- finish reading the information for a given DIE
3383 void completedieinfo (struct dieinfo *dip)
3387 Given a pointer to an already partially initialized die info structure,
3388 scan the raw DIE data and finish filling in the die info structure
3389 from the various attributes found.
3391 Note that since there is no guarantee that the data is properly
3392 aligned in memory for the type of access required (indirection
3393 through anything other than a char pointer), we use memcpy to
3394 shuffle data items larger than a char. Possibly inefficient, but
3399 Each time we are called, we increment the diecount variable, which
3400 keeps an approximate count of the number of dies processed for
3401 each compilation unit. This information is presented to the user
3402 if the info_verbose flag is set.
3407 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3409 char *diep
; /* Current pointer into raw DIE data */
3410 char *end
; /* Terminate DIE scan here */
3411 unsigned short attr
; /* Current attribute being scanned */
3412 unsigned short form
; /* Form of the attribute */
3413 short block2sz
; /* Size of a block2 attribute field */
3414 long block4sz
; /* Size of a block4 attribute field */
3418 end
= diep
+ dip
-> dielength
;
3419 diep
+= sizeof (long) + sizeof (short);
3422 (void) memcpy (&attr
, diep
, sizeof (short));
3423 diep
+= sizeof (short);
3427 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3430 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3433 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3436 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3439 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3442 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3443 dip
-> at_stmt_list_p
= 1;
3446 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3449 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3452 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3454 case AT_user_def_type
:
3455 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3458 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3461 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3464 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3467 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3470 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3473 dip
-> at_location
= diep
;
3475 case AT_mod_fund_type
:
3476 dip
-> at_mod_fund_type
= diep
;
3478 case AT_subscr_data
:
3479 dip
-> at_subscr_data
= diep
;
3481 case AT_mod_u_d_type
:
3482 dip
-> at_mod_u_d_type
= diep
;
3485 dip
-> at_deriv_list
= diep
;
3487 case AT_element_list
:
3488 dip
-> at_element_list
= diep
;
3490 case AT_discr_value
:
3491 dip
-> at_discr_value
= diep
;
3493 case AT_string_length
:
3494 dip
-> at_string_length
= diep
;
3497 dip
-> at_name
= diep
;
3500 dip
-> at_comp_dir
= diep
;
3503 dip
-> at_producer
= diep
;
3506 (void) memcpy (&dip
-> at_loclist
, diep
, sizeof (long));
3509 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3512 (void) memcpy (&dip
-> at_incomplete
, diep
, sizeof (short));
3514 case AT_start_scope
:
3515 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3517 case AT_stride_size
:
3518 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3521 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3524 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3527 dip
-> at_const_data
= diep
;
3529 case AT_is_external
:
3530 (void) memcpy (&dip
-> at_is_external
, diep
, sizeof (short));
3531 dip
-> at_is_external_p
= 1;
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
));