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_low_pc, 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_element_list;
162 BLOCK * at_discr_value;
165 BLOCK * at_string_length;
173 unsigned int has_at_low_pc:1;
174 unsigned int has_at_stmt_list:1;
177 static int diecount; /* Approximate count of dies for compilation unit */
178 static struct dieinfo *curdie; /* For warnings and such */
180 static char *dbbase; /* Base pointer to dwarf info */
181 static int dbroff; /* Relative offset from start of .debug section */
182 static char *lnbase; /* Base pointer to line section */
183 static int isreg; /* Kludge to identify register variables */
185 static CORE_ADDR baseaddr; /* Add to each symbol value */
187 /* Each partial symbol table entry contains a pointer to private data for the
188 read_symtab() function to use when expanding a partial symbol table entry
189 to a full symbol table entry. For DWARF debugging info, this data is
190 contained in the following structure and macros are provided for easy
191 access to the members given a pointer to a partial symbol table entry.
193 dbfoff Always the absolute file offset to the start of the ".debug"
194 section for the file containing the DIE's being accessed.
196 dbroff Relative offset from the start of the ".debug" access to the
197 first DIE to be accessed. When building the partial symbol
198 table, this value will be zero since we are accessing the
199 entire ".debug" section. When expanding a partial symbol
200 table entry, this value will be the offset to the first
201 DIE for the compilation unit containing the symbol that
202 triggers the expansion.
204 dblength The size of the chunk of DIE's being examined, in bytes.
206 lnfoff The absolute file offset to the line table fragment. Ignored
207 when building partial symbol tables, but used when expanding
208 them, and contains the absolute file offset to the fragment
209 of the ".line" section containing the line numbers for the
210 current compilation unit.
214 int dbfoff; /* Absolute file offset to start of .debug section */
215 int dbroff; /* Relative offset from start of .debug section */
216 int dblength; /* Size of the chunk of DIE's being examined */
217 int lnfoff; /* Absolute file offset to line table fragment */
220 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
221 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
222 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
223 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
225 /* Record the symbols defined for each context in a linked list. We don't
226 create a struct block for the context until we know how long to make it.
227 Global symbols for each file are maintained in the global_symbols list. */
229 struct pending_symbol {
230 struct pending_symbol *next; /* Next pending symbol */
231 struct symbol *symbol; /* The actual symbol */
234 static struct pending_symbol *global_symbols; /* global funcs and vars */
235 static struct block *global_symbol_block;
237 /* Line number entries are read into a dynamically expandable vector before
238 being added to the symbol table section. Once we know how many there are
241 static struct linetable *line_vector; /* Vector of line numbers. */
242 static int line_vector_index; /* Index of next entry. */
243 static int line_vector_length; /* Current allocation limit */
245 /* Scope information is kept in a scope tree, one node per scope. Each time
246 a new scope is started, a child node is created under the current node
247 and set to the current scope. Each time a scope is closed, the current
248 scope moves back up the tree to the parent of the current scope.
250 Each scope contains a pointer to the list of symbols defined in the scope,
251 a pointer to the block vector for the scope, a pointer to the symbol
252 that names the scope (if any), and the range of PC values that mark
253 the start and end of the scope. */
256 struct scopenode *parent;
257 struct scopenode *child;
258 struct scopenode *sibling;
259 struct pending_symbol *symbols;
261 struct symbol *namesym;
266 static struct scopenode *scopetree;
267 static struct scopenode *scope;
269 /* DIES which have user defined types or modified user defined types refer to
270 other DIES for the type information. Thus we need to associate the offset
271 of a DIE for a user defined type with a pointer to the type information.
273 Originally this was done using a simple but expensive algorithm, with an
274 array of unsorted structures, each containing an offset/type-pointer pair.
275 This array was scanned linearly each time a lookup was done. The result
276 was that gdb was spending over half it's startup time munging through this
277 array of pointers looking for a structure that had the right offset member.
279 The second attempt used the same array of structures, but the array was
280 sorted using qsort each time a new offset/type was recorded, and a binary
281 search was used to find the type pointer for a given DIE offset. This was
282 even slower, due to the overhead of sorting the array each time a new
283 offset/type pair was entered.
285 The third attempt uses a fixed size array of type pointers, indexed by a
286 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
287 we can divide any DIE offset by 4 to obtain a unique index into this fixed
288 size array. Since each element is a 4 byte pointer, it takes exactly as
289 much memory to hold this array as to hold the DWARF info for a given
290 compilation unit. But it gets freed as soon as we are done with it. */
292 static struct type **utypes; /* Pointer to array of user type pointers */
293 static int numutypes; /* Max number of user type pointers */
295 /* Forward declarations of static functions so we don't have to worry
296 about ordering within this file. The EXFUN macro may be slightly
297 misleading. Should probably be called DCLFUN instead, or something
298 more intuitive, since it can be used for both static and external
302 EXFUN (dwarfwarn, (char *fmt DOTS));
305 EXFUN (scan_partial_symbols, (char *thisdie AND char *enddie));
308 EXFUN (scan_compilation_units,
309 (char *filename AND CORE_ADDR addr AND char *thisdie AND char *enddie
310 AND unsigned int dbfoff AND unsigned int lnoffset
311 AND struct objfile *objfile));
313 static struct partial_symtab *
314 EXFUN(start_psymtab, (struct objfile *objfile AND CORE_ADDR addr
315 AND char *filename AND CORE_ADDR textlow
316 AND CORE_ADDR texthigh AND int dbfoff
317 AND int curoff AND int culength AND int lnfoff
318 AND struct partial_symbol *global_syms
319 AND struct partial_symbol *static_syms));
321 EXFUN(add_partial_symbol, (struct dieinfo *dip));
324 EXFUN(add_psymbol_to_list,
325 (struct psymbol_allocation_list *listp AND char *name
326 AND enum namespace space AND enum address_class class
327 AND CORE_ADDR value));
330 EXFUN(init_psymbol_list, (int total_symbols));
333 EXFUN(basicdieinfo, (struct dieinfo *dip AND char *diep));
336 EXFUN(completedieinfo, (struct dieinfo *dip));
339 EXFUN(dwarf_psymtab_to_symtab, (struct partial_symtab *pst));
342 EXFUN(psymtab_to_symtab_1, (struct partial_symtab *pst));
344 static struct symtab *
345 EXFUN(read_ofile_symtab, (struct partial_symtab *pst));
349 (char *thisdie AND char *enddie AND struct objfile *objfile));
352 EXFUN(read_structure_scope,
353 (struct dieinfo *dip AND char *thisdie AND char *enddie));
356 EXFUN(decode_array_element_type, (char *scan AND char *end));
359 EXFUN(decode_subscr_data, (char *scan AND char *end));
362 EXFUN(read_array_type, (struct dieinfo *dip));
365 EXFUN(read_subroutine_type,
366 (struct dieinfo *dip AND char *thisdie AND char *enddie));
369 EXFUN(read_enumeration,
370 (struct dieinfo *dip AND char *thisdie AND char *enddie));
374 (struct dieinfo *dip AND char *thisdie AND char *enddie));
377 EXFUN(enum_type, (struct dieinfo *dip));
380 EXFUN(start_symtab, (void));
384 (char *filename AND long language AND struct objfile *objfile));
387 EXFUN(scopecount, (struct scopenode *node));
391 (struct symbol *namesym AND CORE_ADDR lowpc AND CORE_ADDR highpc));
394 EXFUN(freescope, (struct scopenode *node));
396 static struct block *
397 EXFUN(buildblock, (struct pending_symbol *syms));
400 EXFUN(closescope, (void));
403 EXFUN(record_line, (int line AND CORE_ADDR pc));
406 EXFUN(decode_line_numbers, (char *linetable));
409 EXFUN(decode_die_type, (struct dieinfo *dip));
412 EXFUN(decode_mod_fund_type, (char *typedata));
415 EXFUN(decode_mod_u_d_type, (char *typedata));
418 EXFUN(decode_modified_type,
419 (unsigned char *modifiers AND unsigned short modcount AND int mtype));
422 EXFUN(decode_fund_type, (unsigned short fundtype));
425 EXFUN(create_name, (char *name AND struct obstack *obstackp));
428 EXFUN(add_symbol_to_list,
429 (struct symbol *symbol AND struct pending_symbol **listhead));
431 static struct block **
432 EXFUN(gatherblocks, (struct block **dest AND struct scopenode *node));
434 static struct blockvector *
435 EXFUN(make_blockvector, (void));
438 EXFUN(lookup_utype, (DIEREF dieref));
441 EXFUN(alloc_utype, (DIEREF dieref AND struct type *usetype));
443 static struct symbol *
444 EXFUN(new_symbol, (struct dieinfo *dip));
447 EXFUN(locval, (char *loc));
450 EXFUN(record_misc_function, (char *name AND CORE_ADDR address AND
451 enum misc_function_type));
454 EXFUN(compare_psymbols,
455 (struct partial_symbol *s1 AND struct partial_symbol *s2));
462 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
466 void dwarf_build_psymtabs (int desc, char *filename, CORE_ADDR addr,
467 int mainline, unsigned int dbfoff, unsigned int dbsize,
468 unsigned int lnoffset, unsigned int lnsize,
469 struct objfile *objfile)
473 This function is called upon to build partial symtabs from files
474 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
476 It is passed a file descriptor for an open file containing the DIES
477 and line number information, the corresponding filename for that
478 file, a base address for relocating the symbols, a flag indicating
479 whether or not this debugging information is from a "main symbol
480 table" rather than a shared library or dynamically linked file,
481 and file offset/size pairs for the DIE information and line number
491 DEFUN(dwarf_build_psymtabs,
492 (desc, filename, addr, mainline, dbfoff, dbsize, lnoffset, lnsize,
498 unsigned int dbfoff AND
499 unsigned int dbsize AND
500 unsigned int lnoffset AND
501 unsigned int lnsize AND
502 struct objfile *objfile)
504 struct cleanup *back_to;
506 dbbase = xmalloc (dbsize);
508 if ((lseek (desc, dbfoff, 0) != dbfoff) ||
509 (read (desc, dbbase, dbsize) != dbsize))
512 error ("can't read DWARF data from '%s'", filename);
514 back_to = make_cleanup (free, dbbase);
516 /* If we are reinitializing, or if we have never loaded syms yet, init.
517 Since we have no idea how many DIES we are looking at, we just guess
518 some arbitrary value. */
520 if (mainline || global_psymbols.size == 0 || static_psymbols.size == 0)
522 init_psymbol_list (1024);
525 /* Follow the compilation unit sibling chain, building a partial symbol
526 table entry for each one. Save enough information about each compilation
527 unit to locate the full DWARF information later. */
529 scan_compilation_units (filename, addr, dbbase, dbbase + dbsize,
530 dbfoff, lnoffset, objfile);
532 do_cleanups (back_to);
540 record_misc_function -- add entry to miscellaneous function vector
544 static void record_misc_function (char *name, CORE_ADDR address,
545 enum misc_function_type mf_type)
549 Given a pointer to the name of a symbol that should be added to the
550 miscellaneous function vector, and the address associated with that
551 symbol, records this information for later use in building the
552 miscellaneous function vector.
557 DEFUN(record_misc_function, (name, address, mf_type),
558 char *name AND CORE_ADDR address AND enum misc_function_type mf_type)
560 prim_record_misc_function (obsavestring (name, strlen (name)), address,
568 dwarfwarn -- issue a DWARF related warning
572 Issue warnings about DWARF related things that aren't serious enough
573 to warrant aborting with an error, but should not be ignored either.
574 This includes things like detectable corruption in DIE's, missing
575 DIE's, unimplemented features, etc.
577 In general, running across tags or attributes that we don't recognize
578 is not considered to be a problem and we should not issue warnings
583 We mostly follow the example of the error() routine, but without
584 returning to command level. It is arguable about whether warnings
585 should be issued at all, and if so, where they should go (stdout or
588 We assume that curdie is valid and contains at least the basic
589 information for the DIE where the problem was noticed.
594 DEFUN(dwarfwarn, (fmt), char *fmt DOTS)
600 fprintf (stderr, "DWARF warning (ref 0x%x): ", curdie -> dieref);
601 if (curdie -> at_name)
603 fprintf (stderr, "'%s': ", curdie -> at_name);
605 vfprintf (stderr, fmt, ap);
606 fprintf (stderr, "\n");
620 fmt = va_arg (ap, char *);
622 fprintf (stderr, "DWARF warning (ref 0x%x): ", curdie -> dieref);
623 if (curdie -> at_name)
625 fprintf (stderr, "'%s': ", curdie -> at_name);
627 vfprintf (stderr, fmt, ap);
628 fprintf (stderr, "\n");
637 compare_psymbols -- compare two partial symbols by name
641 Given pointer to two partial symbol table entries, compare
642 them by name and return -N, 0, or +N (ala strcmp). Typically
643 used by sorting routines like qsort().
647 This is a copy from dbxread.c. It should be moved to a generic
648 gdb file and made available for all psymtab builders (FIXME).
650 Does direct compare of first two characters before punting
651 and passing to strcmp for longer compares. Note that the
652 original version had a bug whereby two null strings or two
653 identically named one character strings would return the
654 comparison of memory following the null byte.
659 DEFUN(compare_psymbols, (s1, s2),
660 struct partial_symbol *s1 AND
661 struct partial_symbol *s2)
663 register char *st1 = SYMBOL_NAME (s1);
664 register char *st2 = SYMBOL_NAME (s2);
666 if ((st1[0] - st2[0]) || !st1[0])
668 return (st1[0] - st2[0]);
670 else if ((st1[1] - st2[1]) || !st1[1])
672 return (st1[1] - st2[1]);
676 return (strcmp (st1 + 2, st2 + 2));
684 read_lexical_block_scope -- process all dies in a lexical block
688 static void read_lexical_block_scope (struct dieinfo *dip,
689 char *thisdie, char *enddie)
693 Process all the DIES contained within a lexical block scope.
694 Start a new scope, process the dies, and then close the scope.
699 DEFUN(read_lexical_block_scope, (dip, thisdie, enddie, objfile),
700 struct dieinfo *dip AND
703 struct objfile *objfile)
705 openscope (NULL, dip -> at_low_pc, dip -> at_high_pc);
706 process_dies (thisdie + dip -> dielength, enddie, objfile);
714 lookup_utype -- look up a user defined type from die reference
718 static type *lookup_utype (DIEREF dieref)
722 Given a DIE reference, lookup the user defined type associated with
723 that DIE, if it has been registered already. If not registered, then
724 return NULL. Alloc_utype() can be called to register an empty
725 type for this reference, which will be filled in later when the
726 actual referenced DIE is processed.
730 DEFUN(lookup_utype, (dieref), DIEREF dieref)
732 struct type *type = NULL;
735 utypeidx = (dieref - dbroff) / 4;
736 if ((utypeidx < 0) || (utypeidx >= numutypes))
738 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref);
742 type = *(utypes + utypeidx);
752 alloc_utype -- add a user defined type for die reference
756 static type *alloc_utype (DIEREF dieref, struct type *utypep)
760 Given a die reference DIEREF, and a possible pointer to a user
761 defined type UTYPEP, register that this reference has a user
762 defined type and either use the specified type in UTYPEP or
763 make a new empty type that will be filled in later.
765 We should only be called after calling lookup_utype() to verify that
766 there is not currently a type registered for DIEREF.
770 DEFUN(alloc_utype, (dieref, utypep),
777 utypeidx = (dieref - dbroff) / 4;
778 typep = utypes + utypeidx;
779 if ((utypeidx < 0) || (utypeidx >= numutypes))
781 utypep = builtin_type_int;
782 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", dieref);
784 else if (*typep != NULL)
787 SQUAWK (("internal error: dup user type allocation"));
793 utypep = (struct type *)
794 obstack_alloc (symbol_obstack, sizeof (struct type));
795 (void) memset (utypep, 0, sizeof (struct type));
806 decode_die_type -- return a type for a specified die
810 static struct type *decode_die_type (struct dieinfo *dip)
814 Given a pointer to a die information structure DIP, decode the
815 type of the die and return a pointer to the decoded type. All
816 dies without specific types default to type int.
820 DEFUN(decode_die_type, (dip), struct dieinfo *dip)
822 struct type *type = NULL;
824 if (dip -> at_fund_type != 0)
826 type = decode_fund_type (dip -> at_fund_type);
828 else if (dip -> at_mod_fund_type != NULL)
830 type = decode_mod_fund_type (dip -> at_mod_fund_type);
832 else if (dip -> at_user_def_type)
834 if ((type = lookup_utype (dip -> at_user_def_type)) == NULL)
836 type = alloc_utype (dip -> at_user_def_type, NULL);
839 else if (dip -> at_mod_u_d_type)
841 type = decode_mod_u_d_type (dip -> at_mod_u_d_type);
845 type = builtin_type_int;
854 struct_type -- compute and return the type for a struct or union
858 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
863 Given pointer to a die information structure for a die which
864 defines a union or structure, and pointers to the raw die data
865 that define the range of dies which define the members, compute
866 and return the user defined type for the structure or union.
870 DEFUN(struct_type, (dip, thisdie, enddie),
871 struct dieinfo *dip AND
877 struct nextfield *next;
880 struct nextfield *list = NULL;
881 struct nextfield *new;
889 if ((type = lookup_utype (dip -> dieref)) == NULL)
891 type = alloc_utype (dip -> dieref, NULL);
893 switch (dip -> dietag)
895 case TAG_structure_type:
896 TYPE_CODE (type) = TYPE_CODE_STRUCT;
897 TYPE_CPLUS_SPECIFIC (type)
898 = (struct cplus_struct_type *) obstack_alloc (symbol_obstack, sizeof (struct cplus_struct_type));
899 bzero (TYPE_CPLUS_SPECIFIC (type), sizeof (struct cplus_struct_type));
903 TYPE_CODE (type) = TYPE_CODE_UNION;
908 SQUAWK (("missing structure or union tag"));
909 TYPE_CODE (type) = TYPE_CODE_UNDEF;
912 /* Some compilers try to be helpful by inventing "fake" names for anonymous
913 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
914 if (dip -> at_name == NULL || *dip -> at_name == '~')
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 /* Some compilers try to be helpful by inventing "fake" names for anonymous
1331 enums, structures, and unions, like "~0fake". Thanks, but no thanks. */
1332 if (dip -> at_name == NULL || *dip -> at_name == '~')
1336 tpart2 = dip -> at_name;
1338 if (dip -> at_byte_size == 0)
1340 tpart3 = " <opaque>";
1344 TYPE_LENGTH (type) = dip -> at_byte_size;
1347 TYPE_NAME (type) = concat (tpart1, tpart2, tpart3, NULL);
1348 if ((scan = dip -> at_element_list) != NULL)
1350 (void) memcpy (&temp, scan, sizeof (temp));
1351 listend = scan + temp + sizeof (temp);
1352 scan += sizeof (temp);
1353 while (scan < listend)
1355 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1358 list -> field.type = NULL;
1359 list -> field.bitsize = 0;
1360 (void) memcpy (&list -> field.bitpos, scan, sizeof (long));
1361 scan += sizeof (long);
1362 list -> field.name = savestring (scan, strlen (scan));
1363 scan += strlen (scan) + 1;
1367 /* Now create the vector of fields, and record how big it is. */
1368 TYPE_NFIELDS (type) = nfields;
1369 TYPE_FIELDS (type) = (struct field *)
1370 obstack_alloc (symbol_obstack, sizeof (struct field) * nfields);
1371 /* Copy the saved-up fields into the field vector. */
1372 for (n = nfields; list; list = list -> next)
1374 TYPE_FIELD (type, --n) = list -> field;
1383 read_func_scope -- process all dies within a function scope
1387 Process all dies within a given function scope. We are passed
1388 a die information structure pointer DIP for the die which
1389 starts the function scope, and pointers into the raw die data
1390 that define the dies within the function scope.
1392 For now, we ignore lexical block scopes within the function.
1393 The problem is that AT&T cc does not define a DWARF lexical
1394 block scope for the function itself, while gcc defines a
1395 lexical block scope for the function. We need to think about
1396 how to handle this difference, or if it is even a problem.
1401 DEFUN(read_func_scope, (dip, thisdie, enddie, objfile),
1402 struct dieinfo *dip AND
1405 struct objfile *objfile)
1409 if (entry_point >= dip -> at_low_pc && entry_point < dip -> at_high_pc)
1411 entry_scope_lowpc = dip -> at_low_pc;
1412 entry_scope_highpc = dip -> at_high_pc;
1414 if (strcmp (dip -> at_name, "main") == 0) /* FIXME: hardwired name */
1416 main_scope_lowpc = dip -> at_low_pc;
1417 main_scope_highpc = dip -> at_high_pc;
1419 sym = new_symbol (dip);
1420 openscope (sym, dip -> at_low_pc, dip -> at_high_pc);
1421 process_dies (thisdie + dip -> dielength, enddie, objfile);
1429 read_file_scope -- process all dies within a file scope
1433 Process all dies within a given file scope. We are passed a
1434 pointer to the die information structure for the die which
1435 starts the file scope, and pointers into the raw die data which
1436 mark the range of dies within the file scope.
1438 When the partial symbol table is built, the file offset for the line
1439 number table for each compilation unit is saved in the partial symbol
1440 table entry for that compilation unit. As the symbols for each
1441 compilation unit are read, the line number table is read into memory
1442 and the variable lnbase is set to point to it. Thus all we have to
1443 do is use lnbase to access the line number table for the current
1448 DEFUN(read_file_scope, (dip, thisdie, enddie, objfile),
1449 struct dieinfo *dip AND
1452 struct objfile *objfile)
1454 struct cleanup *back_to;
1456 if (entry_point >= dip -> at_low_pc && entry_point < dip -> at_high_pc)
1458 startup_file_start = dip -> at_low_pc;
1459 startup_file_end = dip -> at_high_pc;
1461 numutypes = (enddie - thisdie) / 4;
1462 utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
1463 back_to = make_cleanup (free, utypes);
1464 (void) memset (utypes, 0, numutypes * sizeof (struct type *));
1466 openscope (NULL, dip -> at_low_pc, dip -> at_high_pc);
1467 decode_line_numbers (lnbase);
1468 process_dies (thisdie + dip -> dielength, enddie, objfile);
1470 end_symtab (dip -> at_name, dip -> at_language, objfile);
1471 do_cleanups (back_to);
1480 start_symtab -- do initialization for starting new symbol table
1484 static void start_symtab (void)
1488 Called whenever we are starting to process dies for a new
1489 compilation unit, to perform initializations. Right now
1490 the only thing we really have to do is initialize storage
1491 space for the line number vector.
1496 DEFUN_VOID (start_symtab)
1500 line_vector_index = 0;
1501 line_vector_length = 1000;
1502 nbytes = sizeof (struct linetable);
1503 nbytes += line_vector_length * sizeof (struct linetable_entry);
1504 line_vector = (struct linetable *) xmalloc (nbytes);
1511 process_dies -- process a range of DWARF Information Entries
1515 static void process_dies (char *thisdie, char *enddie)
1519 Process all DIE's in a specified range. May be (and almost
1520 certainly will be) called recursively.
1524 DEFUN(process_dies, (thisdie, enddie, objfile),
1525 char *thisdie AND char *enddie AND struct objfile *objfile)
1530 while (thisdie < enddie)
1532 basicdieinfo (&di, thisdie);
1533 if (di.dielength < sizeof (long))
1537 else if (di.dietag == TAG_padding)
1539 nextdie = thisdie + di.dielength;
1543 completedieinfo (&di);
1544 if (di.at_sibling != 0)
1546 nextdie = dbbase + di.at_sibling - dbroff;
1550 nextdie = thisdie + di.dielength;
1554 case TAG_compile_unit:
1555 read_file_scope (&di, thisdie, nextdie, objfile);
1557 case TAG_global_subroutine:
1558 case TAG_subroutine:
1559 if (di.has_at_low_pc)
1561 read_func_scope (&di, thisdie, nextdie, objfile);
1564 case TAG_lexical_block:
1565 read_lexical_block_scope (&di, thisdie, nextdie, objfile);
1567 case TAG_structure_type:
1568 case TAG_union_type:
1569 read_structure_scope (&di, thisdie, nextdie);
1571 case TAG_enumeration_type:
1572 read_enumeration (&di, thisdie, nextdie);
1574 case TAG_subroutine_type:
1575 read_subroutine_type (&di, thisdie, nextdie);
1577 case TAG_array_type:
1578 read_array_type (&di);
1581 (void) new_symbol (&di);
1593 end_symtab -- finish processing for a compilation unit
1597 static void end_symtab (char *filename, long language)
1601 Complete the symbol table entry for the current compilation
1602 unit. Make the struct symtab and put it on the list of all
1608 DEFUN(end_symtab, (filename, language, objfile),
1609 char *filename AND long language AND struct objfile *objfile)
1611 struct symtab *symtab;
1612 struct blockvector *blockvector;
1615 /* Ignore a file that has no functions with real debugging info. */
1616 if (global_symbols == NULL && scopetree -> block == NULL)
1620 line_vector_length = -1;
1621 freescope (scopetree);
1622 scope = scopetree = NULL;
1625 /* Create the blockvector that points to all the file's blocks. */
1627 blockvector = make_blockvector ();
1629 /* Now create the symtab object for this source file. */
1631 symtab = allocate_symtab (savestring (filename, strlen (filename)),
1634 symtab -> free_ptr = 0;
1636 /* Fill in its components. */
1637 symtab -> blockvector = blockvector;
1638 symtab -> free_code = free_linetable;
1640 /* Save the line number information. */
1642 line_vector -> nitems = line_vector_index;
1643 nbytes = sizeof (struct linetable);
1644 if (line_vector_index > 1)
1646 nbytes += (line_vector_index - 1) * sizeof (struct linetable_entry);
1648 symtab -> linetable = (struct linetable *) xrealloc (line_vector, nbytes);
1650 /* FIXME: The following may need to be expanded for other languages */
1655 symtab -> language = language_c;
1657 case LANG_C_PLUS_PLUS:
1658 symtab -> language = language_cplus;
1664 /* Link the new symtab into the list of such. */
1665 symtab -> next = symtab_list;
1666 symtab_list = symtab;
1668 /* Recursively free the scope tree */
1669 freescope (scopetree);
1670 scope = scopetree = NULL;
1672 /* Reinitialize for beginning of new file. */
1674 line_vector_length = -1;
1681 scopecount -- count the number of enclosed scopes
1685 static int scopecount (struct scopenode *node)
1689 Given pointer to a node, compute the size of the subtree which is
1690 rooted in this node, which also happens to be the number of scopes
1695 DEFUN(scopecount, (node), struct scopenode *node)
1701 count += scopecount (node -> child);
1702 count += scopecount (node -> sibling);
1712 openscope -- start a new lexical block scope
1716 static void openscope (struct symbol *namesym, CORE_ADDR lowpc,
1721 Start a new scope by allocating a new scopenode, adding it as the
1722 next child of the current scope (if any) or as the root of the
1723 scope tree, and then making the new node the current scope node.
1727 DEFUN(openscope, (namesym, lowpc, highpc),
1728 struct symbol *namesym AND
1732 struct scopenode *new;
1733 struct scopenode *child;
1735 new = (struct scopenode *) xmalloc (sizeof (*new));
1736 (void) memset (new, 0, sizeof (*new));
1737 new -> namesym = namesym;
1738 new -> lowpc = lowpc;
1739 new -> highpc = highpc;
1744 else if ((child = scope -> child) == NULL)
1746 scope -> child = new;
1747 new -> parent = scope;
1751 while (child -> sibling != NULL)
1753 child = child -> sibling;
1755 child -> sibling = new;
1756 new -> parent = scope;
1765 freescope -- free a scope tree rooted at the given node
1769 static void freescope (struct scopenode *node)
1773 Given a pointer to a node in the scope tree, free the subtree
1774 rooted at that node. First free all the children and sibling
1775 nodes, and then the node itself. Used primarily for cleaning
1776 up after ourselves and returning memory to the system.
1780 DEFUN(freescope, (node), struct scopenode *node)
1784 freescope (node -> child);
1785 freescope (node -> sibling);
1794 buildblock -- build a new block from pending symbols list
1798 static struct block *buildblock (struct pending_symbol *syms)
1802 Given a pointer to a list of symbols, build a new block and free
1803 the symbol list structure. Also check each symbol to see if it
1804 is the special symbol that flags that this block was compiled by
1805 gcc, and if so, mark the block appropriately.
1808 static struct block *
1809 DEFUN(buildblock, (syms), struct pending_symbol *syms)
1811 struct pending_symbol *next, *next1;
1813 struct block *newblock;
1816 for (next = syms, i = 0 ; next ; next = next -> next, i++) {;}
1818 /* Allocate a new block */
1820 nbytes = sizeof (struct block);
1823 nbytes += (i - 1) * sizeof (struct symbol *);
1825 newblock = (struct block *) obstack_alloc (symbol_obstack, nbytes);
1826 (void) memset (newblock, 0, nbytes);
1828 /* Copy the symbols into the block. */
1830 BLOCK_NSYMS (newblock) = i;
1831 for (next = syms ; next ; next = next -> next)
1833 BLOCK_SYM (newblock, --i) = next -> symbol;
1834 if (STREQ (GCC_COMPILED_FLAG_SYMBOL, SYMBOL_NAME (next -> symbol)) ||
1835 STREQ (GCC2_COMPILED_FLAG_SYMBOL, SYMBOL_NAME (next -> symbol)))
1837 BLOCK_GCC_COMPILED (newblock) = 1;
1841 /* Now free the links of the list, and empty the list. */
1843 for (next = syms ; next ; next = next1)
1845 next1 = next -> next;
1856 closescope -- close a lexical block scope
1860 static void closescope (void)
1864 Close the current lexical block scope. Closing the current scope
1865 is as simple as moving the current scope pointer up to the parent
1866 of the current scope pointer. But we also take this opportunity
1867 to build the block for the current scope first, since we now have
1868 all of it's symbols.
1872 DEFUN_VOID(closescope)
1874 struct scopenode *child;
1878 error ("DWARF parse error, too many close scopes");
1882 if (scope -> parent == NULL)
1884 global_symbol_block = buildblock (global_symbols);
1885 global_symbols = NULL;
1886 BLOCK_START (global_symbol_block) = scope -> lowpc + baseaddr;
1887 BLOCK_END (global_symbol_block) = scope -> highpc + baseaddr;
1889 scope -> block = buildblock (scope -> symbols);
1890 scope -> symbols = NULL;
1891 BLOCK_START (scope -> block) = scope -> lowpc + baseaddr;
1892 BLOCK_END (scope -> block) = scope -> highpc + baseaddr;
1894 /* Put the local block in as the value of the symbol that names it. */
1896 if (scope -> namesym)
1898 SYMBOL_BLOCK_VALUE (scope -> namesym) = scope -> block;
1899 BLOCK_FUNCTION (scope -> block) = scope -> namesym;
1902 /* Install this scope's local block as the superblock of all child
1905 for (child = scope -> child ; child ; child = child -> sibling)
1907 BLOCK_SUPERBLOCK (child -> block) = scope -> block;
1910 scope = scope -> parent;
1918 record_line -- record a line number entry in the line vector
1922 static void record_line (int line, CORE_ADDR pc)
1926 Given a line number and the corresponding pc value, record
1927 this pair in the line number vector, expanding the vector as
1932 DEFUN(record_line, (line, pc), int line AND CORE_ADDR pc)
1934 struct linetable_entry *e;
1937 /* Make sure line vector is big enough. */
1939 if (line_vector_index + 2 >= line_vector_length)
1941 line_vector_length *= 2;
1942 nbytes = sizeof (struct linetable);
1943 nbytes += (line_vector_length * sizeof (struct linetable_entry));
1944 line_vector = (struct linetable *) xrealloc (line_vector, nbytes);
1946 e = line_vector -> item + line_vector_index++;
1955 decode_line_numbers -- decode a line number table fragment
1959 static void decode_line_numbers (char *tblscan, char *tblend,
1960 long length, long base, long line, long pc)
1964 Translate the DWARF line number information to gdb form.
1966 The ".line" section contains one or more line number tables, one for
1967 each ".line" section from the objects that were linked.
1969 The AT_stmt_list attribute for each TAG_source_file entry in the
1970 ".debug" section contains the offset into the ".line" section for the
1971 start of the table for that file.
1973 The table itself has the following structure:
1975 <table length><base address><source statement entry>
1976 4 bytes 4 bytes 10 bytes
1978 The table length is the total size of the table, including the 4 bytes
1979 for the length information.
1981 The base address is the address of the first instruction generated
1982 for the source file.
1984 Each source statement entry has the following structure:
1986 <line number><statement position><address delta>
1987 4 bytes 2 bytes 4 bytes
1989 The line number is relative to the start of the file, starting with
1992 The statement position either -1 (0xFFFF) or the number of characters
1993 from the beginning of the line to the beginning of the statement.
1995 The address delta is the difference between the base address and
1996 the address of the first instruction for the statement.
1998 Note that we must copy the bytes from the packed table to our local
1999 variables before attempting to use them, to avoid alignment problems
2000 on some machines, particularly RISC processors.
2004 Does gdb expect the line numbers to be sorted? They are now by
2005 chance/luck, but are not required to be. (FIXME)
2007 The line with number 0 is unused, gdb apparently can discover the
2008 span of the last line some other way. How? (FIXME)
2012 DEFUN(decode_line_numbers, (linetable), char *linetable)
2021 if (linetable != NULL)
2023 tblscan = tblend = linetable;
2024 (void) memcpy (&length, tblscan, sizeof (long));
2025 tblscan += sizeof (long);
2027 (void) memcpy (&base, tblscan, sizeof (long));
2029 tblscan += sizeof (long);
2030 while (tblscan < tblend)
2032 (void) memcpy (&line, tblscan, sizeof (long));
2033 tblscan += sizeof (long) + sizeof (short);
2034 (void) memcpy (&pc, tblscan, sizeof (long));
2035 tblscan += sizeof (long);
2039 record_line (line, pc);
2049 add_symbol_to_list -- add a symbol to head of current symbol list
2053 static void add_symbol_to_list (struct symbol *symbol, struct
2054 pending_symbol **listhead)
2058 Given a pointer to a symbol and a pointer to a pointer to a
2059 list of symbols, add this symbol as the current head of the
2060 list. Typically used for example to add a symbol to the
2061 symbol list for the current scope.
2066 DEFUN(add_symbol_to_list, (symbol, listhead),
2067 struct symbol *symbol AND struct pending_symbol **listhead)
2069 struct pending_symbol *link;
2073 link = (struct pending_symbol *) xmalloc (sizeof (*link));
2074 link -> next = *listhead;
2075 link -> symbol = symbol;
2084 gatherblocks -- walk a scope tree and build block vectors
2088 static struct block **gatherblocks (struct block **dest,
2089 struct scopenode *node)
2093 Recursively walk a scope tree rooted in the given node, adding blocks
2094 to the array pointed to by DEST, in preorder. I.E., first we add the
2095 block for the current scope, then all the blocks for child scopes,
2096 and finally all the blocks for sibling scopes.
2099 static struct block **
2100 DEFUN(gatherblocks, (dest, node),
2101 struct block **dest AND struct scopenode *node)
2105 *dest++ = node -> block;
2106 dest = gatherblocks (dest, node -> child);
2107 dest = gatherblocks (dest, node -> sibling);
2116 make_blockvector -- make a block vector from current scope tree
2120 static struct blockvector *make_blockvector (void)
2124 Make a blockvector from all the blocks in the current scope tree.
2125 The first block is always the global symbol block, followed by the
2126 block for the root of the scope tree which is the local symbol block,
2127 followed by all the remaining blocks in the scope tree, which are all
2132 Note that since the root node of the scope tree is created at the time
2133 each file scope is entered, there are always at least two blocks,
2134 neither of which may have any symbols, but always contribute a block
2135 to the block vector. So the test for number of blocks greater than 1
2136 below is unnecessary given bug free code.
2138 The resulting block structure varies slightly from that produced
2139 by dbxread.c, in that block 0 and block 1 are sibling blocks while
2140 with dbxread.c, block 1 is a child of block 0. This does not
2141 seem to cause any problems, but probably should be fixed. (FIXME)
2144 static struct blockvector *
2145 DEFUN_VOID(make_blockvector)
2147 struct blockvector *blockvector = NULL;
2151 /* Recursively walk down the tree, counting the number of blocks.
2152 Then add one to account for the global's symbol block */
2154 i = scopecount (scopetree) + 1;
2155 nbytes = sizeof (struct blockvector);
2158 nbytes += (i - 1) * sizeof (struct block *);
2160 blockvector = (struct blockvector *)
2161 obstack_alloc (symbol_obstack, nbytes);
2163 /* Copy the blocks into the blockvector. */
2165 BLOCKVECTOR_NBLOCKS (blockvector) = i;
2166 BLOCKVECTOR_BLOCK (blockvector, 0) = global_symbol_block;
2167 gatherblocks (&BLOCKVECTOR_BLOCK (blockvector, 1), scopetree);
2169 return (blockvector);
2176 locval -- compute the value of a location attribute
2180 static int locval (char *loc)
2184 Given pointer to a string of bytes that define a location, compute
2185 the location and return the value.
2187 When computing values involving the current value of the frame pointer,
2188 the value zero is used, which results in a value relative to the frame
2189 pointer, rather than the absolute value. This is what GDB wants
2192 When the result is a register number, the global isreg flag is set,
2193 otherwise it is cleared. This is a kludge until we figure out a better
2194 way to handle the problem. Gdb's design does not mesh well with the
2195 DWARF notion of a location computing interpreter, which is a shame
2196 because the flexibility goes unused.
2200 Note that stack[0] is unused except as a default error return.
2201 Note that stack overflow is not yet handled.
2205 DEFUN(locval, (loc), char *loc)
2207 unsigned short nbytes;
2213 (void) memcpy (&nbytes, loc, sizeof (short));
2214 end = loc + sizeof (short) + nbytes;
2218 for (loc += sizeof (short); loc < end; loc += sizeof (long))
2226 /* push register (number) */
2227 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2231 /* push value of register (number) */
2232 /* Actually, we compute the value as if register has 0 */
2233 (void) memcpy (®no, loc, sizeof (long));
2236 stack[++stacki] = 0;
2240 stack[++stacki] = 0;
2241 SQUAWK (("BASEREG %d not handled!", regno));
2245 /* push address (relocated address) */
2246 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2249 /* push constant (number) */
2250 (void) memcpy (&stack[++stacki], loc, sizeof (long));
2253 /* pop, deref and push 2 bytes (as a long) */
2254 SQUAWK (("OP_DEREF2 address %#x not handled", stack[stacki]));
2256 case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
2257 SQUAWK (("OP_DEREF4 address %#x not handled", stack[stacki]));
2259 case OP_ADD: /* pop top 2 items, add, push result */
2260 stack[stacki - 1] += stack[stacki];
2265 return (stack[stacki]);
2272 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2276 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2280 OFFSET is a relocation offset which gets added to each symbol (FIXME).
2283 static struct symtab *
2284 DEFUN(read_ofile_symtab, (pst),
2285 struct partial_symtab *pst)
2287 struct cleanup *back_to;
2290 bfd *abfd = pst->objfile->obfd;
2292 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2293 unit, seek to the location in the file, and read in all the DIE's. */
2296 dbbase = xmalloc (DBLENGTH(pst));
2297 dbroff = DBROFF(pst);
2298 foffset = DBFOFF(pst) + dbroff;
2299 if (bfd_seek (abfd, foffset, 0) ||
2300 (bfd_read (dbbase, DBLENGTH(pst), 1, abfd) != DBLENGTH(pst)))
2303 error ("can't read DWARF data");
2305 back_to = make_cleanup (free, dbbase);
2307 /* If there is a line number table associated with this compilation unit
2308 then read the first long word from the line number table fragment, which
2309 contains the size of the fragment in bytes (including the long word
2310 itself). Allocate a buffer for the fragment and read it in for future
2316 if (bfd_seek (abfd, LNFOFF (pst), 0) ||
2317 (bfd_read (&lnsize, sizeof(long), 1, abfd) != sizeof(long)))
2319 error ("can't read DWARF line number table size");
2321 lnbase = xmalloc (lnsize);
2322 if (bfd_seek (abfd, LNFOFF (pst), 0) ||
2323 (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
2326 error ("can't read DWARF line numbers");
2328 make_cleanup (free, lnbase);
2331 process_dies (dbbase, dbbase + DBLENGTH(pst), pst->objfile);
2332 do_cleanups (back_to);
2333 return (symtab_list);
2340 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2344 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2348 Called once for each partial symbol table entry that needs to be
2349 expanded into a full symbol table entry.
2354 DEFUN(psymtab_to_symtab_1,
2356 struct partial_symtab *pst)
2366 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
2371 /* Read in all partial symtabs on which this one is dependent */
2372 for (i = 0; i < pst -> number_of_dependencies; i++)
2373 if (!pst -> dependencies[i] -> readin)
2375 /* Inform about additional files that need to be read in. */
2378 fputs_filtered (" ", stdout);
2380 fputs_filtered ("and ", stdout);
2382 printf_filtered ("%s...", pst -> dependencies[i] -> filename);
2383 wrap_here (""); /* Flush output */
2386 psymtab_to_symtab_1 (pst -> dependencies[i]);
2389 if (DBLENGTH(pst)) /* Otherwise it's a dummy */
2391 /* Init stuff necessary for reading in symbols */
2392 pst -> symtab = read_ofile_symtab (pst);
2395 printf_filtered ("%d DIE's, sorting...", diecount);
2398 sort_symtab_syms (pst -> symtab);
2407 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2411 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2415 This is the DWARF support entry point for building a full symbol
2416 table entry from a partial symbol table entry. We are passed a
2417 pointer to the partial symbol table entry that needs to be expanded.
2422 DEFUN(dwarf_psymtab_to_symtab, (pst), struct partial_symtab *pst)
2433 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
2438 if (DBLENGTH(pst) || pst -> number_of_dependencies)
2440 /* Print the message now, before starting serious work, to avoid
2441 disconcerting pauses. */
2444 printf_filtered ("Reading in symbols for %s...", pst -> filename);
2448 psymtab_to_symtab_1 (pst);
2450 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2451 we need to do an equivalent or is this something peculiar to
2452 stabs/a.out format. */
2453 /* Match with global symbols. This only needs to be done once,
2454 after all of the symtabs and dependencies have been read in. */
2455 scan_file_globals ();
2458 /* Finish up the debug error message. */
2461 printf_filtered ("done.\n");
2470 init_psymbol_list -- initialize storage for partial symbols
2474 static void init_psymbol_list (int total_symbols)
2478 Initializes storage for all of the partial symbols that will be
2479 created by dwarf_build_psymtabs and subsidiaries.
2483 DEFUN(init_psymbol_list, (total_symbols), int total_symbols)
2485 /* Free any previously allocated psymbol lists. */
2487 if (global_psymbols.list)
2489 free (global_psymbols.list);
2491 if (static_psymbols.list)
2493 free (static_psymbols.list);
2496 /* Current best guess is that there are approximately a twentieth
2497 of the total symbols (in a debugging file) are global or static
2500 global_psymbols.size = total_symbols / 10;
2501 static_psymbols.size = total_symbols / 10;
2502 global_psymbols.next = global_psymbols.list = (struct partial_symbol *)
2503 xmalloc (global_psymbols.size * sizeof (struct partial_symbol));
2504 static_psymbols.next = static_psymbols.list = (struct partial_symbol *)
2505 xmalloc (static_psymbols.size * sizeof (struct partial_symbol));
2512 start_psymtab -- allocate and partially fill a partial symtab entry
2516 Allocate and partially fill a partial symtab. It will be completely
2517 filled at the end of the symbol list.
2519 SYMFILE_NAME is the name of the symbol-file we are reading from, and
2520 ADDR is the address relative to which its symbols are (incremental)
2521 or 0 (normal). FILENAME is the name of the compilation unit that
2522 these symbols were defined in, and they appear starting a address
2523 TEXTLOW. DBROFF is the absolute file offset in SYMFILE_NAME where
2524 the full symbols can be read for compilation unit FILENAME.
2525 GLOBAL_SYMS and STATIC_SYMS are pointers to the current end of the
2530 static struct partial_symtab *
2531 DEFUN(start_psymtab,
2532 (objfile, addr, filename, textlow, texthigh, dbfoff, curoff,
2533 culength, lnfoff, global_syms, static_syms),
2534 struct objfile *objfile AND
2537 CORE_ADDR textlow AND
2538 CORE_ADDR texthigh AND
2543 struct partial_symbol *global_syms AND
2544 struct partial_symbol *static_syms)
2546 struct partial_symtab *result;
2548 result = (struct partial_symtab *)
2549 obstack_alloc (psymbol_obstack, sizeof (struct partial_symtab));
2550 (void) memset (result, 0, sizeof (struct partial_symtab));
2551 result -> addr = addr;
2552 result -> objfile = objfile;
2553 result -> filename = create_name (filename, psymbol_obstack);
2554 result -> textlow = textlow;
2555 result -> texthigh = texthigh;
2556 result -> read_symtab_private = (char *) obstack_alloc (psymbol_obstack,
2557 sizeof (struct dwfinfo));
2558 DBFOFF (result) = dbfoff;
2559 DBROFF (result) = curoff;
2560 DBLENGTH (result) = culength;
2561 LNFOFF (result) = lnfoff;
2562 result -> readin = 0;
2563 result -> symtab = NULL;
2564 result -> read_symtab = dwarf_psymtab_to_symtab;
2565 result -> globals_offset = global_syms - global_psymbols.list;
2566 result -> statics_offset = static_syms - static_psymbols.list;
2568 result->n_global_syms = 0;
2569 result->n_static_syms = 0;
2578 add_psymbol_to_list -- add a partial symbol to given list
2582 Add a partial symbol to one of the partial symbol vectors (pointed to
2583 by listp). The vector is grown as necessary.
2588 DEFUN(add_psymbol_to_list,
2589 (listp, name, space, class, value),
2590 struct psymbol_allocation_list *listp AND
2592 enum namespace space AND
2593 enum address_class class AND
2596 struct partial_symbol *psym;
2599 if (listp -> next >= listp -> list + listp -> size)
2601 newsize = listp -> size * 2;
2602 listp -> list = (struct partial_symbol *)
2603 xrealloc (listp -> list, (newsize * sizeof (struct partial_symbol)));
2604 /* Next assumes we only went one over. Should be good if program works
2606 listp -> next = listp -> list + listp -> size;
2607 listp -> size = newsize;
2609 psym = listp -> next++;
2610 SYMBOL_NAME (psym) = create_name (name, psymbol_obstack);
2611 SYMBOL_NAMESPACE (psym) = space;
2612 SYMBOL_CLASS (psym) = class;
2613 SYMBOL_VALUE (psym) = value;
2620 add_partial_symbol -- add symbol to partial symbol table
2624 Given a DIE, if it is one of the types that we want to
2625 add to a partial symbol table, finish filling in the die info
2626 and then add a partial symbol table entry for it.
2631 DEFUN(add_partial_symbol, (dip), struct dieinfo *dip)
2633 switch (dip -> dietag)
2635 case TAG_global_subroutine:
2636 record_misc_function (dip -> at_name, dip -> at_low_pc, mf_text);
2637 add_psymbol_to_list (&global_psymbols, dip -> at_name, VAR_NAMESPACE,
2638 LOC_BLOCK, dip -> at_low_pc);
2640 case TAG_global_variable:
2641 record_misc_function (dip -> at_name, locval (dip -> at_location),
2643 add_psymbol_to_list (&global_psymbols, dip -> at_name, VAR_NAMESPACE,
2646 case TAG_subroutine:
2647 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2648 LOC_BLOCK, dip -> at_low_pc);
2650 case TAG_local_variable:
2651 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2655 add_psymbol_to_list (&static_psymbols, dip -> at_name, VAR_NAMESPACE,
2658 case TAG_structure_type:
2659 case TAG_union_type:
2660 case TAG_enumeration_type:
2661 add_psymbol_to_list (&static_psymbols, dip -> at_name, STRUCT_NAMESPACE,
2671 scan_partial_symbols -- scan DIE's within a single compilation unit
2675 Process the DIE's within a single compilation unit, looking for
2676 interesting DIE's that contribute to the partial symbol table entry
2677 for this compilation unit. Since we cannot follow any sibling
2678 chains without reading the complete DIE info for every DIE,
2679 it is probably faster to just sequentially check each one to
2680 see if it is one of the types we are interested in, and if
2681 so, then extracting all the attributes info and generating a
2682 partial symbol table entry.
2686 Don't attempt to add anonymous structures, unions, or enumerations
2687 since they have no name. Also, for variables and subroutines,
2688 check that this is the place where the actual definition occurs,
2689 rather than just a reference to an external.
2694 DEFUN(scan_partial_symbols, (thisdie, enddie), char *thisdie AND char *enddie)
2699 while (thisdie < enddie)
2701 basicdieinfo (&di, thisdie);
2702 if (di.dielength < sizeof (long))
2708 nextdie = thisdie + di.dielength;
2711 case TAG_global_subroutine:
2712 case TAG_subroutine:
2713 case TAG_global_variable:
2714 case TAG_local_variable:
2715 completedieinfo (&di);
2716 if (di.at_name && (di.has_at_low_pc || di.at_location))
2718 add_partial_symbol (&di);
2722 case TAG_structure_type:
2723 case TAG_union_type:
2724 case TAG_enumeration_type:
2725 completedieinfo (&di);
2728 add_partial_symbol (&di);
2741 scan_compilation_units -- build a psymtab entry for each compilation
2745 This is the top level dwarf parsing routine for building partial
2748 It scans from the beginning of the DWARF table looking for the first
2749 TAG_compile_unit DIE, and then follows the sibling chain to locate
2750 each additional TAG_compile_unit DIE.
2752 For each TAG_compile_unit DIE it creates a partial symtab structure,
2753 calls a subordinate routine to collect all the compilation unit's
2754 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2755 new partial symtab structure into the partial symbol table. It also
2756 records the appropriate information in the partial symbol table entry
2757 to allow the chunk of DIE's and line number table for this compilation
2758 unit to be located and re-read later, to generate a complete symbol
2759 table entry for the compilation unit.
2761 Thus it effectively partitions up a chunk of DIE's for multiple
2762 compilation units into smaller DIE chunks and line number tables,
2763 and associates them with a partial symbol table entry.
2767 If any compilation unit has no line number table associated with
2768 it for some reason (a missing at_stmt_list attribute, rather than
2769 just one with a value of zero, which is valid) then we ensure that
2770 the recorded file offset is zero so that the routine which later
2771 reads line number table fragments knows that there is no fragment
2781 DEFUN(scan_compilation_units,
2782 (filename, addr, thisdie, enddie, dbfoff, lnoffset, objfile),
2787 unsigned int dbfoff AND
2788 unsigned int lnoffset AND
2789 struct objfile *objfile)
2793 struct partial_symtab *pst;
2798 while (thisdie < enddie)
2800 basicdieinfo (&di, thisdie);
2801 if (di.dielength < sizeof (long))
2805 else if (di.dietag != TAG_compile_unit)
2807 nextdie = thisdie + di.dielength;
2811 completedieinfo (&di);
2812 if (di.at_sibling != 0)
2814 nextdie = dbbase + di.at_sibling - dbroff;
2818 nextdie = thisdie + di.dielength;
2820 curoff = thisdie - dbbase;
2821 culength = nextdie - thisdie;
2822 curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0;
2823 pst = start_psymtab (objfile, addr, di.at_name,
2824 di.at_low_pc, di.at_high_pc,
2825 dbfoff, curoff, culength, curlnoffset,
2826 global_psymbols.next,
2827 static_psymbols.next);
2828 scan_partial_symbols (thisdie + di.dielength, nextdie);
2829 pst -> n_global_syms = global_psymbols.next -
2830 (global_psymbols.list + pst -> globals_offset);
2831 pst -> n_static_syms = static_psymbols.next -
2832 (static_psymbols.list + pst -> statics_offset);
2833 /* Sort the global list; don't sort the static list */
2834 qsort (global_psymbols.list + pst -> globals_offset,
2835 pst -> n_global_syms, sizeof (struct partial_symbol),
2837 /* If there is already a psymtab or symtab for a file of this name,
2838 remove it. (If there is a symtab, more drastic things also
2839 happen.) This happens in VxWorks. */
2840 free_named_symtabs (pst -> filename);
2841 /* Place the partial symtab on the partial symtab list */
2842 pst -> next = partial_symtab_list;
2843 partial_symtab_list = pst;
2853 new_symbol -- make a symbol table entry for a new symbol
2857 static struct symbol *new_symbol (struct dieinfo *dip)
2861 Given a pointer to a DWARF information entry, figure out if we need
2862 to make a symbol table entry for it, and if so, create a new entry
2863 and return a pointer to it.
2866 static struct symbol *
2867 DEFUN(new_symbol, (dip), struct dieinfo *dip)
2869 struct symbol *sym = NULL;
2871 if (dip -> at_name != NULL)
2873 sym = (struct symbol *) obstack_alloc (symbol_obstack,
2874 sizeof (struct symbol));
2875 (void) memset (sym, 0, sizeof (struct symbol));
2876 SYMBOL_NAME (sym) = create_name (dip -> at_name, symbol_obstack);
2877 /* default assumptions */
2878 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2879 SYMBOL_CLASS (sym) = LOC_STATIC;
2880 SYMBOL_TYPE (sym) = decode_die_type (dip);
2881 switch (dip -> dietag)
2884 SYMBOL_VALUE (sym) = dip -> at_low_pc + baseaddr;
2885 SYMBOL_CLASS (sym) = LOC_LABEL;
2887 case TAG_global_subroutine:
2888 case TAG_subroutine:
2889 SYMBOL_VALUE (sym) = dip -> at_low_pc + baseaddr;
2890 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
2891 SYMBOL_CLASS (sym) = LOC_BLOCK;
2892 if (dip -> dietag == TAG_global_subroutine)
2894 add_symbol_to_list (sym, &global_symbols);
2898 add_symbol_to_list (sym, &scope -> symbols);
2901 case TAG_global_variable:
2902 case TAG_local_variable:
2903 if (dip -> at_location != NULL)
2905 SYMBOL_VALUE (sym) = locval (dip -> at_location);
2907 if (dip -> dietag == TAG_global_variable)
2909 add_symbol_to_list (sym, &global_symbols);
2910 SYMBOL_CLASS (sym) = LOC_STATIC;
2911 SYMBOL_VALUE (sym) += baseaddr;
2915 add_symbol_to_list (sym, &scope -> symbols);
2916 if (scope -> parent != NULL)
2920 SYMBOL_CLASS (sym) = LOC_REGISTER;
2924 SYMBOL_CLASS (sym) = LOC_LOCAL;
2929 SYMBOL_CLASS (sym) = LOC_STATIC;
2930 SYMBOL_VALUE (sym) += baseaddr;
2934 case TAG_formal_parameter:
2935 if (dip -> at_location != NULL)
2937 SYMBOL_VALUE (sym) = locval (dip -> at_location);
2939 add_symbol_to_list (sym, &scope -> symbols);
2942 SYMBOL_CLASS (sym) = LOC_REGPARM;
2946 SYMBOL_CLASS (sym) = LOC_ARG;
2949 case TAG_unspecified_parameters:
2950 /* From varargs functions; gdb doesn't seem to have any interest in
2951 this information, so just ignore it for now. (FIXME?) */
2953 case TAG_structure_type:
2954 case TAG_union_type:
2955 case TAG_enumeration_type:
2956 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2957 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
2958 add_symbol_to_list (sym, &scope -> symbols);
2961 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2962 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2963 add_symbol_to_list (sym, &scope -> symbols);
2966 /* Not a tag we recognize. Hopefully we aren't processing trash
2967 data, but since we must specifically ignore things we don't
2968 recognize, there is nothing else we should do at this point. */
2979 decode_mod_fund_type -- decode a modified fundamental type
2983 static struct type *decode_mod_fund_type (char *typedata)
2987 Decode a block of data containing a modified fundamental
2988 type specification. TYPEDATA is a pointer to the block,
2989 which consists of a two byte length, containing the size
2990 of the rest of the block. At the end of the block is a
2991 two byte value that gives the fundamental type. Everything
2992 in between are type modifiers.
2994 We simply compute the number of modifiers and call the general
2995 function decode_modified_type to do the actual work.
2998 static struct type *
2999 DEFUN(decode_mod_fund_type, (typedata), char *typedata)
3001 struct type *typep = NULL;
3002 unsigned short modcount;
3003 unsigned char *modifiers;
3005 /* Get the total size of the block, exclusive of the size itself */
3006 (void) memcpy (&modcount, typedata, sizeof (short));
3007 /* Deduct the size of the fundamental type bytes at the end of the block. */
3008 modcount -= sizeof (short);
3009 /* Skip over the two size bytes at the beginning of the block. */
3010 modifiers = (unsigned char *) typedata + sizeof (short);
3011 /* Now do the actual decoding */
3012 typep = decode_modified_type (modifiers, modcount, AT_mod_fund_type);
3020 decode_mod_u_d_type -- decode a modified user defined type
3024 static struct type *decode_mod_u_d_type (char *typedata)
3028 Decode a block of data containing a modified user defined
3029 type specification. TYPEDATA is a pointer to the block,
3030 which consists of a two byte length, containing the size
3031 of the rest of the block. At the end of the block is a
3032 four byte value that gives a reference to a user defined type.
3033 Everything in between are type modifiers.
3035 We simply compute the number of modifiers and call the general
3036 function decode_modified_type to do the actual work.
3039 static struct type *
3040 DEFUN(decode_mod_u_d_type, (typedata), char *typedata)
3042 struct type *typep = NULL;
3043 unsigned short modcount;
3044 unsigned char *modifiers;
3046 /* Get the total size of the block, exclusive of the size itself */
3047 (void) memcpy (&modcount, typedata, sizeof (short));
3048 /* Deduct the size of the reference type bytes at the end of the block. */
3049 modcount -= sizeof (long);
3050 /* Skip over the two size bytes at the beginning of the block. */
3051 modifiers = (unsigned char *) typedata + sizeof (short);
3052 /* Now do the actual decoding */
3053 typep = decode_modified_type (modifiers, modcount, AT_mod_u_d_type);
3061 decode_modified_type -- decode modified user or fundamental type
3065 static struct type *decode_modified_type (unsigned char *modifiers,
3066 unsigned short modcount, int mtype)
3070 Decode a modified type, either a modified fundamental type or
3071 a modified user defined type. MODIFIERS is a pointer to the
3072 block of bytes that define MODCOUNT modifiers. Immediately
3073 following the last modifier is a short containing the fundamental
3074 type or a long containing the reference to the user defined
3075 type. Which one is determined by MTYPE, which is either
3076 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3077 type we are generating.
3079 We call ourself recursively to generate each modified type,`
3080 until MODCOUNT reaches zero, at which point we have consumed
3081 all the modifiers and generate either the fundamental type or
3082 user defined type. When the recursion unwinds, each modifier
3083 is applied in turn to generate the full modified type.
3087 If we find a modifier that we don't recognize, and it is not one
3088 of those reserved for application specific use, then we issue a
3089 warning and simply ignore the modifier.
3093 We currently ignore MOD_const and MOD_volatile. (FIXME)
3097 static struct type *
3098 DEFUN(decode_modified_type,
3099 (modifiers, modcount, mtype),
3100 unsigned char *modifiers AND unsigned short modcount AND int mtype)
3102 struct type *typep = NULL;
3103 unsigned short fundtype;
3105 unsigned char modifier;
3111 case AT_mod_fund_type:
3112 (void) memcpy (&fundtype, modifiers, sizeof (short));
3113 typep = decode_fund_type (fundtype);
3115 case AT_mod_u_d_type:
3116 (void) memcpy (&dieref, modifiers, sizeof (DIEREF));
3117 if ((typep = lookup_utype (dieref)) == NULL)
3119 typep = alloc_utype (dieref, NULL);
3123 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype));
3124 typep = builtin_type_int;
3130 modifier = *modifiers++;
3131 typep = decode_modified_type (modifiers, --modcount, mtype);
3134 case MOD_pointer_to:
3135 typep = lookup_pointer_type (typep);
3137 case MOD_reference_to:
3138 typep = lookup_reference_type (typep);
3141 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3144 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3147 if (!(MOD_lo_user <= modifier && modifier <= MOD_hi_user))
3149 SQUAWK (("unknown type modifier %u", modifier));
3161 decode_fund_type -- translate basic DWARF type to gdb base type
3165 Given an integer that is one of the fundamental DWARF types,
3166 translate it to one of the basic internal gdb types and return
3167 a pointer to the appropriate gdb type (a "struct type *").
3171 If we encounter a fundamental type that we are unprepared to
3172 deal with, and it is not in the range of those types defined
3173 as application specific types, then we issue a warning and
3174 treat the type as builtin_type_int.
3177 static struct type *
3178 DEFUN(decode_fund_type, (fundtype), unsigned short fundtype)
3180 struct type *typep = NULL;
3186 typep = builtin_type_void;
3189 case FT_pointer: /* (void *) */
3190 typep = lookup_pointer_type (builtin_type_void);
3194 case FT_signed_char:
3195 typep = builtin_type_char;
3199 case FT_signed_short:
3200 typep = builtin_type_short;
3204 case FT_signed_integer:
3205 case FT_boolean: /* Was FT_set in AT&T version */
3206 typep = builtin_type_int;
3210 case FT_signed_long:
3211 typep = builtin_type_long;
3215 typep = builtin_type_float;
3218 case FT_dbl_prec_float:
3219 typep = builtin_type_double;
3222 case FT_unsigned_char:
3223 typep = builtin_type_unsigned_char;
3226 case FT_unsigned_short:
3227 typep = builtin_type_unsigned_short;
3230 case FT_unsigned_integer:
3231 typep = builtin_type_unsigned_int;
3234 case FT_unsigned_long:
3235 typep = builtin_type_unsigned_long;
3238 case FT_ext_prec_float:
3239 typep = builtin_type_long_double;
3243 typep = builtin_type_complex;
3246 case FT_dbl_prec_complex:
3247 typep = builtin_type_double_complex;
3251 case FT_signed_long_long:
3252 typep = builtin_type_long_long;
3255 case FT_unsigned_long_long:
3256 typep = builtin_type_unsigned_long_long;
3261 if ((typep == NULL) && !(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
3263 SQUAWK (("unexpected fundamental type 0x%x", fundtype));
3264 typep = builtin_type_void;
3274 create_name -- allocate a fresh copy of a string on an obstack
3278 Given a pointer to a string and a pointer to an obstack, allocates
3279 a fresh copy of the string on the specified obstack.
3284 DEFUN(create_name, (name, obstackp), char *name AND struct obstack *obstackp)
3289 length = strlen (name) + 1;
3290 newname = (char *) obstack_alloc (obstackp, length);
3291 (void) strcpy (newname, name);
3299 basicdieinfo -- extract the minimal die info from raw die data
3303 void basicdieinfo (char *diep, struct dieinfo *dip)
3307 Given a pointer to raw DIE data, and a pointer to an instance of a
3308 die info structure, this function extracts the basic information
3309 from the DIE data required to continue processing this DIE, along
3310 with some bookkeeping information about the DIE.
3312 The information we absolutely must have includes the DIE tag,
3313 and the DIE length. If we need the sibling reference, then we
3314 will have to call completedieinfo() to process all the remaining
3317 Note that since there is no guarantee that the data is properly
3318 aligned in memory for the type of access required (indirection
3319 through anything other than a char pointer), we use memcpy to
3320 shuffle data items larger than a char. Possibly inefficient, but
3323 We also take care of some other basic things at this point, such
3324 as ensuring that the instance of the die info structure starts
3325 out completely zero'd and that curdie is initialized for use
3326 in error reporting if we have a problem with the current die.
3330 All DIE's must have at least a valid length, thus the minimum
3331 DIE size is sizeof (long). In order to have a valid tag, the
3332 DIE size must be at least sizeof (short) larger, otherwise they
3333 are forced to be TAG_padding DIES.
3335 Padding DIES must be at least sizeof(long) in length, implying that
3336 if a padding DIE is used for alignment and the amount needed is less
3337 than sizeof(long) then the padding DIE has to be big enough to align
3338 to the next alignment boundry.
3342 DEFUN(basicdieinfo, (dip, diep), struct dieinfo *dip AND char *diep)
3345 (void) memset (dip, 0, sizeof (struct dieinfo));
3347 dip -> dieref = dbroff + (diep - dbbase);
3348 (void) memcpy (&dip -> dielength, diep, sizeof (long));
3349 if (dip -> dielength < sizeof (long))
3351 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip -> dielength);
3353 else if (dip -> dielength < (sizeof (long) + sizeof (short)))
3355 dip -> dietag = TAG_padding;
3359 (void) memcpy (&dip -> dietag, diep + sizeof (long), sizeof (short));
3367 completedieinfo -- finish reading the information for a given DIE
3371 void completedieinfo (struct dieinfo *dip)
3375 Given a pointer to an already partially initialized die info structure,
3376 scan the raw DIE data and finish filling in the die info structure
3377 from the various attributes found.
3379 Note that since there is no guarantee that the data is properly
3380 aligned in memory for the type of access required (indirection
3381 through anything other than a char pointer), we use memcpy to
3382 shuffle data items larger than a char. Possibly inefficient, but
3387 Each time we are called, we increment the diecount variable, which
3388 keeps an approximate count of the number of dies processed for
3389 each compilation unit. This information is presented to the user
3390 if the info_verbose flag is set.
3395 DEFUN(completedieinfo, (dip), struct dieinfo *dip)
3397 char *diep; /* Current pointer into raw DIE data */
3398 char *end; /* Terminate DIE scan here */
3399 unsigned short attr; /* Current attribute being scanned */
3400 unsigned short form; /* Form of the attribute */
3401 short block2sz; /* Size of a block2 attribute field */
3402 long block4sz; /* Size of a block4 attribute field */
3406 end = diep + dip -> dielength;
3407 diep += sizeof (long) + sizeof (short);
3410 (void) memcpy (&attr, diep, sizeof (short));
3411 diep += sizeof (short);
3415 (void) memcpy (&dip -> at_fund_type, diep, sizeof (short));
3418 (void) memcpy (&dip -> at_ordering, diep, sizeof (short));
3421 (void) memcpy (&dip -> at_bit_offset, diep, sizeof (short));
3424 (void) memcpy (&dip -> at_visibility, diep, sizeof (short));
3427 (void) memcpy (&dip -> at_sibling, diep, sizeof (long));
3430 (void) memcpy (&dip -> at_stmt_list, diep, sizeof (long));
3431 dip -> has_at_stmt_list = 1;
3434 (void) memcpy (&dip -> at_low_pc, diep, sizeof (long));
3435 dip -> has_at_low_pc = 1;
3438 (void) memcpy (&dip -> at_high_pc, diep, sizeof (long));
3441 (void) memcpy (&dip -> at_language, diep, sizeof (long));
3443 case AT_user_def_type:
3444 (void) memcpy (&dip -> at_user_def_type, diep, sizeof (long));
3447 (void) memcpy (&dip -> at_byte_size, diep, sizeof (long));
3450 (void) memcpy (&dip -> at_bit_size, diep, sizeof (long));
3453 (void) memcpy (&dip -> at_member, diep, sizeof (long));
3456 (void) memcpy (&dip -> at_discr, diep, sizeof (long));
3459 (void) memcpy (&dip -> at_import, diep, sizeof (long));
3462 dip -> at_location = diep;
3464 case AT_mod_fund_type:
3465 dip -> at_mod_fund_type = diep;
3467 case AT_subscr_data:
3468 dip -> at_subscr_data = diep;
3470 case AT_mod_u_d_type:
3471 dip -> at_mod_u_d_type = diep;
3473 case AT_element_list:
3474 dip -> at_element_list = diep;
3476 case AT_discr_value:
3477 dip -> at_discr_value = diep;
3479 case AT_string_length:
3480 dip -> at_string_length = diep;
3483 dip -> at_name = diep;
3486 dip -> at_comp_dir = diep;
3489 dip -> at_producer = diep;
3492 (void) memcpy (&dip -> at_frame_base, diep, sizeof (long));
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 /* Found an attribute that we are unprepared to handle. However
3508 it is specifically one of the design goals of DWARF that
3509 consumers should ignore unknown attributes. As long as the
3510 form is one that we recognize (so we know how to skip it),
3511 we can just ignore the unknown attribute. */
3518 diep += sizeof (short);
3521 diep += sizeof (long);
3524 diep += 8 * sizeof (char); /* sizeof (long long) ? */
3528 diep += sizeof (long);
3531 (void) memcpy (&block2sz, diep, sizeof (short));
3532 block2sz += sizeof (short);
3536 (void) memcpy (&block4sz, diep, sizeof (long));
3537 block4sz += sizeof (long);
3541 diep += strlen (diep) + 1;
3544 SQUAWK (("unknown attribute form (0x%x), skipped rest", form));