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;
902 TYPE_CPLUS_SPECIFIC (type)
903 = (struct cplus_struct_type *) obstack_alloc (symbol_obstack, sizeof (struct cplus_struct_type));
904 bzero (TYPE_CPLUS_SPECIFIC (type), sizeof (struct cplus_struct_type));
908 TYPE_CODE (type) = TYPE_CODE_UNION;
913 SQUAWK (("missing structure or union tag"));
914 TYPE_CODE (type) = TYPE_CODE_UNDEF;
917 if (dip -> at_name == NULL)
923 tpart2 = dip -> at_name;
925 if (dip -> at_byte_size == 0)
927 tpart3 = " <opaque>";
929 TYPE_LENGTH (type) = dip -> at_byte_size;
932 TYPE_NAME (type) = concat (tpart1, tpart2, tpart3, NULL);
933 thisdie += dip -> dielength;
934 while (thisdie < enddie)
936 basicdieinfo (&mbr, thisdie);
937 completedieinfo (&mbr);
938 if (mbr.dielength <= sizeof (long))
945 /* Get space to record the next field's data. */
946 new = (struct nextfield *) alloca (sizeof (struct nextfield));
950 list -> field.name = savestring (mbr.at_name, strlen (mbr.at_name));
951 list -> field.type = decode_die_type (&mbr);
952 list -> field.bitpos = 8 * locval (mbr.at_location);
953 list -> field.bitsize = 0;
957 SQUAWK (("bad member of '%s'", TYPE_NAME (type)));
960 thisdie += mbr.dielength;
962 /* Now create the vector of fields, and record how big it is. */
963 TYPE_NFIELDS (type) = nfields;
964 TYPE_FIELDS (type) = (struct field *)
965 obstack_alloc (symbol_obstack, sizeof (struct field) * nfields);
966 /* Copy the saved-up fields into the field vector. */
967 for (n = nfields; list; list = list -> next)
969 TYPE_FIELD (type, --n) = list -> field;
978 read_structure_scope -- process all dies within struct or union
982 static void read_structure_scope (struct dieinfo *dip,
983 char *thisdie, char *enddie)
987 Called when we find the DIE that starts a structure or union
988 scope (definition) to process all dies that define the members
989 of the structure or union. DIP is a pointer to the die info
990 struct for the DIE that names the structure or union.
994 Note that we need to call struct_type regardless of whether or not
995 we have a symbol, since we might have a structure or union without
996 a tag name (thus no symbol for the tagname).
1000 DEFUN(read_structure_scope, (dip, thisdie, enddie),
1001 struct dieinfo *dip AND
1008 type = struct_type (dip, thisdie, enddie);
1009 if ((sym = new_symbol (dip)) != NULL)
1011 SYMBOL_TYPE (sym) = type;
1019 decode_array_element_type -- decode type of the array elements
1023 static struct type *decode_array_element_type (char *scan, char *end)
1027 As the last step in decoding the array subscript information for an
1028 array DIE, we need to decode the type of the array elements. We are
1029 passed a pointer to this last part of the subscript information and
1030 must return the appropriate type. If the type attribute is not
1031 recognized, just warn about the problem and return type int.
1034 static struct type *
1035 DEFUN(decode_array_element_type, (scan, end), char *scan AND char *end)
1040 unsigned short fundtype;
1042 (void) memcpy (&attribute, scan, sizeof (short));
1043 scan += sizeof (short);
1047 (void) memcpy (&fundtype, scan, sizeof (short));
1048 typep = decode_fund_type (fundtype);
1050 case AT_mod_fund_type:
1051 typep = decode_mod_fund_type (scan);
1053 case AT_user_def_type:
1054 (void) memcpy (&dieref, scan, sizeof (DIEREF));
1055 if ((typep = lookup_utype (dieref)) == NULL)
1057 typep = alloc_utype (dieref, NULL);
1060 case AT_mod_u_d_type:
1061 typep = decode_mod_u_d_type (scan);
1064 SQUAWK (("bad array element type attribute 0x%x", attribute));
1065 typep = builtin_type_int;
1075 decode_subscr_data -- decode array subscript and element type data
1079 static struct type *decode_subscr_data (char *scan, char *end)
1083 The array subscripts and the data type of the elements of an
1084 array are described by a list of data items, stored as a block
1085 of contiguous bytes. There is a data item describing each array
1086 dimension, and a final data item describing the element type.
1087 The data items are ordered the same as their appearance in the
1088 source (I.E. leftmost dimension first, next to leftmost second,
1091 We are passed a pointer to the start of the block of bytes
1092 containing the data items, and a pointer to the first byte past
1093 the data. This function decodes the data and returns a type.
1096 FIXME: This code only implements the forms currently used
1097 by the AT&T and GNU C compilers.
1099 The end pointer is supplied for error checking, maybe we should
1103 static struct type *
1104 DEFUN(decode_subscr_data, (scan, end), char *scan AND char *end)
1106 struct type *typep = NULL;
1107 struct type *nexttype;
1117 typep = decode_array_element_type (scan, end);
1120 (void) memcpy (&fundtype, scan, sizeof (short));
1121 scan += sizeof (short);
1122 if (fundtype != FT_integer && fundtype != FT_signed_integer
1123 && fundtype != FT_unsigned_integer)
1125 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1130 (void) memcpy (&lowbound, scan, sizeof (long));
1131 scan += sizeof (long);
1132 (void) memcpy (&highbound, scan, sizeof (long));
1133 scan += sizeof (long);
1134 nexttype = decode_subscr_data (scan, end);
1135 if (nexttype != NULL)
1137 typep = (struct type *)
1138 obstack_alloc (symbol_obstack, sizeof (struct type));
1139 (void) memset (typep, 0, sizeof (struct type));
1140 TYPE_CODE (typep) = TYPE_CODE_ARRAY;
1141 TYPE_LENGTH (typep) = TYPE_LENGTH (nexttype);
1142 TYPE_LENGTH (typep) *= lowbound + highbound + 1;
1143 TYPE_TARGET_TYPE (typep) = nexttype;
1154 SQUAWK (("array subscript format 0x%x not handled yet", format));
1157 SQUAWK (("unknown array subscript format %x", format));
1167 read_array_type -- read TAG_array_type DIE
1171 static void read_array_type (struct dieinfo *dip)
1175 Extract all information from a TAG_array_type DIE and add to
1176 the user defined type vector.
1180 DEFUN(read_array_type, (dip), struct dieinfo *dip)
1187 if (dip -> at_ordering != ORD_row_major)
1189 /* FIXME: Can gdb even handle column major arrays? */
1190 SQUAWK (("array not row major; not handled correctly"));
1192 if ((sub = dip -> at_subscr_data) != NULL)
1194 (void) memcpy (&temp, sub, sizeof (short));
1195 subend = sub + sizeof (short) + temp;
1196 sub += sizeof (short);
1197 type = decode_subscr_data (sub, subend);
1200 type = alloc_utype (dip -> dieref, NULL);
1201 TYPE_CODE (type) = TYPE_CODE_ARRAY;
1202 TYPE_TARGET_TYPE (type) = builtin_type_int;
1203 TYPE_LENGTH (type) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (type));
1207 type = alloc_utype (dip -> dieref, type);
1216 read_subroutine_type -- process TAG_subroutine_type dies
1220 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1225 Handle DIES due to C code like:
1228 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1234 The parameter DIES are currently ignored. See if gdb has a way to
1235 include this info in it's type system, and decode them if so. Is
1236 this what the type structure's "arg_types" field is for? (FIXME)
1240 DEFUN(read_subroutine_type, (dip, thisdie, enddie),
1241 struct dieinfo *dip AND
1247 type = decode_die_type (dip);
1248 type = lookup_function_type (type);
1249 type = alloc_utype (dip -> dieref, type);
1256 read_enumeration -- process dies which define an enumeration
1260 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1265 Given a pointer to a die which begins an enumeration, process all
1266 the dies that define the members of the enumeration.
1270 Note that we need to call enum_type regardless of whether or not we
1271 have a symbol, since we might have an enum without a tag name (thus
1272 no symbol for the tagname).
1276 DEFUN(read_enumeration, (dip, thisdie, enddie),
1277 struct dieinfo *dip AND
1284 type = enum_type (dip);
1285 if ((sym = new_symbol (dip)) != NULL)
1287 SYMBOL_TYPE (sym) = type;
1295 enum_type -- decode and return a type for an enumeration
1299 static type *enum_type (struct dieinfo *dip)
1303 Given a pointer to a die information structure for the die which
1304 starts an enumeration, process all the dies that define the members
1305 of the enumeration and return a type pointer for the enumeration.
1308 static struct type *
1309 DEFUN(enum_type, (dip), struct dieinfo *dip)
1313 struct nextfield *next;
1316 struct nextfield *list = NULL;
1317 struct nextfield *new;
1327 if ((type = lookup_utype (dip -> dieref)) == NULL)
1329 type = alloc_utype (dip -> dieref, NULL);
1331 TYPE_CODE (type) = TYPE_CODE_ENUM;
1333 if (dip -> at_name == NULL)
1337 tpart2 = dip -> at_name;
1339 if (dip -> at_byte_size == 0)
1341 tpart3 = " <opaque>";
1345 TYPE_LENGTH (type) = dip -> at_byte_size;
1348 TYPE_NAME (type) = concat (tpart1, tpart2, tpart3, NULL);
1349 if ((scan = dip -> at_element_list) != NULL)
1351 (void) memcpy (&temp, scan, sizeof (temp));
1352 listend = scan + temp + sizeof (temp);
1353 scan += sizeof (temp);
1354 while (scan < listend)
1356 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1359 list -> field.type = NULL;
1360 list -> field.bitsize = 0;
1361 (void) memcpy (&list -> field.bitpos, scan, sizeof (long));
1362 scan += sizeof (long);
1363 list -> field.name = savestring (scan, strlen (scan));
1364 scan += strlen (scan) + 1;
1368 /* Now create the vector of fields, and record how big it is. */
1369 TYPE_NFIELDS (type) = nfields;
1370 TYPE_FIELDS (type) = (struct field *)
1371 obstack_alloc (symbol_obstack, sizeof (struct field) * nfields);
1372 /* Copy the saved-up fields into the field vector. */
1373 for (n = nfields; list; list = list -> next)
1375 TYPE_FIELD (type, --n) = list -> field;
1384 read_func_scope -- process all dies within a function scope
1388 Process all dies within a given function scope. We are passed
1389 a die information structure pointer DIP for the die which
1390 starts the function scope, and pointers into the raw die data
1391 that define the dies within the function scope.
1393 For now, we ignore lexical block scopes within the function.
1394 The problem is that AT&T cc does not define a DWARF lexical
1395 block scope for the function itself, while gcc defines a
1396 lexical block scope for the function. We need to think about
1397 how to handle this difference, or if it is even a problem.
1402 DEFUN(read_func_scope, (dip, thisdie, enddie, objfile),
1403 struct dieinfo *dip AND
1406 struct objfile *objfile)
1410 if (entry_point >= dip -> at_low_pc && entry_point < dip -> at_high_pc)
1412 entry_scope_lowpc = dip -> at_low_pc;
1413 entry_scope_highpc = dip -> at_high_pc;
1415 if (strcmp (dip -> at_name, "main") == 0) /* FIXME: hardwired name */
1417 main_scope_lowpc = dip -> at_low_pc;
1418 main_scope_highpc = dip -> at_high_pc;
1420 sym = new_symbol (dip);
1421 openscope (sym, dip -> at_low_pc, dip -> at_high_pc);
1422 process_dies (thisdie + dip -> dielength, enddie, objfile);
1430 read_file_scope -- process all dies within a file scope
1434 Process all dies within a given file scope. We are passed a
1435 pointer to the die information structure for the die which
1436 starts the file scope, and pointers into the raw die data which
1437 mark the range of dies within the file scope.
1439 When the partial symbol table is built, the file offset for the line
1440 number table for each compilation unit is saved in the partial symbol
1441 table entry for that compilation unit. As the symbols for each
1442 compilation unit are read, the line number table is read into memory
1443 and the variable lnbase is set to point to it. Thus all we have to
1444 do is use lnbase to access the line number table for the current
1449 DEFUN(read_file_scope, (dip, thisdie, enddie, objfile),
1450 struct dieinfo *dip AND
1453 struct objfile *objfile)
1455 struct cleanup *back_to;
1457 if (entry_point >= dip -> at_low_pc && entry_point < dip -> at_high_pc)
1459 startup_file_start = dip -> at_low_pc;
1460 startup_file_end = dip -> at_high_pc;
1462 numutypes = (enddie - thisdie) / 4;
1463 utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
1464 back_to = make_cleanup (free, utypes);
1465 (void) memset (utypes, 0, numutypes * sizeof (struct type *));
1467 openscope (NULL, dip -> at_low_pc, dip -> at_high_pc);
1468 decode_line_numbers (lnbase);
1469 process_dies (thisdie + dip -> dielength, enddie, objfile);
1471 end_symtab (dip -> at_name, dip -> at_language, objfile);
1472 do_cleanups (back_to);
1481 start_symtab -- do initialization for starting new symbol table
1485 static void start_symtab (void)
1489 Called whenever we are starting to process dies for a new
1490 compilation unit, to perform initializations. Right now
1491 the only thing we really have to do is initialize storage
1492 space for the line number vector.
1497 DEFUN_VOID (start_symtab)
1501 line_vector_index = 0;
1502 line_vector_length = 1000;
1503 nbytes = sizeof (struct linetable);
1504 nbytes += line_vector_length * sizeof (struct linetable_entry);
1505 line_vector = (struct linetable *) xmalloc (nbytes);
1512 process_dies -- process a range of DWARF Information Entries
1516 static void process_dies (char *thisdie, char *enddie)
1520 Process all DIE's in a specified range. May be (and almost
1521 certainly will be) called recursively.
1525 DEFUN(process_dies, (thisdie, enddie, objfile),
1526 char *thisdie AND char *enddie AND struct objfile *objfile)
1531 while (thisdie < enddie)
1533 basicdieinfo (&di, thisdie);
1534 if (di.dielength < sizeof (long))
1538 else if (di.dietag == TAG_padding)
1540 nextdie = thisdie + di.dielength;
1544 completedieinfo (&di);
1545 if (di.at_sibling != 0)
1547 nextdie = dbbase + di.at_sibling - dbroff;
1551 nextdie = thisdie + di.dielength;
1555 case TAG_compile_unit:
1556 read_file_scope (&di, thisdie, nextdie, objfile);
1558 case TAG_global_subroutine:
1559 case TAG_subroutine:
1560 if (!di.at_is_external_p)
1562 read_func_scope (&di, thisdie, nextdie, objfile);
1565 case TAG_lexical_block:
1566 read_lexical_block_scope (&di, thisdie, nextdie, objfile);
1568 case TAG_structure_type:
1569 case TAG_union_type:
1570 read_structure_scope (&di, thisdie, nextdie);
1572 case TAG_enumeration_type:
1573 read_enumeration (&di, thisdie, nextdie);
1575 case TAG_subroutine_type:
1576 read_subroutine_type (&di, thisdie, nextdie);
1578 case TAG_array_type:
1579 read_array_type (&di);
1582 (void) new_symbol (&di);
1594 end_symtab -- finish processing for a compilation unit
1598 static void end_symtab (char *filename, long language)
1602 Complete the symbol table entry for the current compilation
1603 unit. Make the struct symtab and put it on the list of all
1609 DEFUN(end_symtab, (filename, language, objfile),
1610 char *filename AND long language AND struct objfile *objfile)
1612 struct symtab *symtab;
1613 struct blockvector *blockvector;
1616 /* Ignore a file that has no functions with real debugging info. */
1617 if (global_symbols == NULL && scopetree -> block == NULL)
1621 line_vector_length = -1;
1622 freescope (scopetree);
1623 scope = scopetree = NULL;
1626 /* Create the blockvector that points to all the file's blocks. */
1628 blockvector = make_blockvector ();
1630 /* Now create the symtab object for this source file. */
1632 symtab = allocate_symtab (savestring (filename, strlen (filename)),
1635 symtab -> free_ptr = 0;
1637 /* Fill in its components. */
1638 symtab -> blockvector = blockvector;
1639 symtab -> free_code = free_linetable;
1641 /* Save the line number information. */
1643 line_vector -> nitems = line_vector_index;
1644 nbytes = sizeof (struct linetable);
1645 if (line_vector_index > 1)
1647 nbytes += (line_vector_index - 1) * sizeof (struct linetable_entry);
1649 symtab -> linetable = (struct linetable *) xrealloc (line_vector, nbytes);
1651 /* FIXME: The following may need to be expanded for other languages */
1656 symtab -> language = language_c;
1658 case LANG_C_PLUS_PLUS:
1659 symtab -> language = language_cplus;
1665 /* Link the new symtab into the list of such. */
1666 symtab -> next = symtab_list;
1667 symtab_list = symtab;
1669 /* Recursively free the scope tree */
1670 freescope (scopetree);
1671 scope = scopetree = NULL;
1673 /* Reinitialize for beginning of new file. */
1675 line_vector_length = -1;
1682 scopecount -- count the number of enclosed scopes
1686 static int scopecount (struct scopenode *node)
1690 Given pointer to a node, compute the size of the subtree which is
1691 rooted in this node, which also happens to be the number of scopes
1696 DEFUN(scopecount, (node), struct scopenode *node)
1702 count += scopecount (node -> child);
1703 count += scopecount (node -> sibling);
1713 openscope -- start a new lexical block scope
1717 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1722 Start a new scope by allocating a new scopenode, adding it as the
1723 next child of the current scope (if any) or as the root of the
1724 scope tree, and then making the new node the current scope node.
1728 DEFUN(openscope, (namesym, lowpc, highpc),
1729 struct symbol *namesym AND
1733 struct scopenode *new;
1734 struct scopenode *child;
1736 new = (struct scopenode *) xmalloc (sizeof (*new));
1737 (void) memset (new, 0, sizeof (*new));
1738 new -> namesym = namesym;
1739 new -> lowpc = lowpc;
1740 new -> highpc = highpc;
1745 else if ((child = scope -> child) == NULL)
1747 scope -> child = new;
1748 new -> parent = scope;
1752 while (child -> sibling != NULL)
1754 child = child -> sibling;
1756 child -> sibling = new;
1757 new -> parent = scope;
1766 freescope -- free a scope tree rooted at the given node
1770 static void freescope (struct scopenode *node)
1774 Given a pointer to a node in the scope tree, free the subtree
1775 rooted at that node. First free all the children and sibling
1776 nodes, and then the node itself. Used primarily for cleaning
1777 up after ourselves and returning memory to the system.
1781 DEFUN(freescope, (node), struct scopenode *node)
1785 freescope (node -> child);
1786 freescope (node -> sibling);
1795 buildblock -- build a new block from pending symbols list
1799 static struct block *buildblock (struct pending_symbol *syms)
1803 Given a pointer to a list of symbols, build a new block and free
1804 the symbol list structure. Also check each symbol to see if it
1805 is the special symbol that flags that this block was compiled by
1806 gcc, and if so, mark the block appropriately.
1809 static struct block *
1810 DEFUN(buildblock, (syms), struct pending_symbol *syms)
1812 struct pending_symbol *next, *next1;
1814 struct block *newblock;
1817 for (next = syms, i = 0 ; next ; next = next -> next, i++) {;}
1819 /* Allocate a new block */
1821 nbytes = sizeof (struct block);
1824 nbytes += (i - 1) * sizeof (struct symbol *);
1826 newblock = (struct block *) obstack_alloc (symbol_obstack, nbytes);
1827 (void) memset (newblock, 0, nbytes);
1829 /* Copy the symbols into the block. */
1831 BLOCK_NSYMS (newblock) = i;
1832 for (next = syms ; next ; next = next -> next)
1834 BLOCK_SYM (newblock, --i) = next -> symbol;
1835 if (STREQ (GCC_COMPILED_FLAG_SYMBOL, SYMBOL_NAME (next -> symbol)) ||
1836 STREQ (GCC2_COMPILED_FLAG_SYMBOL, SYMBOL_NAME (next -> symbol)))
1838 BLOCK_GCC_COMPILED (newblock) = 1;
1842 /* Now free the links of the list, and empty the list. */
1844 for (next = syms ; next ; next = next1)
1846 next1 = next -> next;
1857 closescope -- close a lexical block scope
1861 static void closescope (void)
1865 Close the current lexical block scope. Closing the current scope
1866 is as simple as moving the current scope pointer up to the parent
1867 of the current scope pointer. But we also take this opportunity
1868 to build the block for the current scope first, since we now have
1869 all of it's symbols.
1873 DEFUN_VOID(closescope)
1875 struct scopenode *child;
1879 error ("DWARF parse error, too many close scopes");
1883 if (scope -> parent == NULL)
1885 global_symbol_block = buildblock (global_symbols);
1886 global_symbols = NULL;
1887 BLOCK_START (global_symbol_block) = scope -> lowpc + baseaddr;
1888 BLOCK_END (global_symbol_block) = scope -> highpc + baseaddr;
1890 scope -> block = buildblock (scope -> symbols);
1891 scope -> symbols = NULL;
1892 BLOCK_START (scope -> block) = scope -> lowpc + baseaddr;
1893 BLOCK_END (scope -> block) = scope -> highpc + baseaddr;
1895 /* Put the local block in as the value of the symbol that names it. */
1897 if (scope -> namesym)
1899 SYMBOL_BLOCK_VALUE (scope -> namesym) = scope -> block;
1900 BLOCK_FUNCTION (scope -> block) = scope -> namesym;
1903 /* Install this scope's local block as the superblock of all child
1906 for (child = scope -> child ; child ; child = child -> sibling)
1908 BLOCK_SUPERBLOCK (child -> block) = scope -> block;
1911 scope = scope -> parent;
1919 record_line -- record a line number entry in the line vector
1923 static void record_line (int line, CORE_ADDR pc)
1927 Given a line number and the corresponding pc value, record
1928 this pair in the line number vector, expanding the vector as
1933 DEFUN(record_line, (line, pc), int line AND CORE_ADDR pc)
1935 struct linetable_entry *e;
1938 /* Make sure line vector is big enough. */
1940 if (line_vector_index + 2 >= line_vector_length)
1942 line_vector_length *= 2;
1943 nbytes = sizeof (struct linetable);
1944 nbytes += (line_vector_length * sizeof (struct linetable_entry));
1945 line_vector = (struct linetable *) xrealloc (line_vector, nbytes);
1947 e = line_vector -> item + line_vector_index++;
1956 decode_line_numbers -- decode a line number table fragment
1960 static void decode_line_numbers (char *tblscan, char *tblend,
1961 long length, long base, long line, long pc)
1965 Translate the DWARF line number information to gdb form.
1967 The ".line" section contains one or more line number tables, one for
1968 each ".line" section from the objects that were linked.
1970 The AT_stmt_list attribute for each TAG_source_file entry in the
1971 ".debug" section contains the offset into the ".line" section for the
1972 start of the table for that file.
1974 The table itself has the following structure:
1976 <table length><base address><source statement entry>
1977 4 bytes 4 bytes 10 bytes
1979 The table length is the total size of the table, including the 4 bytes
1980 for the length information.
1982 The base address is the address of the first instruction generated
1983 for the source file.
1985 Each source statement entry has the following structure:
1987 <line number><statement position><address delta>
1988 4 bytes 2 bytes 4 bytes
1990 The line number is relative to the start of the file, starting with
1993 The statement position either -1 (0xFFFF) or the number of characters
1994 from the beginning of the line to the beginning of the statement.
1996 The address delta is the difference between the base address and
1997 the address of the first instruction for the statement.
1999 Note that we must copy the bytes from the packed table to our local
2000 variables before attempting to use them, to avoid alignment problems
2001 on some machines, particularly RISC processors.
2005 Does gdb expect the line numbers to be sorted? They are now by
2006 chance/luck, but are not required to be. (FIXME)
2008 The line with number 0 is unused, gdb apparently can discover the
2009 span of the last line some other way. How? (FIXME)
2013 DEFUN(decode_line_numbers, (linetable), char *linetable)
2022 if (linetable != NULL)
2024 tblscan = tblend = linetable;
2025 (void) memcpy (&length, tblscan, sizeof (long));
2026 tblscan += sizeof (long);
2028 (void) memcpy (&base, tblscan, sizeof (long));
2030 tblscan += sizeof (long);
2031 while (tblscan < tblend)
2033 (void) memcpy (&line, tblscan, sizeof (long));
2034 tblscan += sizeof (long) + sizeof (short);
2035 (void) memcpy (&pc, tblscan, sizeof (long));
2036 tblscan += sizeof (long);
2040 record_line (line, pc);
2050 add_symbol_to_list -- add a symbol to head of current symbol list
2054 static void add_symbol_to_list (struct symbol *symbol, struct
2055 pending_symbol **listhead)
2059 Given a pointer to a symbol and a pointer to a pointer to a
2060 list of symbols, add this symbol as the current head of the
2061 list. Typically used for example to add a symbol to the
2062 symbol list for the current scope.
2067 DEFUN(add_symbol_to_list, (symbol, listhead),
2068 struct symbol *symbol AND struct pending_symbol **listhead)
2070 struct pending_symbol *link;
2074 link = (struct pending_symbol *) xmalloc (sizeof (*link));
2075 link -> next = *listhead;
2076 link -> symbol = symbol;
2085 gatherblocks -- walk a scope tree and build block vectors
2089 static struct block **gatherblocks (struct block **dest,
2090 struct scopenode *node)
2094 Recursively walk a scope tree rooted in the given node, adding blocks
2095 to the array pointed to by DEST, in preorder. I.E., first we add the
2096 block for the current scope, then all the blocks for child scopes,
2097 and finally all the blocks for sibling scopes.
2100 static struct block **
2101 DEFUN(gatherblocks, (dest, node),
2102 struct block **dest AND struct scopenode *node)
2106 *dest++ = node -> block;
2107 dest = gatherblocks (dest, node -> child);
2108 dest = gatherblocks (dest, node -> sibling);
2117 make_blockvector -- make a block vector from current scope tree
2121 static struct blockvector *make_blockvector (void)
2125 Make a blockvector from all the blocks in the current scope tree.
2126 The first block is always the global symbol block, followed by the
2127 block for the root of the scope tree which is the local symbol block,
2128 followed by all the remaining blocks in the scope tree, which are all
2133 Note that since the root node of the scope tree is created at the time
2134 each file scope is entered, there are always at least two blocks,
2135 neither of which may have any symbols, but always contribute a block
2136 to the block vector. So the test for number of blocks greater than 1
2137 below is unnecessary given bug free code.
2139 The resulting block structure varies slightly from that produced
2140 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2141 with dbxread.c, block 1 is a child of block 0. This does not
2142 seem to cause any problems, but probably should be fixed. (FIXME)
2145 static struct blockvector *
2146 DEFUN_VOID(make_blockvector)
2148 struct blockvector *blockvector = NULL;
2152 /* Recursively walk down the tree, counting the number of blocks.
2153 Then add one to account for the global's symbol block */
2155 i = scopecount (scopetree) + 1;
2156 nbytes = sizeof (struct blockvector);
2159 nbytes += (i - 1) * sizeof (struct block *);
2161 blockvector = (struct blockvector *)
2162 obstack_alloc (symbol_obstack, nbytes);
2164 /* Copy the blocks into the blockvector. */
2166 BLOCKVECTOR_NBLOCKS (blockvector) = i;
2167 BLOCKVECTOR_BLOCK (blockvector, 0) = global_symbol_block;
2168 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector, 1), scopetree);
2170 return (blockvector);
2177 locval -- compute the value of a location attribute
2181 static int locval (char *loc)
2185 Given pointer to a string of bytes that define a location, compute
2186 the location and return the value.
2188 When computing values involving the current value of the frame pointer,
2189 the value zero is used, which results in a value relative to the frame
2190 pointer, rather than the absolute value. This is what GDB wants
2193 When the result is a register number, the global isreg flag is set,
2194 otherwise it is cleared. This is a kludge until we figure out a better
2195 way to handle the problem. Gdb's design does not mesh well with the
2196 DWARF notion of a location computing interpreter, which is a shame
2197 because the flexibility goes unused.
2201 Note that stack[0] is unused except as a default error return.
2202 Note that stack overflow is not yet handled.
2206 DEFUN(locval, (loc), char *loc)
2208 unsigned short nbytes;
2214 (void) memcpy (&nbytes, loc, sizeof (short));
2215 end = loc + sizeof (short) + nbytes;
2219 for (loc += sizeof (short); loc < end; loc += sizeof (long))
2227 /* push register (number) */
2228 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2232 /* push value of register (number) */
2233 /* Actually, we compute the value as if register has 0 */
2234 (void) memcpy (®no, loc, sizeof (long));
2237 stack[++stacki] = 0;
2241 stack[++stacki] = 0;
2242 SQUAWK (("BASEREG %d not handled!", regno));
2246 /* push address (relocated address) */
2247 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2250 /* push constant (number) */
2251 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2254 /* pop, deref and push 2 bytes (as a long) */
2255 SQUAWK (("OP_DEREF2 address %#x not handled", stack[stacki]));
2257 case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
2258 SQUAWK (("OP_DEREF4 address %#x not handled", stack[stacki]));
2260 case OP_ADD: /* pop top 2 items, add, push result */
2261 stack[stacki - 1] += stack[stacki];
2266 return (stack[stacki]);
2273 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2277 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2281 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2284 static struct symtab *
2285 DEFUN(read_ofile_symtab, (pst),
2286 struct partial_symtab *pst)
2288 struct cleanup *back_to;
2291 bfd *abfd = pst->objfile->obfd;
2293 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2294 unit, seek to the location in the file, and read in all the DIE's. */
2297 dbbase = xmalloc (DBLENGTH(pst));
2298 dbroff = DBROFF(pst);
2299 foffset = DBFOFF(pst) + dbroff;
2300 if (bfd_seek (abfd, foffset, 0) ||
2301 (bfd_read (dbbase, DBLENGTH(pst), 1, abfd) != DBLENGTH(pst)))
2304 error ("can't read DWARF data");
2306 back_to = make_cleanup (free, dbbase);
2308 /* If there is a line number table associated with this compilation unit
2309 then read the first long word from the line number table fragment, which
2310 contains the size of the fragment in bytes (including the long word
2311 itself). Allocate a buffer for the fragment and read it in for future
2317 if (bfd_seek (abfd, LNFOFF (pst), 0) ||
2318 (bfd_read (&lnsize, sizeof(long), 1, abfd) != sizeof(long)))
2320 error ("can't read DWARF line number table size");
2322 lnbase = xmalloc (lnsize);
2323 if (bfd_seek (abfd, LNFOFF (pst), 0) ||
2324 (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
2327 error ("can't read DWARF line numbers");
2329 make_cleanup (free, lnbase);
2332 process_dies (dbbase, dbbase + DBLENGTH(pst), pst->objfile);
2333 do_cleanups (back_to);
2334 return (symtab_list);
2341 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2345 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2349 Called once for each partial symbol table entry that needs to be
2350 expanded into a full symbol table entry.
2355 DEFUN(psymtab_to_symtab_1,
2357 struct partial_symtab *pst)
2367 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
2372 /* Read in all partial symtabs on which this one is dependent */
2373 for (i = 0; i < pst -> number_of_dependencies; i++)
2374 if (!pst -> dependencies[i] -> readin)
2376 /* Inform about additional files that need to be read in. */
2379 fputs_filtered (" ", stdout);
2381 fputs_filtered ("and ", stdout);
2383 printf_filtered ("%s...", pst -> dependencies[i] -> filename);
2384 wrap_here (""); /* Flush output */
2387 psymtab_to_symtab_1 (pst -> dependencies[i]);
2390 if (DBLENGTH(pst)) /* Otherwise it's a dummy */
2392 /* Init stuff necessary for reading in symbols */
2393 pst -> symtab = read_ofile_symtab (pst);
2396 printf_filtered ("%d DIE's, sorting...", diecount);
2399 sort_symtab_syms (pst -> symtab);
2408 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2412 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2416 This is the DWARF support entry point for building a full symbol
2417 table entry from a partial symbol table entry. We are passed a
2418 pointer to the partial symbol table entry that needs to be expanded.
2423 DEFUN(dwarf_psymtab_to_symtab, (pst), struct partial_symtab *pst)
2434 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
2439 if (DBLENGTH(pst) || pst -> number_of_dependencies)
2441 /* Print the message now, before starting serious work, to avoid
2442 disconcerting pauses. */
2445 printf_filtered ("Reading in symbols for %s...", pst -> filename);
2449 psymtab_to_symtab_1 (pst);
2451 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2452 we need to do an equivalent or is this something peculiar to
2453 stabs/a.out format. */
2454 /* Match with global symbols. This only needs to be done once,
2455 after all of the symtabs and dependencies have been read in. */
2456 scan_file_globals ();
2459 /* Finish up the debug error message. */
2462 printf_filtered ("done.\n");
2471 init_psymbol_list -- initialize storage for partial symbols
2475 static void init_psymbol_list (int total_symbols)
2479 Initializes storage for all of the partial symbols that will be
2480 created by dwarf_build_psymtabs and subsidiaries.
2484 DEFUN(init_psymbol_list, (total_symbols), int total_symbols)
2486 /* Free any previously allocated psymbol lists. */
2488 if (global_psymbols.list)
2490 free (global_psymbols.list);
2492 if (static_psymbols.list)
2494 free (static_psymbols.list);
2497 /* Current best guess is that there are approximately a twentieth
2498 of the total symbols (in a debugging file) are global or static
2501 global_psymbols.size = total_symbols / 10;
2502 static_psymbols.size = total_symbols / 10;
2503 global_psymbols.next = global_psymbols.list = (struct partial_symbol *)
2504 xmalloc (global_psymbols.size * sizeof (struct partial_symbol));
2505 static_psymbols.next = static_psymbols.list = (struct partial_symbol *)
2506 xmalloc (static_psymbols.size * sizeof (struct partial_symbol));
2513 start_psymtab -- allocate and partially fill a partial symtab entry
2517 Allocate and partially fill a partial symtab. It will be completely
2518 filled at the end of the symbol list.
2520 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2521 ADDR is the address relative to which its symbols are (incremental)
2522 or 0 (normal). FILENAME is the name of the compilation unit that
2523 these symbols were defined in, and they appear starting a address
2524 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2525 the full symbols can be read for compilation unit FILENAME.
2526 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2531 static struct partial_symtab *
2532 DEFUN(start_psymtab,
2533 (objfile, addr, filename, textlow, texthigh, dbfoff, curoff,
2534 culength, lnfoff, global_syms, static_syms),
2535 struct objfile *objfile AND
2538 CORE_ADDR textlow AND
2539 CORE_ADDR texthigh AND
2544 struct partial_symbol *global_syms AND
2545 struct partial_symbol *static_syms)
2547 struct partial_symtab *result;
2549 result = (struct partial_symtab *)
2550 obstack_alloc (psymbol_obstack, sizeof (struct partial_symtab));
2551 (void) memset (result, 0, sizeof (struct partial_symtab));
2552 result -> addr = addr;
2553 result -> objfile = objfile;
2554 result -> filename = create_name (filename, psymbol_obstack);
2555 result -> textlow = textlow;
2556 result -> texthigh = texthigh;
2557 result -> read_symtab_private = (char *) obstack_alloc (psymbol_obstack,
2558 sizeof (struct dwfinfo));
2559 DBFOFF (result) = dbfoff;
2560 DBROFF (result) = curoff;
2561 DBLENGTH (result) = culength;
2562 LNFOFF (result) = lnfoff;
2563 result -> readin = 0;
2564 result -> symtab = NULL;
2565 result -> read_symtab = dwarf_psymtab_to_symtab;
2566 result -> globals_offset = global_syms - global_psymbols.list;
2567 result -> statics_offset = static_syms - static_psymbols.list;
2569 result->n_global_syms = 0;
2570 result->n_static_syms = 0;
2579 add_psymbol_to_list -- add a partial symbol to given list
2583 Add a partial symbol to one of the partial symbol vectors (pointed to
2584 by listp). The vector is grown as necessary.
2589 DEFUN(add_psymbol_to_list,
2590 (listp, name, space, class, value),
2591 struct psymbol_allocation_list *listp AND
2593 enum namespace space AND
2594 enum address_class class AND
2597 struct partial_symbol *psym;
2600 if (listp -> next >= listp -> list + listp -> size)
2602 newsize = listp -> size * 2;
2603 listp -> list = (struct partial_symbol *)
2604 xrealloc (listp -> list, (newsize * sizeof (struct partial_symbol)));
2605 /* Next assumes we only went one over. Should be good if program works
2607 listp -> next = listp -> list + listp -> size;
2608 listp -> size = newsize;
2610 psym = listp -> next++;
2611 SYMBOL_NAME (psym) = create_name (name, psymbol_obstack);
2612 SYMBOL_NAMESPACE (psym) = space;
2613 SYMBOL_CLASS (psym) = class;
2614 SYMBOL_VALUE (psym) = value;
2621 add_partial_symbol -- add symbol to partial symbol table
2625 Given a DIE, if it is one of the types that we want to
2626 add to a partial symbol table, finish filling in the die info
2627 and then add a partial symbol table entry for it.
2632 DEFUN(add_partial_symbol, (dip), struct dieinfo *dip)
2634 switch (dip -> dietag)
2636 case TAG_global_subroutine:
2637 record_misc_function (dip -> at_name, dip -> at_low_pc, mf_text);
2638 add_psymbol_to_list (&global_psymbols, dip -> at_name, VAR_NAMESPACE,
2639 LOC_BLOCK, dip -> at_low_pc);
2641 case TAG_global_variable:
2642 record_misc_function (dip -> at_name, locval (dip -> at_location),
2644 add_psymbol_to_list (&global_psymbols, dip -> at_name, VAR_NAMESPACE,
2647 case TAG_subroutine:
2648 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2649 LOC_BLOCK, dip -> at_low_pc);
2651 case TAG_local_variable:
2652 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2656 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2659 case TAG_structure_type:
2660 case TAG_union_type:
2661 case TAG_enumeration_type:
2662 add_psymbol_to_list (&static_psymbols, dip -> at_name, STRUCT_NAMESPACE,
2672 scan_partial_symbols -- scan DIE's within a single compilation unit
2676 Process the DIE's within a single compilation unit, looking for
2677 interesting DIE's that contribute to the partial symbol table entry
2678 for this compilation unit. Since we cannot follow any sibling
2679 chains without reading the complete DIE info for every DIE,
2680 it is probably faster to just sequentially check each one to
2681 see if it is one of the types we are interested in, and if
2682 so, then extracting all the attributes info and generating a
2683 partial symbol table entry.
2688 DEFUN(scan_partial_symbols, (thisdie, enddie), char *thisdie AND char *enddie)
2693 while (thisdie < enddie)
2695 basicdieinfo (&di, thisdie);
2696 if (di.dielength < sizeof (long))
2702 nextdie = thisdie + di.dielength;
2705 case TAG_global_subroutine:
2706 case TAG_global_variable:
2707 case TAG_subroutine:
2708 case TAG_local_variable:
2710 case TAG_structure_type:
2711 case TAG_union_type:
2712 case TAG_enumeration_type:
2713 completedieinfo (&di);
2714 /* Don't attempt to add anonymous structures, unions, or
2715 enumerations since they have no name. Also check that
2716 this is the place where the actual definition occurs,
2717 rather than just a reference to an external. */
2718 if (di.at_name != NULL && !di.at_is_external_p)
2720 add_partial_symbol (&di);
2733 scan_compilation_units -- build a psymtab entry for each compilation
2737 This is the top level dwarf parsing routine for building partial
2740 It scans from the beginning of the DWARF table looking for the first
2741 TAG_compile_unit DIE, and then follows the sibling chain to locate
2742 each additional TAG_compile_unit DIE.
2744 For each TAG_compile_unit DIE it creates a partial symtab structure,
2745 calls a subordinate routine to collect all the compilation unit's
2746 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2747 new partial symtab structure into the partial symbol table. It also
2748 records the appropriate information in the partial symbol table entry
2749 to allow the chunk of DIE's and line number table for this compilation
2750 unit to be located and re-read later, to generate a complete symbol
2751 table entry for the compilation unit.
2753 Thus it effectively partitions up a chunk of DIE's for multiple
2754 compilation units into smaller DIE chunks and line number tables,
2755 and associates them with a partial symbol table entry.
2759 If any compilation unit has no line number table associated with
2760 it for some reason (a missing at_stmt_list attribute, rather than
2761 just one with a value of zero, which is valid) then we ensure that
2762 the recorded file offset is zero so that the routine which later
2763 reads line number table fragments knows that there is no fragment
2773 DEFUN(scan_compilation_units,
2774 (filename, addr, thisdie, enddie, dbfoff, lnoffset, objfile),
2779 unsigned int dbfoff AND
2780 unsigned int lnoffset AND
2781 struct objfile *objfile)
2785 struct partial_symtab *pst;
2790 while (thisdie < enddie)
2792 basicdieinfo (&di, thisdie);
2793 if (di.dielength < sizeof (long))
2797 else if (di.dietag != TAG_compile_unit)
2799 nextdie = thisdie + di.dielength;
2803 completedieinfo (&di);
2804 if (di.at_sibling != 0)
2806 nextdie = dbbase + di.at_sibling - dbroff;
2810 nextdie = thisdie + di.dielength;
2812 curoff = thisdie - dbbase;
2813 culength = nextdie - thisdie;
2814 curlnoffset = di.at_stmt_list_p ? lnoffset + di.at_stmt_list : 0;
2815 pst = start_psymtab (objfile, addr, di.at_name,
2816 di.at_low_pc, di.at_high_pc,
2817 dbfoff, curoff, culength, curlnoffset,
2818 global_psymbols.next,
2819 static_psymbols.next);
2820 scan_partial_symbols (thisdie + di.dielength, nextdie);
2821 pst -> n_global_syms = global_psymbols.next -
2822 (global_psymbols.list + pst -> globals_offset);
2823 pst -> n_static_syms = static_psymbols.next -
2824 (static_psymbols.list + pst -> statics_offset);
2825 /* Sort the global list; don't sort the static list */
2826 qsort (global_psymbols.list + pst -> globals_offset,
2827 pst -> n_global_syms, sizeof (struct partial_symbol),
2829 /* If there is already a psymtab or symtab for a file of this name,
2830 remove it. (If there is a symtab, more drastic things also
2831 happen.) This happens in VxWorks. */
2832 free_named_symtabs (pst -> filename);
2833 /* Place the partial symtab on the partial symtab list */
2834 pst -> next = partial_symtab_list;
2835 partial_symtab_list = pst;
2845 new_symbol -- make a symbol table entry for a new symbol
2849 static struct symbol *new_symbol (struct dieinfo *dip)
2853 Given a pointer to a DWARF information entry, figure out if we need
2854 to make a symbol table entry for it, and if so, create a new entry
2855 and return a pointer to it.
2858 static struct symbol *
2859 DEFUN(new_symbol, (dip), struct dieinfo *dip)
2861 struct symbol *sym = NULL;
2863 if (dip -> at_name != NULL)
2865 sym = (struct symbol *) obstack_alloc (symbol_obstack,
2866 sizeof (struct symbol));
2867 (void) memset (sym, 0, sizeof (struct symbol));
2868 SYMBOL_NAME (sym) = create_name (dip -> at_name, symbol_obstack);
2869 /* default assumptions */
2870 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2871 SYMBOL_CLASS (sym) = LOC_STATIC;
2872 SYMBOL_TYPE (sym) = decode_die_type (dip);
2873 switch (dip -> dietag)
2876 SYMBOL_VALUE (sym) = dip -> at_low_pc + baseaddr;
2877 SYMBOL_CLASS (sym) = LOC_LABEL;
2879 case TAG_global_subroutine:
2880 case TAG_subroutine:
2881 SYMBOL_VALUE (sym) = dip -> at_low_pc + baseaddr;
2882 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
2883 SYMBOL_CLASS (sym) = LOC_BLOCK;
2884 if (dip -> dietag == TAG_global_subroutine)
2886 add_symbol_to_list (sym, &global_symbols);
2890 add_symbol_to_list (sym, &scope -> symbols);
2893 case TAG_global_variable:
2894 case TAG_local_variable:
2895 if (dip -> at_location != NULL)
2897 SYMBOL_VALUE (sym) = locval (dip -> at_location);
2899 if (dip -> dietag == TAG_global_variable)
2901 add_symbol_to_list (sym, &global_symbols);
2902 SYMBOL_CLASS (sym) = LOC_STATIC;
2903 SYMBOL_VALUE (sym) += baseaddr;
2907 add_symbol_to_list (sym, &scope -> symbols);
2908 if (scope -> parent != NULL)
2912 SYMBOL_CLASS (sym) = LOC_REGISTER;
2916 SYMBOL_CLASS (sym) = LOC_LOCAL;
2921 SYMBOL_CLASS (sym) = LOC_STATIC;
2922 SYMBOL_VALUE (sym) += baseaddr;
2926 case TAG_formal_parameter:
2927 if (dip -> at_location != NULL)
2929 SYMBOL_VALUE (sym) = locval (dip -> at_location);
2931 add_symbol_to_list (sym, &scope -> symbols);
2934 SYMBOL_CLASS (sym) = LOC_REGPARM;
2938 SYMBOL_CLASS (sym) = LOC_ARG;
2941 case TAG_unspecified_parameters:
2942 /* From varargs functions; gdb doesn't seem to have any interest in
2943 this information, so just ignore it for now. (FIXME?) */
2945 case TAG_structure_type:
2946 case TAG_union_type:
2947 case TAG_enumeration_type:
2948 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2949 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
2950 add_symbol_to_list (sym, &scope -> symbols);
2953 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2954 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2955 add_symbol_to_list (sym, &scope -> symbols);
2958 /* Not a tag we recognize. Hopefully we aren't processing trash
2959 data, but since we must specifically ignore things we don't
2960 recognize, there is nothing else we should do at this point. */
2971 decode_mod_fund_type -- decode a modified fundamental type
2975 static struct type *decode_mod_fund_type (char *typedata)
2979 Decode a block of data containing a modified fundamental
2980 type specification. TYPEDATA is a pointer to the block,
2981 which consists of a two byte length, containing the size
2982 of the rest of the block. At the end of the block is a
2983 two byte value that gives the fundamental type. Everything
2984 in between are type modifiers.
2986 We simply compute the number of modifiers and call the general
2987 function decode_modified_type to do the actual work.
2990 static struct type *
2991 DEFUN(decode_mod_fund_type, (typedata), char *typedata)
2993 struct type *typep = NULL;
2994 unsigned short modcount;
2995 unsigned char *modifiers;
2997 /* Get the total size of the block, exclusive of the size itself */
2998 (void) memcpy (&modcount, typedata, sizeof (short));
2999 /* Deduct the size of the fundamental type bytes at the end of the block. */
3000 modcount -= sizeof (short);
3001 /* Skip over the two size bytes at the beginning of the block. */
3002 modifiers = (unsigned char *) typedata + sizeof (short);
3003 /* Now do the actual decoding */
3004 typep = decode_modified_type (modifiers, modcount, AT_mod_fund_type);
3012 decode_mod_u_d_type -- decode a modified user defined type
3016 static struct type *decode_mod_u_d_type (char *typedata)
3020 Decode a block of data containing a modified user defined
3021 type specification. TYPEDATA is a pointer to the block,
3022 which consists of a two byte length, containing the size
3023 of the rest of the block. At the end of the block is a
3024 four byte value that gives a reference to a user defined type.
3025 Everything in between are type modifiers.
3027 We simply compute the number of modifiers and call the general
3028 function decode_modified_type to do the actual work.
3031 static struct type *
3032 DEFUN(decode_mod_u_d_type, (typedata), char *typedata)
3034 struct type *typep = NULL;
3035 unsigned short modcount;
3036 unsigned char *modifiers;
3038 /* Get the total size of the block, exclusive of the size itself */
3039 (void) memcpy (&modcount, typedata, sizeof (short));
3040 /* Deduct the size of the reference type bytes at the end of the block. */
3041 modcount -= sizeof (long);
3042 /* Skip over the two size bytes at the beginning of the block. */
3043 modifiers = (unsigned char *) typedata + sizeof (short);
3044 /* Now do the actual decoding */
3045 typep = decode_modified_type (modifiers, modcount, AT_mod_u_d_type);
3053 decode_modified_type -- decode modified user or fundamental type
3057 static struct type *decode_modified_type (unsigned char *modifiers,
3058 unsigned short modcount, int mtype)
3062 Decode a modified type, either a modified fundamental type or
3063 a modified user defined type. MODIFIERS is a pointer to the
3064 block of bytes that define MODCOUNT modifiers. Immediately
3065 following the last modifier is a short containing the fundamental
3066 type or a long containing the reference to the user defined
3067 type. Which one is determined by MTYPE, which is either
3068 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3069 type we are generating.
3071 We call ourself recursively to generate each modified type,`
3072 until MODCOUNT reaches zero, at which point we have consumed
3073 all the modifiers and generate either the fundamental type or
3074 user defined type. When the recursion unwinds, each modifier
3075 is applied in turn to generate the full modified type.
3079 If we find a modifier that we don't recognize, and it is not one
3080 of those reserved for application specific use, then we issue a
3081 warning and simply ignore the modifier.
3085 We currently ignore MOD_const and MOD_volatile. (FIXME)
3089 static struct type *
3090 DEFUN(decode_modified_type,
3091 (modifiers, modcount, mtype),
3092 unsigned char *modifiers AND unsigned short modcount AND int mtype)
3094 struct type *typep = NULL;
3095 unsigned short fundtype;
3097 unsigned char modifier;
3103 case AT_mod_fund_type:
3104 (void) memcpy (&fundtype, modifiers, sizeof (short));
3105 typep = decode_fund_type (fundtype);
3107 case AT_mod_u_d_type:
3108 (void) memcpy (&dieref, modifiers, sizeof (DIEREF));
3109 if ((typep = lookup_utype (dieref)) == NULL)
3111 typep = alloc_utype (dieref, NULL);
3115 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype));
3116 typep = builtin_type_int;
3122 modifier = *modifiers++;
3123 typep = decode_modified_type (modifiers, --modcount, mtype);
3126 case MOD_pointer_to:
3127 typep = lookup_pointer_type (typep);
3129 case MOD_reference_to:
3130 typep = lookup_reference_type (typep);
3133 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3136 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3139 if (!(MOD_lo_user <= modifier && modifier <= MOD_hi_user))
3141 SQUAWK (("unknown type modifier %u", modifier));
3153 decode_fund_type -- translate basic DWARF type to gdb base type
3157 Given an integer that is one of the fundamental DWARF types,
3158 translate it to one of the basic internal gdb types and return
3159 a pointer to the appropriate gdb type (a "struct type *").
3163 If we encounter a fundamental type that we are unprepared to
3164 deal with, and it is not in the range of those types defined
3165 as application specific types, then we issue a warning and
3166 treat the type as builtin_type_int.
3169 static struct type *
3170 DEFUN(decode_fund_type, (fundtype), unsigned short fundtype)
3172 struct type *typep = NULL;
3178 typep = builtin_type_void;
3181 case FT_pointer: /* (void *) */
3182 typep = lookup_pointer_type (builtin_type_void);
3186 case FT_signed_char:
3187 typep = builtin_type_char;
3191 case FT_signed_short:
3192 typep = builtin_type_short;
3196 case FT_signed_integer:
3197 case FT_boolean: /* Was FT_set in AT&T version */
3198 typep = builtin_type_int;
3202 case FT_signed_long:
3203 typep = builtin_type_long;
3207 typep = builtin_type_float;
3210 case FT_dbl_prec_float:
3211 typep = builtin_type_double;
3214 case FT_unsigned_char:
3215 typep = builtin_type_unsigned_char;
3218 case FT_unsigned_short:
3219 typep = builtin_type_unsigned_short;
3222 case FT_unsigned_integer:
3223 typep = builtin_type_unsigned_int;
3226 case FT_unsigned_long:
3227 typep = builtin_type_unsigned_long;
3230 case FT_ext_prec_float:
3231 typep = builtin_type_long_double;
3235 typep = builtin_type_complex;
3238 case FT_dbl_prec_complex:
3239 typep = builtin_type_double_complex;
3243 case FT_signed_long_long:
3244 typep = builtin_type_long_long;
3247 case FT_unsigned_long_long:
3248 typep = builtin_type_unsigned_long_long;
3253 if ((typep == NULL) && !(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
3255 SQUAWK (("unexpected fundamental type 0x%x", fundtype));
3256 typep = builtin_type_void;
3266 create_name -- allocate a fresh copy of a string on an obstack
3270 Given a pointer to a string and a pointer to an obstack, allocates
3271 a fresh copy of the string on the specified obstack.
3276 DEFUN(create_name, (name, obstackp), char *name AND struct obstack *obstackp)
3281 length = strlen (name) + 1;
3282 newname = (char *) obstack_alloc (obstackp, length);
3283 (void) strcpy (newname, name);
3291 basicdieinfo -- extract the minimal die info from raw die data
3295 void basicdieinfo (char *diep, struct dieinfo *dip)
3299 Given a pointer to raw DIE data, and a pointer to an instance of a
3300 die info structure, this function extracts the basic information
3301 from the DIE data required to continue processing this DIE, along
3302 with some bookkeeping information about the DIE.
3304 The information we absolutely must have includes the DIE tag,
3305 and the DIE length. If we need the sibling reference, then we
3306 will have to call completedieinfo() to process all the remaining
3309 Note that since there is no guarantee that the data is properly
3310 aligned in memory for the type of access required (indirection
3311 through anything other than a char pointer), we use memcpy to
3312 shuffle data items larger than a char. Possibly inefficient, but
3315 We also take care of some other basic things at this point, such
3316 as ensuring that the instance of the die info structure starts
3317 out completely zero'd and that curdie is initialized for use
3318 in error reporting if we have a problem with the current die.
3322 All DIE's must have at least a valid length, thus the minimum
3323 DIE size is sizeof (long). In order to have a valid tag, the
3324 DIE size must be at least sizeof (short) larger, otherwise they
3325 are forced to be TAG_padding DIES.
3327 Padding DIES must be at least sizeof(long) in length, implying that
3328 if a padding DIE is used for alignment and the amount needed is less
3329 than sizeof(long) then the padding DIE has to be big enough to align
3330 to the next alignment boundry.
3334 DEFUN(basicdieinfo, (dip, diep), struct dieinfo *dip AND char *diep)
3337 (void) memset (dip, 0, sizeof (struct dieinfo));
3339 dip -> dieref = dbroff + (diep - dbbase);
3340 (void) memcpy (&dip -> dielength, diep, sizeof (long));
3341 if (dip -> dielength < sizeof (long))
3343 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip -> dielength);
3345 else if (dip -> dielength < (sizeof (long) + sizeof (short)))
3347 dip -> dietag = TAG_padding;
3351 (void) memcpy (&dip -> dietag, diep + sizeof (long), sizeof (short));
3359 completedieinfo -- finish reading the information for a given DIE
3363 void completedieinfo (struct dieinfo *dip)
3367 Given a pointer to an already partially initialized die info structure,
3368 scan the raw DIE data and finish filling in the die info structure
3369 from the various attributes found.
3371 Note that since there is no guarantee that the data is properly
3372 aligned in memory for the type of access required (indirection
3373 through anything other than a char pointer), we use memcpy to
3374 shuffle data items larger than a char. Possibly inefficient, but
3379 Each time we are called, we increment the diecount variable, which
3380 keeps an approximate count of the number of dies processed for
3381 each compilation unit. This information is presented to the user
3382 if the info_verbose flag is set.
3387 DEFUN(completedieinfo, (dip), struct dieinfo *dip)
3389 char *diep; /* Current pointer into raw DIE data */
3390 char *end; /* Terminate DIE scan here */
3391 unsigned short attr; /* Current attribute being scanned */
3392 unsigned short form; /* Form of the attribute */
3393 short block2sz; /* Size of a block2 attribute field */
3394 long block4sz; /* Size of a block4 attribute field */
3398 end = diep + dip -> dielength;
3399 diep += sizeof (long) + sizeof (short);
3402 (void) memcpy (&attr, diep, sizeof (short));
3403 diep += sizeof (short);
3407 (void) memcpy (&dip -> at_fund_type, diep, sizeof (short));
3410 (void) memcpy (&dip -> at_ordering, diep, sizeof (short));
3413 (void) memcpy (&dip -> at_bit_offset, diep, sizeof (short));
3416 (void) memcpy (&dip -> at_visibility, diep, sizeof (short));
3419 (void) memcpy (&dip -> at_sibling, diep, sizeof (long));
3422 (void) memcpy (&dip -> at_stmt_list, diep, sizeof (long));
3423 dip -> at_stmt_list_p = 1;
3426 (void) memcpy (&dip -> at_low_pc, diep, sizeof (long));
3429 (void) memcpy (&dip -> at_high_pc, diep, sizeof (long));
3432 (void) memcpy (&dip -> at_language, diep, sizeof (long));
3434 case AT_user_def_type:
3435 (void) memcpy (&dip -> at_user_def_type, diep, sizeof (long));
3438 (void) memcpy (&dip -> at_byte_size, diep, sizeof (long));
3441 (void) memcpy (&dip -> at_bit_size, diep, sizeof (long));
3444 (void) memcpy (&dip -> at_member, diep, sizeof (long));
3447 (void) memcpy (&dip -> at_discr, diep, sizeof (long));
3450 (void) memcpy (&dip -> at_import, diep, sizeof (long));
3453 dip -> at_location = diep;
3455 case AT_mod_fund_type:
3456 dip -> at_mod_fund_type = diep;
3458 case AT_subscr_data:
3459 dip -> at_subscr_data = diep;
3461 case AT_mod_u_d_type:
3462 dip -> at_mod_u_d_type = diep;
3465 dip -> at_deriv_list = diep;
3467 case AT_element_list:
3468 dip -> at_element_list = diep;
3470 case AT_discr_value:
3471 dip -> at_discr_value = diep;
3473 case AT_string_length:
3474 dip -> at_string_length = diep;
3477 dip -> at_name = diep;
3480 dip -> at_comp_dir = diep;
3483 dip -> at_producer = diep;
3486 (void) memcpy (&dip -> at_loclist, diep, sizeof (long));
3489 (void) memcpy (&dip -> at_frame_base, diep, sizeof (long));
3492 (void) memcpy (&dip -> at_incomplete, diep, sizeof (short));
3494 case AT_start_scope:
3495 (void) memcpy (&dip -> at_start_scope, diep, sizeof (long));
3497 case AT_stride_size:
3498 (void) memcpy (&dip -> at_stride_size, diep, sizeof (long));
3501 (void) memcpy (&dip -> at_src_info, diep, sizeof (long));
3504 (void) memcpy (&dip -> at_prototyped, diep, sizeof (short));
3507 dip -> at_const_data = diep;
3509 case AT_is_external:
3510 (void) memcpy (&dip -> at_is_external, diep, sizeof (short));
3511 dip -> at_is_external_p = 1;
3514 /* Found an attribute that we are unprepared to handle. However
3515 it is specifically one of the design goals of DWARF that
3516 consumers should ignore unknown attributes. As long as the
3517 form is one that we recognize (so we know how to skip it),
3518 we can just ignore the unknown attribute. */
3525 diep += sizeof (short);
3528 diep += sizeof (long);
3531 diep += 8 * sizeof (char); /* sizeof (long long) ? */
3535 diep += sizeof (long);
3538 (void) memcpy (&block2sz, diep, sizeof (short));
3539 block2sz += sizeof (short);
3543 (void) memcpy (&block4sz, diep, sizeof (long));
3544 block4sz += sizeof (long);
3548 diep += strlen (diep) + 1;
3551 SQUAWK (("unknown attribute form (0x%x), skipped rest", form));