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 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
100 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
101 extern CORE_ADDR entry_scope_lowpc
; /* From blockframe.c */
102 extern CORE_ADDR entry_scope_highpc
; /* From blockframc.c */
103 extern CORE_ADDR main_scope_lowpc
; /* From blockframe.c */
104 extern CORE_ADDR main_scope_highpc
; /* From blockframc.c */
105 extern int info_verbose
; /* From main.c; nonzero => verbose */
108 /* The DWARF debugging information consists of two major pieces,
109 one is a block of DWARF Information Entries (DIE's) and the other
110 is a line number table. The "struct dieinfo" structure contains
111 the information for a single DIE, the one currently being processed.
113 In order to make it easier to randomly access the attribute fields
114 of the current DIE, which are specifically unordered within the DIE
115 each DIE is scanned and an instance of the "struct dieinfo"
116 structure is initialized.
118 Initialization is done in two levels. The first, done by basicdieinfo(),
119 just initializes those fields that are vital to deciding whether or not
120 to use this DIE, how to skip past it, etc. The second, done by the
121 function completedieinfo(), fills in the rest of the information.
123 Attributes which have block forms are not interpreted at the time
124 the DIE is scanned, instead we just save pointers to the start
125 of their value fields.
127 Some fields have a flag <name>_p that is set when the value of the
128 field is valid (I.E. we found a matching attribute in the DIE). Since
129 we may want to test for the presence of some attributes in the DIE,
130 such as AT_is_external, without restricting the values of the field,
131 we need someway to note that we found such an attribute.
138 char * die
; /* Pointer to the raw DIE data */
139 long dielength
; /* Length of the raw DIE data */
140 DIEREF dieref
; /* Offset of this DIE */
141 short dietag
; /* Tag for this DIE */
146 unsigned short at_fund_type
;
147 BLOCK
* at_mod_fund_type
;
148 long at_user_def_type
;
149 BLOCK
* at_mod_u_d_type
;
151 BLOCK
* at_subscr_data
;
155 BLOCK
* at_deriv_list
;
156 BLOCK
* at_element_list
;
163 BLOCK
* at_discr_value
;
166 BLOCK
* at_string_length
;
176 BLOCK
* at_const_data
;
177 short at_is_external
;
178 unsigned int at_is_external_p
:1;
179 unsigned int at_stmt_list_p
:1;
182 static int diecount
; /* Approximate count of dies for compilation unit */
183 static struct dieinfo
*curdie
; /* For warnings and such */
185 static char *dbbase
; /* Base pointer to dwarf info */
186 static int dbroff
; /* Relative offset from start of .debug section */
187 static char *lnbase
; /* Base pointer to line section */
188 static int isreg
; /* Kludge to identify register variables */
190 static CORE_ADDR baseaddr
; /* Add to each symbol value */
192 /* Each partial symbol table entry contains a pointer to private data for the
193 read_symtab() function to use when expanding a partial symbol table entry
194 to a full symbol table entry. For DWARF debugging info, this data is
195 contained in the following structure and macros are provided for easy
196 access to the members given a pointer to a partial symbol table entry.
198 dbfoff Always the absolute file offset to the start of the ".debug"
199 section for the file containing the DIE's being accessed.
201 dbroff Relative offset from the start of the ".debug" access to the
202 first DIE to be accessed. When building the partial symbol
203 table, this value will be zero since we are accessing the
204 entire ".debug" section. When expanding a partial symbol
205 table entry, this value will be the offset to the first
206 DIE for the compilation unit containing the symbol that
207 triggers the expansion.
209 dblength The size of the chunk of DIE's being examined, in bytes.
211 lnfoff The absolute file offset to the line table fragment. Ignored
212 when building partial symbol tables, but used when expanding
213 them, and contains the absolute file offset to the fragment
214 of the ".line" section containing the line numbers for the
215 current compilation unit.
219 int dbfoff
; /* Absolute file offset to start of .debug section */
220 int dbroff
; /* Relative offset from start of .debug section */
221 int dblength
; /* Size of the chunk of DIE's being examined */
222 int lnfoff
; /* Absolute file offset to line table fragment */
225 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
226 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
227 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
228 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
230 /* Record the symbols defined for each context in a linked list. We don't
231 create a struct block for the context until we know how long to make it.
232 Global symbols for each file are maintained in the global_symbols list. */
234 struct pending_symbol
{
235 struct pending_symbol
*next
; /* Next pending symbol */
236 struct symbol
*symbol
; /* The actual symbol */
239 static struct pending_symbol
*global_symbols
; /* global funcs and vars */
240 static struct block
*global_symbol_block
;
242 /* Line number entries are read into a dynamically expandable vector before
243 being added to the symbol table section. Once we know how many there are
246 static struct linetable
*line_vector
; /* Vector of line numbers. */
247 static int line_vector_index
; /* Index of next entry. */
248 static int line_vector_length
; /* Current allocation limit */
250 /* Scope information is kept in a scope tree, one node per scope. Each time
251 a new scope is started, a child node is created under the current node
252 and set to the current scope. Each time a scope is closed, the current
253 scope moves back up the tree to the parent of the current scope.
255 Each scope contains a pointer to the list of symbols defined in the scope,
256 a pointer to the block vector for the scope, a pointer to the symbol
257 that names the scope (if any), and the range of PC values that mark
258 the start and end of the scope. */
261 struct scopenode
*parent
;
262 struct scopenode
*child
;
263 struct scopenode
*sibling
;
264 struct pending_symbol
*symbols
;
266 struct symbol
*namesym
;
271 static struct scopenode
*scopetree
;
272 static struct scopenode
*scope
;
274 /* DIES which have user defined types or modified user defined types refer to
275 other DIES for the type information. Thus we need to associate the offset
276 of a DIE for a user defined type with a pointer to the type information.
278 Originally this was done using a simple but expensive algorithm, with an
279 array of unsorted structures, each containing an offset/type-pointer pair.
280 This array was scanned linearly each time a lookup was done. The result
281 was that gdb was spending over half it's startup time munging through this
282 array of pointers looking for a structure that had the right offset member.
284 The second attempt used the same array of structures, but the array was
285 sorted using qsort each time a new offset/type was recorded, and a binary
286 search was used to find the type pointer for a given DIE offset. This was
287 even slower, due to the overhead of sorting the array each time a new
288 offset/type pair was entered.
290 The third attempt uses a fixed size array of type pointers, indexed by a
291 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
292 we can divide any DIE offset by 4 to obtain a unique index into this fixed
293 size array. Since each element is a 4 byte pointer, it takes exactly as
294 much memory to hold this array as to hold the DWARF info for a given
295 compilation unit. But it gets freed as soon as we are done with it. */
297 static struct type
**utypes
; /* Pointer to array of user type pointers */
298 static int numutypes
; /* Max number of user type pointers */
300 /* Forward declarations of static functions so we don't have to worry
301 about ordering within this file. The EXFUN macro may be slightly
302 misleading. Should probably be called DCLFUN instead, or something
303 more intuitive, since it can be used for both static and external
307 EXFUN (dwarfwarn
, (char *fmt DOTS
));
310 EXFUN (scan_partial_symbols
, (char *thisdie AND
char *enddie
));
313 EXFUN (scan_compilation_units
,
314 (char *filename AND CORE_ADDR addr AND
char *thisdie AND
char *enddie
315 AND
unsigned int dbfoff AND
unsigned int lnoffset
316 AND
struct objfile
*objfile
));
318 static struct partial_symtab
*
319 EXFUN(start_psymtab
, (struct objfile
*objfile AND CORE_ADDR addr
320 AND
char *filename AND CORE_ADDR textlow
321 AND CORE_ADDR texthigh AND
int dbfoff
322 AND
int curoff AND
int culength AND
int lnfoff
323 AND
struct partial_symbol
*global_syms
324 AND
struct partial_symbol
*static_syms
));
326 EXFUN(add_partial_symbol
, (struct dieinfo
*dip
));
329 EXFUN(add_psymbol_to_list
,
330 (struct psymbol_allocation_list
*listp AND
char *name
331 AND
enum namespace space AND
enum address_class
class
332 AND CORE_ADDR value
));
335 EXFUN(init_psymbol_list
, (int total_symbols
));
338 EXFUN(basicdieinfo
, (struct dieinfo
*dip AND
char *diep
));
341 EXFUN(completedieinfo
, (struct dieinfo
*dip
));
344 EXFUN(dwarf_psymtab_to_symtab
, (struct partial_symtab
*pst
));
347 EXFUN(psymtab_to_symtab_1
, (struct partial_symtab
*pst
));
349 static struct symtab
*
350 EXFUN(read_ofile_symtab
, (struct partial_symtab
*pst
));
354 (char *thisdie AND
char *enddie AND
struct objfile
*objfile
));
357 EXFUN(read_structure_scope
,
358 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
361 EXFUN(decode_array_element_type
, (char *scan AND
char *end
));
364 EXFUN(decode_subscr_data
, (char *scan AND
char *end
));
367 EXFUN(read_array_type
, (struct dieinfo
*dip
));
370 EXFUN(read_subroutine_type
,
371 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
374 EXFUN(read_enumeration
,
375 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
379 (struct dieinfo
*dip AND
char *thisdie AND
char *enddie
));
382 EXFUN(enum_type
, (struct dieinfo
*dip
));
385 EXFUN(start_symtab
, (void));
389 (char *filename AND
long language AND
struct objfile
*objfile
));
392 EXFUN(scopecount
, (struct scopenode
*node
));
396 (struct symbol
*namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc
));
399 EXFUN(freescope
, (struct scopenode
*node
));
401 static struct block
*
402 EXFUN(buildblock
, (struct pending_symbol
*syms
));
405 EXFUN(closescope
, (void));
408 EXFUN(record_line
, (int line AND CORE_ADDR pc
));
411 EXFUN(decode_line_numbers
, (char *linetable
));
414 EXFUN(decode_die_type
, (struct dieinfo
*dip
));
417 EXFUN(decode_mod_fund_type
, (char *typedata
));
420 EXFUN(decode_mod_u_d_type
, (char *typedata
));
423 EXFUN(decode_modified_type
,
424 (unsigned char *modifiers AND
unsigned short modcount AND
int mtype
));
427 EXFUN(decode_fund_type
, (unsigned short fundtype
));
430 EXFUN(create_name
, (char *name AND
struct obstack
*obstackp
));
433 EXFUN(add_symbol_to_list
,
434 (struct symbol
*symbol AND
struct pending_symbol
**listhead
));
436 static struct block
**
437 EXFUN(gatherblocks
, (struct block
**dest AND
struct scopenode
*node
));
439 static struct blockvector
*
440 EXFUN(make_blockvector
, (void));
443 EXFUN(lookup_utype
, (DIEREF dieref
));
446 EXFUN(alloc_utype
, (DIEREF dieref AND
struct type
*usetype
));
448 static struct symbol
*
449 EXFUN(new_symbol
, (struct dieinfo
*dip
));
452 EXFUN(locval
, (char *loc
));
455 EXFUN(record_misc_function
, (char *name AND CORE_ADDR address AND
456 enum misc_function_type
));
459 EXFUN(compare_psymbols
,
460 (struct partial_symbol
*s1 AND
struct partial_symbol
*s2
));
467 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
471 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
472 int mainline, unsigned int dbfoff, unsigned int dbsize,
473 unsigned int lnoffset, unsigned int lnsize,
474 struct objfile *objfile)
478 This function is called upon to build partial symtabs from files
479 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
481 It is passed a file descriptor for an open file containing the DIES
482 and line number information, the corresponding filename for that
483 file, a base address for relocating the symbols, a flag indicating
484 whether or not this debugging information is from a "main symbol
485 table" rather than a shared library or dynamically linked file,
486 and file offset/size pairs for the DIE information and line number
496 DEFUN(dwarf_build_psymtabs
,
497 (desc
, filename
, addr
, mainline
, dbfoff
, dbsize
, lnoffset
, lnsize
,
503 unsigned int dbfoff AND
504 unsigned int dbsize AND
505 unsigned int lnoffset AND
506 unsigned int lnsize AND
507 struct objfile
*objfile
)
509 struct cleanup
*back_to
;
511 dbbase
= xmalloc (dbsize
);
513 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
514 (read (desc
, dbbase
, dbsize
) != dbsize
))
517 error ("can't read DWARF data from '%s'", filename
);
519 back_to
= make_cleanup (free
, dbbase
);
521 /* If we are reinitializing, or if we have never loaded syms yet, init.
522 Since we have no idea how many DIES we are looking at, we just guess
523 some arbitrary value. */
525 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
527 init_psymbol_list (1024);
530 /* Follow the compilation unit sibling chain, building a partial symbol
531 table entry for each one. Save enough information about each compilation
532 unit to locate the full DWARF information later. */
534 scan_compilation_units (filename
, addr
, dbbase
, dbbase
+ dbsize
,
535 dbfoff
, lnoffset
, objfile
);
537 do_cleanups (back_to
);
545 record_misc_function -- add entry to miscellaneous function vector
549 static void record_misc_function (char *name, CORE_ADDR address,
550 enum misc_function_type mf_type)
554 Given a pointer to the name of a symbol that should be added to the
555 miscellaneous function vector, and the address associated with that
556 symbol, records this information for later use in building the
557 miscellaneous function vector.
562 DEFUN(record_misc_function
, (name
, address
, mf_type
),
563 char *name AND CORE_ADDR address AND
enum misc_function_type mf_type
)
565 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
573 dwarfwarn -- issue a DWARF related warning
577 Issue warnings about DWARF related things that aren't serious enough
578 to warrant aborting with an error, but should not be ignored either.
579 This includes things like detectable corruption in DIE's, missing
580 DIE's, unimplemented features, etc.
582 In general, running across tags or attributes that we don't recognize
583 is not considered to be a problem and we should not issue warnings
588 We mostly follow the example of the error() routine, but without
589 returning to command level. It is arguable about whether warnings
590 should be issued at all, and if so, where they should go (stdout or
593 We assume that curdie is valid and contains at least the basic
594 information for the DIE where the problem was noticed.
599 DEFUN(dwarfwarn
, (fmt
), char *fmt DOTS
)
605 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
606 if (curdie
-> at_name
)
608 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
610 vfprintf (stderr
, fmt
, ap
);
611 fprintf (stderr
, "\n");
625 fmt
= va_arg (ap
, char *);
627 fprintf (stderr
, "DWARF warning (ref 0x%x): ", curdie
-> dieref
);
628 if (curdie
-> at_name
)
630 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
632 vfprintf (stderr
, fmt
, ap
);
633 fprintf (stderr
, "\n");
642 compare_psymbols -- compare two partial symbols by name
646 Given pointer to two partial symbol table entries, compare
647 them by name and return -N, 0, or +N (ala strcmp). Typically
648 used by sorting routines like qsort().
652 This is a copy from dbxread.c. It should be moved to a generic
653 gdb file and made available for all psymtab builders (FIXME).
655 Does direct compare of first two characters before punting
656 and passing to strcmp for longer compares. Note that the
657 original version had a bug whereby two null strings or two
658 identically named one character strings would return the
659 comparison of memory following the null byte.
664 DEFUN(compare_psymbols
, (s1
, s2
),
665 struct partial_symbol
*s1 AND
666 struct partial_symbol
*s2
)
668 register char *st1
= SYMBOL_NAME (s1
);
669 register char *st2
= SYMBOL_NAME (s2
);
671 if ((st1
[0] - st2
[0]) || !st1
[0])
673 return (st1
[0] - st2
[0]);
675 else if ((st1
[1] - st2
[1]) || !st1
[1])
677 return (st1
[1] - st2
[1]);
681 return (strcmp (st1
+ 2, st2
+ 2));
689 read_lexical_block_scope -- process all dies in a lexical block
693 static void read_lexical_block_scope (struct dieinfo *dip,
694 char *thisdie, char *enddie)
698 Process all the DIES contained within a lexical block scope.
699 Start a new scope, process the dies, and then close the scope.
704 DEFUN(read_lexical_block_scope
, (dip
, thisdie
, enddie
, objfile
),
705 struct dieinfo
*dip AND
708 struct objfile
*objfile
)
710 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
711 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
719 lookup_utype -- look up a user defined type from die reference
723 static type *lookup_utype (DIEREF dieref)
727 Given a DIE reference, lookup the user defined type associated with
728 that DIE, if it has been registered already. If not registered, then
729 return NULL. Alloc_utype() can be called to register an empty
730 type for this reference, which will be filled in later when the
731 actual referenced DIE is processed.
735 DEFUN(lookup_utype
, (dieref
), DIEREF dieref
)
737 struct type
*type
= NULL
;
740 utypeidx
= (dieref
- dbroff
) / 4;
741 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
743 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
747 type
= *(utypes
+ utypeidx
);
757 alloc_utype -- add a user defined type for die reference
761 static type *alloc_utype (DIEREF dieref, struct type *utypep)
765 Given a die reference DIEREF, and a possible pointer to a user
766 defined type UTYPEP, register that this reference has a user
767 defined type and either use the specified type in UTYPEP or
768 make a new empty type that will be filled in later.
770 We should only be called after calling lookup_utype() to verify that
771 there is not currently a type registered for DIEREF.
775 DEFUN(alloc_utype
, (dieref
, utypep
),
782 utypeidx
= (dieref
- dbroff
) / 4;
783 typep
= utypes
+ utypeidx
;
784 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
786 utypep
= builtin_type_int
;
787 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref
);
789 else if (*typep
!= NULL
)
792 SQUAWK (("internal error: dup user type allocation"));
798 utypep
= (struct type
*)
799 obstack_alloc (symbol_obstack
, sizeof (struct type
));
800 (void) memset (utypep
, 0, sizeof (struct type
));
811 decode_die_type -- return a type for a specified die
815 static struct type *decode_die_type (struct dieinfo *dip)
819 Given a pointer to a die information structure DIP, decode the
820 type of the die and return a pointer to the decoded type. All
821 dies without specific types default to type int.
825 DEFUN(decode_die_type
, (dip
), struct dieinfo
*dip
)
827 struct type
*type
= NULL
;
829 if (dip
-> at_fund_type
!= 0)
831 type
= decode_fund_type (dip
-> at_fund_type
);
833 else if (dip
-> at_mod_fund_type
!= NULL
)
835 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
837 else if (dip
-> at_user_def_type
)
839 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
841 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
844 else if (dip
-> at_mod_u_d_type
)
846 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
850 type
= builtin_type_int
;
859 struct_type -- compute and return the type for a struct or union
863 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
868 Given pointer to a die information structure for a die which
869 defines a union or structure, and pointers to the raw die data
870 that define the range of dies which define the members, compute
871 and return the user defined type for the structure or union.
875 DEFUN(struct_type
, (dip
, thisdie
, enddie
),
876 struct dieinfo
*dip AND
882 struct nextfield
*next
;
885 struct nextfield
*list
= NULL
;
886 struct nextfield
*new;
894 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
896 type
= alloc_utype (dip
-> dieref
, NULL
);
898 switch (dip
-> dietag
)
900 case TAG_structure_type
:
901 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
905 TYPE_CODE (type
) = TYPE_CODE_UNION
;
910 SQUAWK (("missing structure or union tag"));
911 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
914 if (dip
-> at_name
== NULL
)
920 tpart2
= dip
-> at_name
;
922 if (dip
-> at_byte_size
== 0)
924 tpart3
= " <opaque>";
926 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
929 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
930 thisdie
+= dip
-> dielength
;
931 while (thisdie
< enddie
)
933 basicdieinfo (&mbr
, thisdie
);
934 completedieinfo (&mbr
);
935 if (mbr
.dielength
<= sizeof (long))
942 /* Get space to record the next field's data. */
943 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
947 list
-> field
.name
= savestring (mbr
.at_name
, strlen (mbr
.at_name
));
948 list
-> field
.type
= decode_die_type (&mbr
);
949 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
950 list
-> field
.bitsize
= 0;
954 SQUAWK (("bad member of '%s'", TYPE_NAME (type
)));
957 thisdie
+= mbr
.dielength
;
959 /* Now create the vector of fields, and record how big it is. */
960 TYPE_NFIELDS (type
) = nfields
;
961 TYPE_FIELDS (type
) = (struct field
*)
962 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
963 /* Copy the saved-up fields into the field vector. */
964 for (n
= nfields
; list
; list
= list
-> next
)
966 TYPE_FIELD (type
, --n
) = list
-> field
;
975 read_structure_scope -- process all dies within struct or union
979 static void read_structure_scope (struct dieinfo *dip,
980 char *thisdie, char *enddie)
984 Called when we find the DIE that starts a structure or union
985 scope (definition) to process all dies that define the members
986 of the structure or union. DIP is a pointer to the die info
987 struct for the DIE that names the structure or union.
991 Note that we need to call struct_type regardless of whether or not
992 we have a symbol, since we might have a structure or union without
993 a tag name (thus no symbol for the tagname).
997 DEFUN(read_structure_scope
, (dip
, thisdie
, enddie
),
998 struct dieinfo
*dip AND
1005 type
= struct_type (dip
, thisdie
, enddie
);
1006 if ((sym
= new_symbol (dip
)) != NULL
)
1008 SYMBOL_TYPE (sym
) = type
;
1016 decode_array_element_type -- decode type of the array elements
1020 static struct type *decode_array_element_type (char *scan, char *end)
1024 As the last step in decoding the array subscript information for an
1025 array DIE, we need to decode the type of the array elements. We are
1026 passed a pointer to this last part of the subscript information and
1027 must return the appropriate type. If the type attribute is not
1028 recognized, just warn about the problem and return type int.
1031 static struct type
*
1032 DEFUN(decode_array_element_type
, (scan
, end
), char *scan AND
char *end
)
1037 unsigned short fundtype
;
1039 (void) memcpy (&attribute
, scan
, sizeof (short));
1040 scan
+= sizeof (short);
1044 (void) memcpy (&fundtype
, scan
, sizeof (short));
1045 typep
= decode_fund_type (fundtype
);
1047 case AT_mod_fund_type
:
1048 typep
= decode_mod_fund_type (scan
);
1050 case AT_user_def_type
:
1051 (void) memcpy (&dieref
, scan
, sizeof (DIEREF
));
1052 if ((typep
= lookup_utype (dieref
)) == NULL
)
1054 typep
= alloc_utype (dieref
, NULL
);
1057 case AT_mod_u_d_type
:
1058 typep
= decode_mod_u_d_type (scan
);
1061 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1062 typep
= builtin_type_int
;
1072 decode_subscr_data -- decode array subscript and element type data
1076 static struct type *decode_subscr_data (char *scan, char *end)
1080 The array subscripts and the data type of the elements of an
1081 array are described by a list of data items, stored as a block
1082 of contiguous bytes. There is a data item describing each array
1083 dimension, and a final data item describing the element type.
1084 The data items are ordered the same as their appearance in the
1085 source (I.E. leftmost dimension first, next to leftmost second,
1088 We are passed a pointer to the start of the block of bytes
1089 containing the data items, and a pointer to the first byte past
1090 the data. This function decodes the data and returns a type.
1093 FIXME: This code only implements the forms currently used
1094 by the AT&T and GNU C compilers.
1096 The end pointer is supplied for error checking, maybe we should
1100 static struct type
*
1101 DEFUN(decode_subscr_data
, (scan
, end
), char *scan AND
char *end
)
1103 struct type
*typep
= NULL
;
1104 struct type
*nexttype
;
1114 typep
= decode_array_element_type (scan
, end
);
1117 (void) memcpy (&fundtype
, scan
, sizeof (short));
1118 scan
+= sizeof (short);
1119 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1120 && fundtype
!= FT_unsigned_integer
)
1122 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1127 (void) memcpy (&lowbound
, scan
, sizeof (long));
1128 scan
+= sizeof (long);
1129 (void) memcpy (&highbound
, scan
, sizeof (long));
1130 scan
+= sizeof (long);
1131 nexttype
= decode_subscr_data (scan
, end
);
1132 if (nexttype
!= NULL
)
1134 typep
= (struct type
*)
1135 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1136 (void) memset (typep
, 0, sizeof (struct type
));
1137 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1138 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1139 TYPE_LENGTH (typep
) *= lowbound
+ highbound
+ 1;
1140 TYPE_TARGET_TYPE (typep
) = nexttype
;
1151 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1154 SQUAWK (("unknown array subscript format %x", format
));
1164 read_array_type -- read TAG_array_type DIE
1168 static void read_array_type (struct dieinfo *dip)
1172 Extract all information from a TAG_array_type DIE and add to
1173 the user defined type vector.
1177 DEFUN(read_array_type
, (dip
), struct dieinfo
*dip
)
1184 if (dip
-> at_ordering
!= ORD_row_major
)
1186 /* FIXME: Can gdb even handle column major arrays? */
1187 SQUAWK (("array not row major; not handled correctly"));
1189 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1191 (void) memcpy (&temp
, sub
, sizeof (short));
1192 subend
= sub
+ sizeof (short) + temp
;
1193 sub
+= sizeof (short);
1194 type
= decode_subscr_data (sub
, subend
);
1197 type
= alloc_utype (dip
-> dieref
, NULL
);
1198 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1199 TYPE_TARGET_TYPE (type
) = builtin_type_int
;
1200 TYPE_LENGTH (type
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
1204 type
= alloc_utype (dip
-> dieref
, type
);
1213 read_subroutine_type -- process TAG_subroutine_type dies
1217 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1222 Handle DIES due to C code like:
1225 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1231 The parameter DIES are currently ignored. See if gdb has a way to
1232 include this info in it's type system, and decode them if so. Is
1233 this what the type structure's "arg_types" field is for? (FIXME)
1237 DEFUN(read_subroutine_type
, (dip
, thisdie
, enddie
),
1238 struct dieinfo
*dip AND
1244 type
= decode_die_type (dip
);
1245 type
= lookup_function_type (type
);
1246 type
= alloc_utype (dip
-> dieref
, type
);
1253 read_enumeration -- process dies which define an enumeration
1257 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1262 Given a pointer to a die which begins an enumeration, process all
1263 the dies that define the members of the enumeration.
1267 Note that we need to call enum_type regardless of whether or not we
1268 have a symbol, since we might have an enum without a tag name (thus
1269 no symbol for the tagname).
1273 DEFUN(read_enumeration
, (dip
, thisdie
, enddie
),
1274 struct dieinfo
*dip AND
1281 type
= enum_type (dip
);
1282 if ((sym
= new_symbol (dip
)) != NULL
)
1284 SYMBOL_TYPE (sym
) = type
;
1292 enum_type -- decode and return a type for an enumeration
1296 static type *enum_type (struct dieinfo *dip)
1300 Given a pointer to a die information structure for the die which
1301 starts an enumeration, process all the dies that define the members
1302 of the enumeration and return a type pointer for the enumeration.
1305 static struct type
*
1306 DEFUN(enum_type
, (dip
), struct dieinfo
*dip
)
1310 struct nextfield
*next
;
1313 struct nextfield
*list
= NULL
;
1314 struct nextfield
*new;
1324 if ((type
= lookup_utype (dip
-> dieref
)) == NULL
)
1326 type
= alloc_utype (dip
-> dieref
, NULL
);
1328 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1330 if (dip
-> at_name
== NULL
)
1334 tpart2
= dip
-> at_name
;
1336 if (dip
-> at_byte_size
== 0)
1338 tpart3
= " <opaque>";
1342 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1345 TYPE_NAME (type
) = concat (tpart1
, tpart2
, tpart3
, NULL
);
1346 if ((scan
= dip
-> at_element_list
) != NULL
)
1348 (void) memcpy (&temp
, scan
, sizeof (temp
));
1349 listend
= scan
+ temp
+ sizeof (temp
);
1350 scan
+= sizeof (temp
);
1351 while (scan
< listend
)
1353 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1356 list
-> field
.type
= NULL
;
1357 list
-> field
.bitsize
= 0;
1358 (void) memcpy (&list
-> field
.bitpos
, scan
, sizeof (long));
1359 scan
+= sizeof (long);
1360 list
-> field
.name
= savestring (scan
, strlen (scan
));
1361 scan
+= strlen (scan
) + 1;
1365 /* Now create the vector of fields, and record how big it is. */
1366 TYPE_NFIELDS (type
) = nfields
;
1367 TYPE_FIELDS (type
) = (struct field
*)
1368 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1369 /* Copy the saved-up fields into the field vector. */
1370 for (n
= nfields
; list
; list
= list
-> next
)
1372 TYPE_FIELD (type
, --n
) = list
-> field
;
1381 read_func_scope -- process all dies within a function scope
1385 Process all dies within a given function scope. We are passed
1386 a die information structure pointer DIP for the die which
1387 starts the function scope, and pointers into the raw die data
1388 that define the dies within the function scope.
1390 For now, we ignore lexical block scopes within the function.
1391 The problem is that AT&T cc does not define a DWARF lexical
1392 block scope for the function itself, while gcc defines a
1393 lexical block scope for the function. We need to think about
1394 how to handle this difference, or if it is even a problem.
1399 DEFUN(read_func_scope
, (dip
, thisdie
, enddie
, objfile
),
1400 struct dieinfo
*dip AND
1403 struct objfile
*objfile
)
1407 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1409 entry_scope_lowpc
= dip
-> at_low_pc
;
1410 entry_scope_highpc
= dip
-> at_high_pc
;
1412 if (strcmp (dip
-> at_name
, "main") == 0) /* FIXME: hardwired name */
1414 main_scope_lowpc
= dip
-> at_low_pc
;
1415 main_scope_highpc
= dip
-> at_high_pc
;
1417 sym
= new_symbol (dip
);
1418 openscope (sym
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1419 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1427 read_file_scope -- process all dies within a file scope
1431 Process all dies within a given file scope. We are passed a
1432 pointer to the die information structure for the die which
1433 starts the file scope, and pointers into the raw die data which
1434 mark the range of dies within the file scope.
1436 When the partial symbol table is built, the file offset for the line
1437 number table for each compilation unit is saved in the partial symbol
1438 table entry for that compilation unit. As the symbols for each
1439 compilation unit are read, the line number table is read into memory
1440 and the variable lnbase is set to point to it. Thus all we have to
1441 do is use lnbase to access the line number table for the current
1446 DEFUN(read_file_scope
, (dip
, thisdie
, enddie
, objfile
),
1447 struct dieinfo
*dip AND
1450 struct objfile
*objfile
)
1452 struct cleanup
*back_to
;
1454 if (entry_point
>= dip
-> at_low_pc
&& entry_point
< dip
-> at_high_pc
)
1456 startup_file_start
= dip
-> at_low_pc
;
1457 startup_file_end
= dip
-> at_high_pc
;
1459 numutypes
= (enddie
- thisdie
) / 4;
1460 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1461 back_to
= make_cleanup (free
, utypes
);
1462 (void) memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1464 openscope (NULL
, dip
-> at_low_pc
, dip
-> at_high_pc
);
1465 decode_line_numbers (lnbase
);
1466 process_dies (thisdie
+ dip
-> dielength
, enddie
, objfile
);
1468 end_symtab (dip
-> at_name
, dip
-> at_language
, objfile
);
1469 do_cleanups (back_to
);
1478 start_symtab -- do initialization for starting new symbol table
1482 static void start_symtab (void)
1486 Called whenever we are starting to process dies for a new
1487 compilation unit, to perform initializations. Right now
1488 the only thing we really have to do is initialize storage
1489 space for the line number vector.
1494 DEFUN_VOID (start_symtab
)
1498 line_vector_index
= 0;
1499 line_vector_length
= 1000;
1500 nbytes
= sizeof (struct linetable
);
1501 nbytes
+= line_vector_length
* sizeof (struct linetable_entry
);
1502 line_vector
= (struct linetable
*) xmalloc (nbytes
);
1509 process_dies -- process a range of DWARF Information Entries
1513 static void process_dies (char *thisdie, char *enddie)
1517 Process all DIE's in a specified range. May be (and almost
1518 certainly will be) called recursively.
1522 DEFUN(process_dies
, (thisdie
, enddie
, objfile
),
1523 char *thisdie AND
char *enddie AND
struct objfile
*objfile
)
1528 while (thisdie
< enddie
)
1530 basicdieinfo (&di
, thisdie
);
1531 if (di
.dielength
< sizeof (long))
1535 else if (di
.dietag
== TAG_padding
)
1537 nextdie
= thisdie
+ di
.dielength
;
1541 completedieinfo (&di
);
1542 if (di
.at_sibling
!= 0)
1544 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1548 nextdie
= thisdie
+ di
.dielength
;
1552 case TAG_compile_unit
:
1553 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1555 case TAG_global_subroutine
:
1556 case TAG_subroutine
:
1557 if (!di
.at_is_external_p
)
1559 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1562 case TAG_lexical_block
:
1563 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1565 case TAG_structure_type
:
1566 case TAG_union_type
:
1567 read_structure_scope (&di
, thisdie
, nextdie
);
1569 case TAG_enumeration_type
:
1570 read_enumeration (&di
, thisdie
, nextdie
);
1572 case TAG_subroutine_type
:
1573 read_subroutine_type (&di
, thisdie
, nextdie
);
1575 case TAG_array_type
:
1576 read_array_type (&di
);
1579 (void) new_symbol (&di
);
1591 end_symtab -- finish processing for a compilation unit
1595 static void end_symtab (char *filename, long language)
1599 Complete the symbol table entry for the current compilation
1600 unit. Make the struct symtab and put it on the list of all
1606 DEFUN(end_symtab
, (filename
, language
, objfile
),
1607 char *filename AND
long language AND
struct objfile
*objfile
)
1609 struct symtab
*symtab
;
1610 struct blockvector
*blockvector
;
1613 /* Ignore a file that has no functions with real debugging info. */
1614 if (global_symbols
== NULL
&& scopetree
-> block
== NULL
)
1618 line_vector_length
= -1;
1619 freescope (scopetree
);
1620 scope
= scopetree
= NULL
;
1623 /* Create the blockvector that points to all the file's blocks. */
1625 blockvector
= make_blockvector ();
1627 /* Now create the symtab object for this source file. */
1629 symtab
= allocate_symtab (savestring (filename
, strlen (filename
)),
1632 symtab
-> free_ptr
= 0;
1634 /* Fill in its components. */
1635 symtab
-> blockvector
= blockvector
;
1636 symtab
-> free_code
= free_linetable
;
1638 /* Save the line number information. */
1640 line_vector
-> nitems
= line_vector_index
;
1641 nbytes
= sizeof (struct linetable
);
1642 if (line_vector_index
> 1)
1644 nbytes
+= (line_vector_index
- 1) * sizeof (struct linetable_entry
);
1646 symtab
-> linetable
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1648 /* FIXME: The following may need to be expanded for other languages */
1653 symtab
-> language
= language_c
;
1655 case LANG_C_PLUS_PLUS
:
1656 symtab
-> language
= language_cplus
;
1662 /* Link the new symtab into the list of such. */
1663 symtab
-> next
= symtab_list
;
1664 symtab_list
= symtab
;
1666 /* Recursively free the scope tree */
1667 freescope (scopetree
);
1668 scope
= scopetree
= NULL
;
1670 /* Reinitialize for beginning of new file. */
1672 line_vector_length
= -1;
1679 scopecount -- count the number of enclosed scopes
1683 static int scopecount (struct scopenode *node)
1687 Given pointer to a node, compute the size of the subtree which is
1688 rooted in this node, which also happens to be the number of scopes
1693 DEFUN(scopecount
, (node
), struct scopenode
*node
)
1699 count
+= scopecount (node
-> child
);
1700 count
+= scopecount (node
-> sibling
);
1710 openscope -- start a new lexical block scope
1714 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1719 Start a new scope by allocating a new scopenode, adding it as the
1720 next child of the current scope (if any) or as the root of the
1721 scope tree, and then making the new node the current scope node.
1725 DEFUN(openscope
, (namesym
, lowpc
, highpc
),
1726 struct symbol
*namesym AND
1730 struct scopenode
*new;
1731 struct scopenode
*child
;
1733 new = (struct scopenode
*) xmalloc (sizeof (*new));
1734 (void) memset (new, 0, sizeof (*new));
1735 new -> namesym
= namesym
;
1736 new -> lowpc
= lowpc
;
1737 new -> highpc
= highpc
;
1742 else if ((child
= scope
-> child
) == NULL
)
1744 scope
-> child
= new;
1745 new -> parent
= scope
;
1749 while (child
-> sibling
!= NULL
)
1751 child
= child
-> sibling
;
1753 child
-> sibling
= new;
1754 new -> parent
= scope
;
1763 freescope -- free a scope tree rooted at the given node
1767 static void freescope (struct scopenode *node)
1771 Given a pointer to a node in the scope tree, free the subtree
1772 rooted at that node. First free all the children and sibling
1773 nodes, and then the node itself. Used primarily for cleaning
1774 up after ourselves and returning memory to the system.
1778 DEFUN(freescope
, (node
), struct scopenode
*node
)
1782 freescope (node
-> child
);
1783 freescope (node
-> sibling
);
1792 buildblock -- build a new block from pending symbols list
1796 static struct block *buildblock (struct pending_symbol *syms)
1800 Given a pointer to a list of symbols, build a new block and free
1801 the symbol list structure. Also check each symbol to see if it
1802 is the special symbol that flags that this block was compiled by
1803 gcc, and if so, mark the block appropriately.
1806 static struct block
*
1807 DEFUN(buildblock
, (syms
), struct pending_symbol
*syms
)
1809 struct pending_symbol
*next
, *next1
;
1811 struct block
*newblock
;
1814 for (next
= syms
, i
= 0 ; next
; next
= next
-> next
, i
++) {;}
1816 /* Allocate a new block */
1818 nbytes
= sizeof (struct block
);
1821 nbytes
+= (i
- 1) * sizeof (struct symbol
*);
1823 newblock
= (struct block
*) obstack_alloc (symbol_obstack
, nbytes
);
1824 (void) memset (newblock
, 0, nbytes
);
1826 /* Copy the symbols into the block. */
1828 BLOCK_NSYMS (newblock
) = i
;
1829 for (next
= syms
; next
; next
= next
-> next
)
1831 BLOCK_SYM (newblock
, --i
) = next
-> symbol
;
1832 if (STREQ (GCC_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)) ||
1833 STREQ (GCC2_COMPILED_FLAG_SYMBOL
, SYMBOL_NAME (next
-> symbol
)))
1835 BLOCK_GCC_COMPILED (newblock
) = 1;
1839 /* Now free the links of the list, and empty the list. */
1841 for (next
= syms
; next
; next
= next1
)
1843 next1
= next
-> next
;
1854 closescope -- close a lexical block scope
1858 static void closescope (void)
1862 Close the current lexical block scope. Closing the current scope
1863 is as simple as moving the current scope pointer up to the parent
1864 of the current scope pointer. But we also take this opportunity
1865 to build the block for the current scope first, since we now have
1866 all of it's symbols.
1870 DEFUN_VOID(closescope
)
1872 struct scopenode
*child
;
1876 error ("DWARF parse error, too many close scopes");
1880 if (scope
-> parent
== NULL
)
1882 global_symbol_block
= buildblock (global_symbols
);
1883 global_symbols
= NULL
;
1884 BLOCK_START (global_symbol_block
) = scope
-> lowpc
+ baseaddr
;
1885 BLOCK_END (global_symbol_block
) = scope
-> highpc
+ baseaddr
;
1887 scope
-> block
= buildblock (scope
-> symbols
);
1888 scope
-> symbols
= NULL
;
1889 BLOCK_START (scope
-> block
) = scope
-> lowpc
+ baseaddr
;
1890 BLOCK_END (scope
-> block
) = scope
-> highpc
+ baseaddr
;
1892 /* Put the local block in as the value of the symbol that names it. */
1894 if (scope
-> namesym
)
1896 SYMBOL_BLOCK_VALUE (scope
-> namesym
) = scope
-> block
;
1897 BLOCK_FUNCTION (scope
-> block
) = scope
-> namesym
;
1900 /* Install this scope's local block as the superblock of all child
1903 for (child
= scope
-> child
; child
; child
= child
-> sibling
)
1905 BLOCK_SUPERBLOCK (child
-> block
) = scope
-> block
;
1908 scope
= scope
-> parent
;
1916 record_line -- record a line number entry in the line vector
1920 static void record_line (int line, CORE_ADDR pc)
1924 Given a line number and the corresponding pc value, record
1925 this pair in the line number vector, expanding the vector as
1930 DEFUN(record_line
, (line
, pc
), int line AND CORE_ADDR pc
)
1932 struct linetable_entry
*e
;
1935 /* Make sure line vector is big enough. */
1937 if (line_vector_index
+ 2 >= line_vector_length
)
1939 line_vector_length
*= 2;
1940 nbytes
= sizeof (struct linetable
);
1941 nbytes
+= (line_vector_length
* sizeof (struct linetable_entry
));
1942 line_vector
= (struct linetable
*) xrealloc (line_vector
, nbytes
);
1944 e
= line_vector
-> item
+ line_vector_index
++;
1953 decode_line_numbers -- decode a line number table fragment
1957 static void decode_line_numbers (char *tblscan, char *tblend,
1958 long length, long base, long line, long pc)
1962 Translate the DWARF line number information to gdb form.
1964 The ".line" section contains one or more line number tables, one for
1965 each ".line" section from the objects that were linked.
1967 The AT_stmt_list attribute for each TAG_source_file entry in the
1968 ".debug" section contains the offset into the ".line" section for the
1969 start of the table for that file.
1971 The table itself has the following structure:
1973 <table length><base address><source statement entry>
1974 4 bytes 4 bytes 10 bytes
1976 The table length is the total size of the table, including the 4 bytes
1977 for the length information.
1979 The base address is the address of the first instruction generated
1980 for the source file.
1982 Each source statement entry has the following structure:
1984 <line number><statement position><address delta>
1985 4 bytes 2 bytes 4 bytes
1987 The line number is relative to the start of the file, starting with
1990 The statement position either -1 (0xFFFF) or the number of characters
1991 from the beginning of the line to the beginning of the statement.
1993 The address delta is the difference between the base address and
1994 the address of the first instruction for the statement.
1996 Note that we must copy the bytes from the packed table to our local
1997 variables before attempting to use them, to avoid alignment problems
1998 on some machines, particularly RISC processors.
2002 Does gdb expect the line numbers to be sorted? They are now by
2003 chance/luck, but are not required to be. (FIXME)
2005 The line with number 0 is unused, gdb apparently can discover the
2006 span of the last line some other way. How? (FIXME)
2010 DEFUN(decode_line_numbers
, (linetable
), char *linetable
)
2019 if (linetable
!= NULL
)
2021 tblscan
= tblend
= linetable
;
2022 (void) memcpy (&length
, tblscan
, sizeof (long));
2023 tblscan
+= sizeof (long);
2025 (void) memcpy (&base
, tblscan
, sizeof (long));
2027 tblscan
+= sizeof (long);
2028 while (tblscan
< tblend
)
2030 (void) memcpy (&line
, tblscan
, sizeof (long));
2031 tblscan
+= sizeof (long) + sizeof (short);
2032 (void) memcpy (&pc
, tblscan
, sizeof (long));
2033 tblscan
+= sizeof (long);
2037 record_line (line
, pc
);
2047 add_symbol_to_list -- add a symbol to head of current symbol list
2051 static void add_symbol_to_list (struct symbol *symbol, struct
2052 pending_symbol **listhead)
2056 Given a pointer to a symbol and a pointer to a pointer to a
2057 list of symbols, add this symbol as the current head of the
2058 list. Typically used for example to add a symbol to the
2059 symbol list for the current scope.
2064 DEFUN(add_symbol_to_list
, (symbol
, listhead
),
2065 struct symbol
*symbol AND
struct pending_symbol
**listhead
)
2067 struct pending_symbol
*link
;
2071 link
= (struct pending_symbol
*) xmalloc (sizeof (*link
));
2072 link
-> next
= *listhead
;
2073 link
-> symbol
= symbol
;
2082 gatherblocks -- walk a scope tree and build block vectors
2086 static struct block **gatherblocks (struct block **dest,
2087 struct scopenode *node)
2091 Recursively walk a scope tree rooted in the given node, adding blocks
2092 to the array pointed to by DEST, in preorder. I.E., first we add the
2093 block for the current scope, then all the blocks for child scopes,
2094 and finally all the blocks for sibling scopes.
2097 static struct block
**
2098 DEFUN(gatherblocks
, (dest
, node
),
2099 struct block
**dest AND
struct scopenode
*node
)
2103 *dest
++ = node
-> block
;
2104 dest
= gatherblocks (dest
, node
-> child
);
2105 dest
= gatherblocks (dest
, node
-> sibling
);
2114 make_blockvector -- make a block vector from current scope tree
2118 static struct blockvector *make_blockvector (void)
2122 Make a blockvector from all the blocks in the current scope tree.
2123 The first block is always the global symbol block, followed by the
2124 block for the root of the scope tree which is the local symbol block,
2125 followed by all the remaining blocks in the scope tree, which are all
2130 Note that since the root node of the scope tree is created at the time
2131 each file scope is entered, there are always at least two blocks,
2132 neither of which may have any symbols, but always contribute a block
2133 to the block vector. So the test for number of blocks greater than 1
2134 below is unnecessary given bug free code.
2136 The resulting block structure varies slightly from that produced
2137 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2138 with dbxread.c, block 1 is a child of block 0. This does not
2139 seem to cause any problems, but probably should be fixed. (FIXME)
2142 static struct blockvector
*
2143 DEFUN_VOID(make_blockvector
)
2145 struct blockvector
*blockvector
= NULL
;
2149 /* Recursively walk down the tree, counting the number of blocks.
2150 Then add one to account for the global's symbol block */
2152 i
= scopecount (scopetree
) + 1;
2153 nbytes
= sizeof (struct blockvector
);
2156 nbytes
+= (i
- 1) * sizeof (struct block
*);
2158 blockvector
= (struct blockvector
*)
2159 obstack_alloc (symbol_obstack
, nbytes
);
2161 /* Copy the blocks into the blockvector. */
2163 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
2164 BLOCKVECTOR_BLOCK (blockvector
, 0) = global_symbol_block
;
2165 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector
, 1), scopetree
);
2167 return (blockvector
);
2174 locval -- compute the value of a location attribute
2178 static int locval (char *loc)
2182 Given pointer to a string of bytes that define a location, compute
2183 the location and return the value.
2185 When computing values involving the current value of the frame pointer,
2186 the value zero is used, which results in a value relative to the frame
2187 pointer, rather than the absolute value. This is what GDB wants
2190 When the result is a register number, the global isreg flag is set,
2191 otherwise it is cleared. This is a kludge until we figure out a better
2192 way to handle the problem. Gdb's design does not mesh well with the
2193 DWARF notion of a location computing interpreter, which is a shame
2194 because the flexibility goes unused.
2198 Note that stack[0] is unused except as a default error return.
2199 Note that stack overflow is not yet handled.
2203 DEFUN(locval
, (loc
), char *loc
)
2205 unsigned short nbytes
;
2211 (void) memcpy (&nbytes
, loc
, sizeof (short));
2212 end
= loc
+ sizeof (short) + nbytes
;
2216 for (loc
+= sizeof (short); loc
< end
; loc
+= sizeof (long))
2224 /* push register (number) */
2225 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2229 /* push value of register (number) */
2230 /* Actually, we compute the value as if register has 0 */
2231 (void) memcpy (®no
, loc
, sizeof (long));
2234 stack
[++stacki
] = 0;
2238 stack
[++stacki
] = 0;
2239 SQUAWK (("BASEREG %d not handled!", regno
));
2243 /* push address (relocated address) */
2244 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2247 /* push constant (number) */
2248 (void) memcpy (&stack
[++stacki
], loc
, sizeof (long));
2251 /* pop, deref and push 2 bytes (as a long) */
2252 SQUAWK (("OP_DEREF2 address %#x not handled", stack
[stacki
]));
2254 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2255 SQUAWK (("OP_DEREF4 address %#x not handled", stack
[stacki
]));
2257 case OP_ADD
: /* pop top 2 items, add, push result */
2258 stack
[stacki
- 1] += stack
[stacki
];
2263 return (stack
[stacki
]);
2270 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2274 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2278 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2281 static struct symtab
*
2282 DEFUN(read_ofile_symtab
, (pst
),
2283 struct partial_symtab
*pst
)
2285 struct cleanup
*back_to
;
2288 bfd
*abfd
= pst
->objfile
->obfd
;
2290 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2291 unit, seek to the location in the file, and read in all the DIE's. */
2294 dbbase
= xmalloc (DBLENGTH(pst
));
2295 dbroff
= DBROFF(pst
);
2296 foffset
= DBFOFF(pst
) + dbroff
;
2297 if (bfd_seek (abfd
, foffset
, 0) ||
2298 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2301 error ("can't read DWARF data");
2303 back_to
= make_cleanup (free
, dbbase
);
2305 /* If there is a line number table associated with this compilation unit
2306 then read the first long word from the line number table fragment, which
2307 contains the size of the fragment in bytes (including the long word
2308 itself). Allocate a buffer for the fragment and read it in for future
2314 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2315 (bfd_read (&lnsize
, sizeof(long), 1, abfd
) != sizeof(long)))
2317 error ("can't read DWARF line number table size");
2319 lnbase
= xmalloc (lnsize
);
2320 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2321 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2324 error ("can't read DWARF line numbers");
2326 make_cleanup (free
, lnbase
);
2329 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
->objfile
);
2330 do_cleanups (back_to
);
2331 return (symtab_list
);
2338 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2342 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2346 Called once for each partial symbol table entry that needs to be
2347 expanded into a full symbol table entry.
2352 DEFUN(psymtab_to_symtab_1
,
2354 struct partial_symtab
*pst
)
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
]);
2387 if (DBLENGTH(pst
)) /* Otherwise it's a dummy */
2389 /* Init stuff necessary for reading in symbols */
2390 pst
-> symtab
= read_ofile_symtab (pst
);
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
)
2431 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2436 if (DBLENGTH(pst
) || pst
-> number_of_dependencies
)
2438 /* Print the message now, before starting serious work, to avoid
2439 disconcerting pauses. */
2442 printf_filtered ("Reading in symbols for %s...", pst
-> filename
);
2446 psymtab_to_symtab_1 (pst
);
2448 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2449 we need to do an equivalent or is this something peculiar to
2450 stabs/a.out format. */
2451 /* Match with global symbols. This only needs to be done once,
2452 after all of the symtabs and dependencies have been read in. */
2453 scan_file_globals ();
2456 /* Finish up the debug error message. */
2459 printf_filtered ("done.\n");
2468 init_psymbol_list -- initialize storage for partial symbols
2472 static void init_psymbol_list (int total_symbols)
2476 Initializes storage for all of the partial symbols that will be
2477 created by dwarf_build_psymtabs and subsidiaries.
2481 DEFUN(init_psymbol_list
, (total_symbols
), int total_symbols
)
2483 /* Free any previously allocated psymbol lists. */
2485 if (global_psymbols
.list
)
2487 free (global_psymbols
.list
);
2489 if (static_psymbols
.list
)
2491 free (static_psymbols
.list
);
2494 /* Current best guess is that there are approximately a twentieth
2495 of the total symbols (in a debugging file) are global or static
2498 global_psymbols
.size
= total_symbols
/ 10;
2499 static_psymbols
.size
= total_symbols
/ 10;
2500 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
2501 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
2502 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
2503 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
2510 start_psymtab -- allocate and partially fill a partial symtab entry
2514 Allocate and partially fill a partial symtab. It will be completely
2515 filled at the end of the symbol list.
2517 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2518 ADDR is the address relative to which its symbols are (incremental)
2519 or 0 (normal). FILENAME is the name of the compilation unit that
2520 these symbols were defined in, and they appear starting a address
2521 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2522 the full symbols can be read for compilation unit FILENAME.
2523 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2528 static struct partial_symtab
*
2529 DEFUN(start_psymtab
,
2530 (objfile
, addr
, filename
, textlow
, texthigh
, dbfoff
, curoff
,
2531 culength
, lnfoff
, global_syms
, static_syms
),
2532 struct objfile
*objfile AND
2535 CORE_ADDR textlow AND
2536 CORE_ADDR texthigh AND
2541 struct partial_symbol
*global_syms AND
2542 struct partial_symbol
*static_syms
)
2544 struct partial_symtab
*result
;
2546 result
= (struct partial_symtab
*)
2547 obstack_alloc (psymbol_obstack
, sizeof (struct partial_symtab
));
2548 (void) memset (result
, 0, sizeof (struct partial_symtab
));
2549 result
-> addr
= addr
;
2550 result
-> objfile
= objfile
;
2551 result
-> filename
= create_name (filename
, psymbol_obstack
);
2552 result
-> textlow
= textlow
;
2553 result
-> texthigh
= texthigh
;
2554 result
-> read_symtab_private
= (char *) obstack_alloc (psymbol_obstack
,
2555 sizeof (struct dwfinfo
));
2556 DBFOFF (result
) = dbfoff
;
2557 DBROFF (result
) = curoff
;
2558 DBLENGTH (result
) = culength
;
2559 LNFOFF (result
) = lnfoff
;
2560 result
-> readin
= 0;
2561 result
-> symtab
= NULL
;
2562 result
-> read_symtab
= dwarf_psymtab_to_symtab
;
2563 result
-> globals_offset
= global_syms
- global_psymbols
.list
;
2564 result
-> statics_offset
= static_syms
- static_psymbols
.list
;
2566 result
->n_global_syms
= 0;
2567 result
->n_static_syms
= 0;
2576 add_psymbol_to_list -- add a partial symbol to given list
2580 Add a partial symbol to one of the partial symbol vectors (pointed to
2581 by listp). The vector is grown as necessary.
2586 DEFUN(add_psymbol_to_list
,
2587 (listp
, name
, space
, class, value
),
2588 struct psymbol_allocation_list
*listp AND
2590 enum namespace space AND
2591 enum address_class
class AND
2594 struct partial_symbol
*psym
;
2597 if (listp
-> next
>= listp
-> list
+ listp
-> size
)
2599 newsize
= listp
-> size
* 2;
2600 listp
-> list
= (struct partial_symbol
*)
2601 xrealloc (listp
-> list
, (newsize
* sizeof (struct partial_symbol
)));
2602 /* Next assumes we only went one over. Should be good if program works
2604 listp
-> next
= listp
-> list
+ listp
-> size
;
2605 listp
-> size
= newsize
;
2607 psym
= listp
-> next
++;
2608 SYMBOL_NAME (psym
) = create_name (name
, psymbol_obstack
);
2609 SYMBOL_NAMESPACE (psym
) = space
;
2610 SYMBOL_CLASS (psym
) = class;
2611 SYMBOL_VALUE (psym
) = value
;
2618 add_partial_symbol -- add symbol to partial symbol table
2622 Given a DIE, if it is one of the types that we want to
2623 add to a partial symbol table, finish filling in the die info
2624 and then add a partial symbol table entry for it.
2629 DEFUN(add_partial_symbol
, (dip
), struct dieinfo
*dip
)
2631 switch (dip
-> dietag
)
2633 case TAG_global_subroutine
:
2634 record_misc_function (dip
-> at_name
, dip
-> at_low_pc
, mf_text
);
2635 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2636 LOC_BLOCK
, dip
-> at_low_pc
);
2638 case TAG_global_variable
:
2639 record_misc_function (dip
-> at_name
, locval (dip
-> at_location
),
2641 add_psymbol_to_list (&global_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2644 case TAG_subroutine
:
2645 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2646 LOC_BLOCK
, dip
-> at_low_pc
);
2648 case TAG_local_variable
:
2649 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2653 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, VAR_NAMESPACE
,
2656 case TAG_structure_type
:
2657 case TAG_union_type
:
2658 case TAG_enumeration_type
:
2659 add_psymbol_to_list (&static_psymbols
, dip
-> at_name
, STRUCT_NAMESPACE
,
2669 scan_partial_symbols -- scan DIE's within a single compilation unit
2673 Process the DIE's within a single compilation unit, looking for
2674 interesting DIE's that contribute to the partial symbol table entry
2675 for this compilation unit. Since we cannot follow any sibling
2676 chains without reading the complete DIE info for every DIE,
2677 it is probably faster to just sequentially check each one to
2678 see if it is one of the types we are interested in, and if
2679 so, then extracting all the attributes info and generating a
2680 partial symbol table entry.
2685 DEFUN(scan_partial_symbols
, (thisdie
, enddie
), char *thisdie AND
char *enddie
)
2690 while (thisdie
< enddie
)
2692 basicdieinfo (&di
, thisdie
);
2693 if (di
.dielength
< sizeof (long))
2699 nextdie
= thisdie
+ di
.dielength
;
2702 case TAG_global_subroutine
:
2703 case TAG_global_variable
:
2704 case TAG_subroutine
:
2705 case TAG_local_variable
:
2707 case TAG_structure_type
:
2708 case TAG_union_type
:
2709 case TAG_enumeration_type
:
2710 completedieinfo (&di
);
2711 /* Don't attempt to add anonymous structures, unions, or
2712 enumerations since they have no name. Also check that
2713 this is the place where the actual definition occurs,
2714 rather than just a reference to an external. */
2715 if (di
.at_name
!= NULL
&& !di
.at_is_external_p
)
2717 add_partial_symbol (&di
);
2730 scan_compilation_units -- build a psymtab entry for each compilation
2734 This is the top level dwarf parsing routine for building partial
2737 It scans from the beginning of the DWARF table looking for the first
2738 TAG_compile_unit DIE, and then follows the sibling chain to locate
2739 each additional TAG_compile_unit DIE.
2741 For each TAG_compile_unit DIE it creates a partial symtab structure,
2742 calls a subordinate routine to collect all the compilation unit's
2743 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2744 new partial symtab structure into the partial symbol table. It also
2745 records the appropriate information in the partial symbol table entry
2746 to allow the chunk of DIE's and line number table for this compilation
2747 unit to be located and re-read later, to generate a complete symbol
2748 table entry for the compilation unit.
2750 Thus it effectively partitions up a chunk of DIE's for multiple
2751 compilation units into smaller DIE chunks and line number tables,
2752 and associates them with a partial symbol table entry.
2756 If any compilation unit has no line number table associated with
2757 it for some reason (a missing at_stmt_list attribute, rather than
2758 just one with a value of zero, which is valid) then we ensure that
2759 the recorded file offset is zero so that the routine which later
2760 reads line number table fragments knows that there is no fragment
2770 DEFUN(scan_compilation_units
,
2771 (filename
, addr
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
),
2776 unsigned int dbfoff AND
2777 unsigned int lnoffset AND
2778 struct objfile
*objfile
)
2782 struct partial_symtab
*pst
;
2787 while (thisdie
< enddie
)
2789 basicdieinfo (&di
, thisdie
);
2790 if (di
.dielength
< sizeof (long))
2794 else if (di
.dietag
!= TAG_compile_unit
)
2796 nextdie
= thisdie
+ di
.dielength
;
2800 completedieinfo (&di
);
2801 if (di
.at_sibling
!= 0)
2803 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2807 nextdie
= thisdie
+ di
.dielength
;
2809 curoff
= thisdie
- dbbase
;
2810 culength
= nextdie
- thisdie
;
2811 curlnoffset
= di
.at_stmt_list_p
? lnoffset
+ di
.at_stmt_list
: 0;
2812 pst
= start_psymtab (objfile
, addr
, di
.at_name
,
2813 di
.at_low_pc
, di
.at_high_pc
,
2814 dbfoff
, curoff
, culength
, curlnoffset
,
2815 global_psymbols
.next
,
2816 static_psymbols
.next
);
2817 scan_partial_symbols (thisdie
+ di
.dielength
, nextdie
);
2818 pst
-> n_global_syms
= global_psymbols
.next
-
2819 (global_psymbols
.list
+ pst
-> globals_offset
);
2820 pst
-> n_static_syms
= static_psymbols
.next
-
2821 (static_psymbols
.list
+ pst
-> statics_offset
);
2822 /* Sort the global list; don't sort the static list */
2823 qsort (global_psymbols
.list
+ pst
-> globals_offset
,
2824 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
2826 /* If there is already a psymtab or symtab for a file of this name,
2827 remove it. (If there is a symtab, more drastic things also
2828 happen.) This happens in VxWorks. */
2829 free_named_symtabs (pst
-> filename
);
2830 /* Place the partial symtab on the partial symtab list */
2831 pst
-> next
= partial_symtab_list
;
2832 partial_symtab_list
= pst
;
2842 new_symbol -- make a symbol table entry for a new symbol
2846 static struct symbol *new_symbol (struct dieinfo *dip)
2850 Given a pointer to a DWARF information entry, figure out if we need
2851 to make a symbol table entry for it, and if so, create a new entry
2852 and return a pointer to it.
2855 static struct symbol
*
2856 DEFUN(new_symbol
, (dip
), struct dieinfo
*dip
)
2858 struct symbol
*sym
= NULL
;
2860 if (dip
-> at_name
!= NULL
)
2862 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
,
2863 sizeof (struct symbol
));
2864 (void) memset (sym
, 0, sizeof (struct symbol
));
2865 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, symbol_obstack
);
2866 /* default assumptions */
2867 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2868 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2869 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2870 switch (dip
-> dietag
)
2873 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2874 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2876 case TAG_global_subroutine
:
2877 case TAG_subroutine
:
2878 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
+ baseaddr
;
2879 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2880 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2881 if (dip
-> dietag
== TAG_global_subroutine
)
2883 add_symbol_to_list (sym
, &global_symbols
);
2887 add_symbol_to_list (sym
, &scope
-> symbols
);
2890 case TAG_global_variable
:
2891 case TAG_local_variable
:
2892 if (dip
-> at_location
!= NULL
)
2894 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2896 if (dip
-> dietag
== TAG_global_variable
)
2898 add_symbol_to_list (sym
, &global_symbols
);
2899 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2900 SYMBOL_VALUE (sym
) += baseaddr
;
2904 add_symbol_to_list (sym
, &scope
-> symbols
);
2905 if (scope
-> parent
!= NULL
)
2909 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2913 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2918 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2919 SYMBOL_VALUE (sym
) += baseaddr
;
2923 case TAG_formal_parameter
:
2924 if (dip
-> at_location
!= NULL
)
2926 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2928 add_symbol_to_list (sym
, &scope
-> symbols
);
2931 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2935 SYMBOL_CLASS (sym
) = LOC_ARG
;
2938 case TAG_unspecified_parameters
:
2939 /* From varargs functions; gdb doesn't seem to have any interest in
2940 this information, so just ignore it for now. (FIXME?) */
2942 case TAG_structure_type
:
2943 case TAG_union_type
:
2944 case TAG_enumeration_type
:
2945 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2946 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2947 add_symbol_to_list (sym
, &scope
-> symbols
);
2950 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2951 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2952 add_symbol_to_list (sym
, &scope
-> symbols
);
2955 /* Not a tag we recognize. Hopefully we aren't processing trash
2956 data, but since we must specifically ignore things we don't
2957 recognize, there is nothing else we should do at this point. */
2968 decode_mod_fund_type -- decode a modified fundamental type
2972 static struct type *decode_mod_fund_type (char *typedata)
2976 Decode a block of data containing a modified fundamental
2977 type specification. TYPEDATA is a pointer to the block,
2978 which consists of a two byte length, containing the size
2979 of the rest of the block. At the end of the block is a
2980 two byte value that gives the fundamental type. Everything
2981 in between are type modifiers.
2983 We simply compute the number of modifiers and call the general
2984 function decode_modified_type to do the actual work.
2987 static struct type
*
2988 DEFUN(decode_mod_fund_type
, (typedata
), char *typedata
)
2990 struct type
*typep
= NULL
;
2991 unsigned short modcount
;
2992 unsigned char *modifiers
;
2994 /* Get the total size of the block, exclusive of the size itself */
2995 (void) memcpy (&modcount
, typedata
, sizeof (short));
2996 /* Deduct the size of the fundamental type bytes at the end of the block. */
2997 modcount
-= sizeof (short);
2998 /* Skip over the two size bytes at the beginning of the block. */
2999 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3000 /* Now do the actual decoding */
3001 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_fund_type
);
3009 decode_mod_u_d_type -- decode a modified user defined type
3013 static struct type *decode_mod_u_d_type (char *typedata)
3017 Decode a block of data containing a modified user defined
3018 type specification. TYPEDATA is a pointer to the block,
3019 which consists of a two byte length, containing the size
3020 of the rest of the block. At the end of the block is a
3021 four byte value that gives a reference to a user defined type.
3022 Everything in between are type modifiers.
3024 We simply compute the number of modifiers and call the general
3025 function decode_modified_type to do the actual work.
3028 static struct type
*
3029 DEFUN(decode_mod_u_d_type
, (typedata
), char *typedata
)
3031 struct type
*typep
= NULL
;
3032 unsigned short modcount
;
3033 unsigned char *modifiers
;
3035 /* Get the total size of the block, exclusive of the size itself */
3036 (void) memcpy (&modcount
, typedata
, sizeof (short));
3037 /* Deduct the size of the reference type bytes at the end of the block. */
3038 modcount
-= sizeof (long);
3039 /* Skip over the two size bytes at the beginning of the block. */
3040 modifiers
= (unsigned char *) typedata
+ sizeof (short);
3041 /* Now do the actual decoding */
3042 typep
= decode_modified_type (modifiers
, modcount
, AT_mod_u_d_type
);
3050 decode_modified_type -- decode modified user or fundamental type
3054 static struct type *decode_modified_type (unsigned char *modifiers,
3055 unsigned short modcount, int mtype)
3059 Decode a modified type, either a modified fundamental type or
3060 a modified user defined type. MODIFIERS is a pointer to the
3061 block of bytes that define MODCOUNT modifiers. Immediately
3062 following the last modifier is a short containing the fundamental
3063 type or a long containing the reference to the user defined
3064 type. Which one is determined by MTYPE, which is either
3065 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3066 type we are generating.
3068 We call ourself recursively to generate each modified type,`
3069 until MODCOUNT reaches zero, at which point we have consumed
3070 all the modifiers and generate either the fundamental type or
3071 user defined type. When the recursion unwinds, each modifier
3072 is applied in turn to generate the full modified type.
3076 If we find a modifier that we don't recognize, and it is not one
3077 of those reserved for application specific use, then we issue a
3078 warning and simply ignore the modifier.
3082 We currently ignore MOD_const and MOD_volatile. (FIXME)
3086 static struct type
*
3087 DEFUN(decode_modified_type
,
3088 (modifiers
, modcount
, mtype
),
3089 unsigned char *modifiers AND
unsigned short modcount AND
int mtype
)
3091 struct type
*typep
= NULL
;
3092 unsigned short fundtype
;
3094 unsigned char modifier
;
3100 case AT_mod_fund_type
:
3101 (void) memcpy (&fundtype
, modifiers
, sizeof (short));
3102 typep
= decode_fund_type (fundtype
);
3104 case AT_mod_u_d_type
:
3105 (void) memcpy (&dieref
, modifiers
, sizeof (DIEREF
));
3106 if ((typep
= lookup_utype (dieref
)) == NULL
)
3108 typep
= alloc_utype (dieref
, NULL
);
3112 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3113 typep
= builtin_type_int
;
3119 modifier
= *modifiers
++;
3120 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3123 case MOD_pointer_to
:
3124 typep
= lookup_pointer_type (typep
);
3126 case MOD_reference_to
:
3127 typep
= lookup_reference_type (typep
);
3130 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3133 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3136 if (!(MOD_lo_user
<= modifier
&& modifier
<= MOD_hi_user
))
3138 SQUAWK (("unknown type modifier %u", modifier
));
3150 decode_fund_type -- translate basic DWARF type to gdb base type
3154 Given an integer that is one of the fundamental DWARF types,
3155 translate it to one of the basic internal gdb types and return
3156 a pointer to the appropriate gdb type (a "struct type *").
3160 If we encounter a fundamental type that we are unprepared to
3161 deal with, and it is not in the range of those types defined
3162 as application specific types, then we issue a warning and
3163 treat the type as builtin_type_int.
3166 static struct type
*
3167 DEFUN(decode_fund_type
, (fundtype
), unsigned short fundtype
)
3169 struct type
*typep
= NULL
;
3175 typep
= builtin_type_void
;
3178 case FT_pointer
: /* (void *) */
3179 typep
= lookup_pointer_type (builtin_type_void
);
3183 case FT_signed_char
:
3184 typep
= builtin_type_char
;
3188 case FT_signed_short
:
3189 typep
= builtin_type_short
;
3193 case FT_signed_integer
:
3194 case FT_boolean
: /* Was FT_set in AT&T version */
3195 typep
= builtin_type_int
;
3199 case FT_signed_long
:
3200 typep
= builtin_type_long
;
3204 typep
= builtin_type_float
;
3207 case FT_dbl_prec_float
:
3208 typep
= builtin_type_double
;
3211 case FT_unsigned_char
:
3212 typep
= builtin_type_unsigned_char
;
3215 case FT_unsigned_short
:
3216 typep
= builtin_type_unsigned_short
;
3219 case FT_unsigned_integer
:
3220 typep
= builtin_type_unsigned_int
;
3223 case FT_unsigned_long
:
3224 typep
= builtin_type_unsigned_long
;
3227 case FT_ext_prec_float
:
3228 typep
= builtin_type_long_double
;
3232 typep
= builtin_type_complex
;
3235 case FT_dbl_prec_complex
:
3236 typep
= builtin_type_double_complex
;
3240 case FT_signed_long_long
:
3241 typep
= builtin_type_long_long
;
3244 case FT_unsigned_long_long
:
3245 typep
= builtin_type_unsigned_long_long
;
3250 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3252 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3253 typep
= builtin_type_void
;
3263 create_name -- allocate a fresh copy of a string on an obstack
3267 Given a pointer to a string and a pointer to an obstack, allocates
3268 a fresh copy of the string on the specified obstack.
3273 DEFUN(create_name
, (name
, obstackp
), char *name AND
struct obstack
*obstackp
)
3278 length
= strlen (name
) + 1;
3279 newname
= (char *) obstack_alloc (obstackp
, length
);
3280 (void) strcpy (newname
, name
);
3288 basicdieinfo -- extract the minimal die info from raw die data
3292 void basicdieinfo (char *diep, struct dieinfo *dip)
3296 Given a pointer to raw DIE data, and a pointer to an instance of a
3297 die info structure, this function extracts the basic information
3298 from the DIE data required to continue processing this DIE, along
3299 with some bookkeeping information about the DIE.
3301 The information we absolutely must have includes the DIE tag,
3302 and the DIE length. If we need the sibling reference, then we
3303 will have to call completedieinfo() to process all the remaining
3306 Note that since there is no guarantee that the data is properly
3307 aligned in memory for the type of access required (indirection
3308 through anything other than a char pointer), we use memcpy to
3309 shuffle data items larger than a char. Possibly inefficient, but
3312 We also take care of some other basic things at this point, such
3313 as ensuring that the instance of the die info structure starts
3314 out completely zero'd and that curdie is initialized for use
3315 in error reporting if we have a problem with the current die.
3319 All DIE's must have at least a valid length, thus the minimum
3320 DIE size is sizeof (long). In order to have a valid tag, the
3321 DIE size must be at least sizeof (short) larger, otherwise they
3322 are forced to be TAG_padding DIES.
3324 Padding DIES must be at least sizeof(long) in length, implying that
3325 if a padding DIE is used for alignment and the amount needed is less
3326 than sizeof(long) then the padding DIE has to be big enough to align
3327 to the next alignment boundry.
3331 DEFUN(basicdieinfo
, (dip
, diep
), struct dieinfo
*dip AND
char *diep
)
3334 (void) memset (dip
, 0, sizeof (struct dieinfo
));
3336 dip
-> dieref
= dbroff
+ (diep
- dbbase
);
3337 (void) memcpy (&dip
-> dielength
, diep
, sizeof (long));
3338 if (dip
-> dielength
< sizeof (long))
3340 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> dielength
);
3342 else if (dip
-> dielength
< (sizeof (long) + sizeof (short)))
3344 dip
-> dietag
= TAG_padding
;
3348 (void) memcpy (&dip
-> dietag
, diep
+ sizeof (long), sizeof (short));
3356 completedieinfo -- finish reading the information for a given DIE
3360 void completedieinfo (struct dieinfo *dip)
3364 Given a pointer to an already partially initialized die info structure,
3365 scan the raw DIE data and finish filling in the die info structure
3366 from the various attributes found.
3368 Note that since there is no guarantee that the data is properly
3369 aligned in memory for the type of access required (indirection
3370 through anything other than a char pointer), we use memcpy to
3371 shuffle data items larger than a char. Possibly inefficient, but
3376 Each time we are called, we increment the diecount variable, which
3377 keeps an approximate count of the number of dies processed for
3378 each compilation unit. This information is presented to the user
3379 if the info_verbose flag is set.
3384 DEFUN(completedieinfo
, (dip
), struct dieinfo
*dip
)
3386 char *diep
; /* Current pointer into raw DIE data */
3387 char *end
; /* Terminate DIE scan here */
3388 unsigned short attr
; /* Current attribute being scanned */
3389 unsigned short form
; /* Form of the attribute */
3390 short block2sz
; /* Size of a block2 attribute field */
3391 long block4sz
; /* Size of a block4 attribute field */
3395 end
= diep
+ dip
-> dielength
;
3396 diep
+= sizeof (long) + sizeof (short);
3399 (void) memcpy (&attr
, diep
, sizeof (short));
3400 diep
+= sizeof (short);
3404 (void) memcpy (&dip
-> at_fund_type
, diep
, sizeof (short));
3407 (void) memcpy (&dip
-> at_ordering
, diep
, sizeof (short));
3410 (void) memcpy (&dip
-> at_bit_offset
, diep
, sizeof (short));
3413 (void) memcpy (&dip
-> at_visibility
, diep
, sizeof (short));
3416 (void) memcpy (&dip
-> at_sibling
, diep
, sizeof (long));
3419 (void) memcpy (&dip
-> at_stmt_list
, diep
, sizeof (long));
3420 dip
-> at_stmt_list_p
= 1;
3423 (void) memcpy (&dip
-> at_low_pc
, diep
, sizeof (long));
3426 (void) memcpy (&dip
-> at_high_pc
, diep
, sizeof (long));
3429 (void) memcpy (&dip
-> at_language
, diep
, sizeof (long));
3431 case AT_user_def_type
:
3432 (void) memcpy (&dip
-> at_user_def_type
, diep
, sizeof (long));
3435 (void) memcpy (&dip
-> at_byte_size
, diep
, sizeof (long));
3438 (void) memcpy (&dip
-> at_bit_size
, diep
, sizeof (long));
3441 (void) memcpy (&dip
-> at_member
, diep
, sizeof (long));
3444 (void) memcpy (&dip
-> at_discr
, diep
, sizeof (long));
3447 (void) memcpy (&dip
-> at_import
, diep
, sizeof (long));
3450 dip
-> at_location
= diep
;
3452 case AT_mod_fund_type
:
3453 dip
-> at_mod_fund_type
= diep
;
3455 case AT_subscr_data
:
3456 dip
-> at_subscr_data
= diep
;
3458 case AT_mod_u_d_type
:
3459 dip
-> at_mod_u_d_type
= diep
;
3462 dip
-> at_deriv_list
= diep
;
3464 case AT_element_list
:
3465 dip
-> at_element_list
= diep
;
3467 case AT_discr_value
:
3468 dip
-> at_discr_value
= diep
;
3470 case AT_string_length
:
3471 dip
-> at_string_length
= diep
;
3474 dip
-> at_name
= diep
;
3477 dip
-> at_comp_dir
= diep
;
3480 dip
-> at_producer
= diep
;
3483 (void) memcpy (&dip
-> at_loclist
, diep
, sizeof (long));
3486 (void) memcpy (&dip
-> at_frame_base
, diep
, sizeof (long));
3489 (void) memcpy (&dip
-> at_incomplete
, diep
, sizeof (short));
3491 case AT_start_scope
:
3492 (void) memcpy (&dip
-> at_start_scope
, diep
, sizeof (long));
3494 case AT_stride_size
:
3495 (void) memcpy (&dip
-> at_stride_size
, diep
, sizeof (long));
3498 (void) memcpy (&dip
-> at_src_info
, diep
, sizeof (long));
3501 (void) memcpy (&dip
-> at_prototyped
, diep
, sizeof (short));
3504 dip
-> at_const_data
= diep
;
3506 case AT_is_external
:
3507 (void) memcpy (&dip
-> at_is_external
, diep
, sizeof (short));
3508 dip
-> at_is_external_p
= 1;
3511 /* Found an attribute that we are unprepared to handle. However
3512 it is specifically one of the design goals of DWARF that
3513 consumers should ignore unknown attributes. As long as the
3514 form is one that we recognize (so we know how to skip it),
3515 we can just ignore the unknown attribute. */
3522 diep
+= sizeof (short);
3525 diep
+= sizeof (long);
3528 diep
+= 8 * sizeof (char); /* sizeof (long long) ? */
3532 diep
+= sizeof (long);
3535 (void) memcpy (&block2sz
, diep
, sizeof (short));
3536 block2sz
+= sizeof (short);
3540 (void) memcpy (&block4sz
, diep
, sizeof (long));
3541 block4sz
+= sizeof (long);
3545 diep
+= strlen (diep
) + 1;
3548 SQUAWK (("unknown attribute form (0x%x), skipped rest", form
));