1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992 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: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
53 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
54 #include "elf/dwarf.h"
58 #ifdef MAINTENANCE /* Define to 1 to compile in some maintenance stuff */
59 #define SQUAWK(stuff) dwarfwarn stuff
64 #ifndef R_FP /* FIXME */
65 #define R_FP 14 /* Kludge to get frame pointer register number */
68 typedef unsigned int DIE_REF
; /* Reference to a DIE */
71 #define GCC_PRODUCER "GNU C "
74 #ifndef GPLUS_PRODUCER
75 #define GPLUS_PRODUCER "GNU C++ "
79 #define LCC_PRODUCER "NCR C/C++ "
82 #ifndef CFRONT_PRODUCER
83 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
86 #define STREQ(a,b) (strcmp(a,b)==0)
87 #define STREQN(a,b,n) (strncmp(a,b,n)==0)
89 /* Flags to target_to_host() that tell whether or not the data object is
90 expected to be signed. Used, for example, when fetching a signed
91 integer in the target environment which is used as a signed integer
92 in the host environment, and the two environments have different sized
93 ints. In this case, *somebody* has to sign extend the smaller sized
96 #define GET_UNSIGNED 0 /* No sign extension required */
97 #define GET_SIGNED 1 /* Sign extension required */
99 /* Defines for things which are specified in the document "DWARF Debugging
100 Information Format" published by UNIX International, Programming Languages
101 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
103 #define SIZEOF_DIE_LENGTH 4
104 #define SIZEOF_DIE_TAG 2
105 #define SIZEOF_ATTRIBUTE 2
106 #define SIZEOF_FORMAT_SPECIFIER 1
107 #define SIZEOF_FMT_FT 2
108 #define SIZEOF_LINETBL_LENGTH 4
109 #define SIZEOF_LINETBL_LINENO 4
110 #define SIZEOF_LINETBL_STMT 2
111 #define SIZEOF_LINETBL_DELTA 4
112 #define SIZEOF_LOC_ATOM_CODE 1
114 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
116 /* Macros that return the sizes of various types of data in the target
119 FIXME: Currently these are just compile time constants (as they are in
120 other parts of gdb as well). They need to be able to get the right size
121 either from the bfd or possibly from the DWARF info. It would be nice if
122 the DWARF producer inserted DIES that describe the fundamental types in
123 the target environment into the DWARF info, similar to the way dbx stabs
124 producers produce information about their fundamental types. */
126 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
127 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
129 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
130 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
131 However, the Issue 2 DWARF specification from AT&T defines it as
132 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
133 For backwards compatibility with the AT&T compiler produced executables
134 we define AT_short_element_list for this variant. */
136 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
138 /* External variables referenced. */
140 extern int info_verbose
; /* From main.c; nonzero => verbose */
141 extern char *warning_pre_print
; /* From utils.c */
143 /* The DWARF debugging information consists of two major pieces,
144 one is a block of DWARF Information Entries (DIE's) and the other
145 is a line number table. The "struct dieinfo" structure contains
146 the information for a single DIE, the one currently being processed.
148 In order to make it easier to randomly access the attribute fields
149 of the current DIE, which are specifically unordered within the DIE,
150 each DIE is scanned and an instance of the "struct dieinfo"
151 structure is initialized.
153 Initialization is done in two levels. The first, done by basicdieinfo(),
154 just initializes those fields that are vital to deciding whether or not
155 to use this DIE, how to skip past it, etc. The second, done by the
156 function completedieinfo(), fills in the rest of the information.
158 Attributes which have block forms are not interpreted at the time
159 the DIE is scanned, instead we just save pointers to the start
160 of their value fields.
162 Some fields have a flag <name>_p that is set when the value of the
163 field is valid (I.E. we found a matching attribute in the DIE). Since
164 we may want to test for the presence of some attributes in the DIE,
165 such as AT_low_pc, without restricting the values of the field,
166 we need someway to note that we found such an attribute.
173 char * die
; /* Pointer to the raw DIE data */
174 unsigned long die_length
; /* Length of the raw DIE data */
175 DIE_REF die_ref
; /* Offset of this DIE */
176 unsigned short die_tag
; /* Tag for this DIE */
177 unsigned long at_padding
;
178 unsigned long at_sibling
;
181 unsigned short at_fund_type
;
182 BLOCK
* at_mod_fund_type
;
183 unsigned long at_user_def_type
;
184 BLOCK
* at_mod_u_d_type
;
185 unsigned short at_ordering
;
186 BLOCK
* at_subscr_data
;
187 unsigned long at_byte_size
;
188 unsigned short at_bit_offset
;
189 unsigned long at_bit_size
;
190 BLOCK
* at_element_list
;
191 unsigned long at_stmt_list
;
192 unsigned long at_low_pc
;
193 unsigned long at_high_pc
;
194 unsigned long at_language
;
195 unsigned long at_member
;
196 unsigned long at_discr
;
197 BLOCK
* at_discr_value
;
198 BLOCK
* at_string_length
;
201 unsigned long at_start_scope
;
202 unsigned long at_stride_size
;
203 unsigned long at_src_info
;
204 char * at_prototyped
;
205 unsigned int has_at_low_pc
:1;
206 unsigned int has_at_stmt_list
:1;
207 unsigned int short_element_list
:1;
210 static int diecount
; /* Approximate count of dies for compilation unit */
211 static struct dieinfo
*curdie
; /* For warnings and such */
213 static char *dbbase
; /* Base pointer to dwarf info */
214 static int dbroff
; /* Relative offset from start of .debug section */
215 static char *lnbase
; /* Base pointer to line section */
216 static int isreg
; /* Kludge to identify register variables */
217 static int offreg
; /* Kludge to identify basereg references */
219 /* This value is added to each symbol value. FIXME: Generalize to
220 the section_offsets structure used by dbxread. */
221 static CORE_ADDR baseaddr
; /* Add to each symbol value */
223 /* The section offsets used in the current psymtab or symtab. FIXME,
224 only used to pass one value (baseaddr) at the moment. */
225 static struct section_offsets
*base_section_offsets
;
227 /* Each partial symbol table entry contains a pointer to private data for the
228 read_symtab() function to use when expanding a partial symbol table entry
229 to a full symbol table entry. For DWARF debugging info, this data is
230 contained in the following structure and macros are provided for easy
231 access to the members given a pointer to a partial symbol table entry.
233 dbfoff Always the absolute file offset to the start of the ".debug"
234 section for the file containing the DIE's being accessed.
236 dbroff Relative offset from the start of the ".debug" access to the
237 first DIE to be accessed. When building the partial symbol
238 table, this value will be zero since we are accessing the
239 entire ".debug" section. When expanding a partial symbol
240 table entry, this value will be the offset to the first
241 DIE for the compilation unit containing the symbol that
242 triggers the expansion.
244 dblength The size of the chunk of DIE's being examined, in bytes.
246 lnfoff The absolute file offset to the line table fragment. Ignored
247 when building partial symbol tables, but used when expanding
248 them, and contains the absolute file offset to the fragment
249 of the ".line" section containing the line numbers for the
250 current compilation unit.
254 int dbfoff
; /* Absolute file offset to start of .debug section */
255 int dbroff
; /* Relative offset from start of .debug section */
256 int dblength
; /* Size of the chunk of DIE's being examined */
257 int lnfoff
; /* Absolute file offset to line table fragment */
260 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
261 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
262 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
263 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
265 /* The generic symbol table building routines have separate lists for
266 file scope symbols and all all other scopes (local scopes). So
267 we need to select the right one to pass to add_symbol_to_list().
268 We do it by keeping a pointer to the correct list in list_in_scope.
270 FIXME: The original dwarf code just treated the file scope as the first
271 local scope, and all other local scopes as nested local scopes, and worked
272 fine. Check to see if we really need to distinguish these in buildsym.c */
274 struct pending
**list_in_scope
= &file_symbols
;
276 /* DIES which have user defined types or modified user defined types refer to
277 other DIES for the type information. Thus we need to associate the offset
278 of a DIE for a user defined type with a pointer to the type information.
280 Originally this was done using a simple but expensive algorithm, with an
281 array of unsorted structures, each containing an offset/type-pointer pair.
282 This array was scanned linearly each time a lookup was done. The result
283 was that gdb was spending over half it's startup time munging through this
284 array of pointers looking for a structure that had the right offset member.
286 The second attempt used the same array of structures, but the array was
287 sorted using qsort each time a new offset/type was recorded, and a binary
288 search was used to find the type pointer for a given DIE offset. This was
289 even slower, due to the overhead of sorting the array each time a new
290 offset/type pair was entered.
292 The third attempt uses a fixed size array of type pointers, indexed by a
293 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
294 we can divide any DIE offset by 4 to obtain a unique index into this fixed
295 size array. Since each element is a 4 byte pointer, it takes exactly as
296 much memory to hold this array as to hold the DWARF info for a given
297 compilation unit. But it gets freed as soon as we are done with it. */
299 static struct type
**utypes
; /* Pointer to array of user type pointers */
300 static int numutypes
; /* Max number of user type pointers */
302 /* Forward declarations of static functions so we don't have to worry
303 about ordering within this file. */
306 attribute_size
PARAMS ((unsigned int));
309 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
312 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
315 handle_producer
PARAMS ((char *));
318 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
321 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
324 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
331 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
334 scan_compilation_units
PARAMS ((char *, char *, char *, unsigned int,
335 unsigned int, struct objfile
*));
338 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
341 init_psymbol_list
PARAMS ((struct objfile
*, int));
344 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
347 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
350 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
353 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
355 static struct symtab
*
356 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
359 process_dies
PARAMS ((char *, char *, struct objfile
*));
362 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
366 decode_array_element_type
PARAMS ((char *));
369 decode_subscr_data
PARAMS ((char *, char *));
372 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
375 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
378 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
381 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
384 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
387 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
390 decode_line_numbers
PARAMS ((char *));
393 decode_die_type
PARAMS ((struct dieinfo
*));
396 decode_mod_fund_type
PARAMS ((char *));
399 decode_mod_u_d_type
PARAMS ((char *));
402 decode_modified_type
PARAMS ((char *, unsigned int, int));
405 decode_fund_type
PARAMS ((unsigned int));
408 create_name
PARAMS ((char *, struct obstack
*));
411 lookup_utype
PARAMS ((DIE_REF
));
414 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
416 static struct symbol
*
417 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
420 locval
PARAMS ((char *));
423 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
430 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
434 void dwarf_build_psymtabs (int desc, char *filename,
435 struct section_offsets *section_offsets,
436 int mainline, unsigned int dbfoff, unsigned int dbsize,
437 unsigned int lnoffset, unsigned int lnsize,
438 struct objfile *objfile)
442 This function is called upon to build partial symtabs from files
443 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
445 It is passed a file descriptor for an open file containing the DIES
446 and line number information, the corresponding filename for that
447 file, a base address for relocating the symbols, a flag indicating
448 whether or not this debugging information is from a "main symbol
449 table" rather than a shared library or dynamically linked file,
450 and file offset/size pairs for the DIE information and line number
460 dwarf_build_psymtabs (desc
, filename
, section_offsets
, mainline
, dbfoff
, dbsize
,
461 lnoffset
, lnsize
, objfile
)
464 struct section_offsets
*section_offsets
;
468 unsigned int lnoffset
;
470 struct objfile
*objfile
;
472 struct cleanup
*back_to
;
474 current_objfile
= objfile
;
475 dbbase
= xmalloc (dbsize
);
477 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
478 (read (desc
, dbbase
, dbsize
) != dbsize
))
481 error ("can't read DWARF data from '%s'", filename
);
483 back_to
= make_cleanup (free
, dbbase
);
485 /* If we are reinitializing, or if we have never loaded syms yet, init.
486 Since we have no idea how many DIES we are looking at, we just guess
487 some arbitrary value. */
489 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
490 objfile
-> static_psymbols
.size
== 0)
492 init_psymbol_list (objfile
, 1024);
495 /* Save the relocation factor where everybody can see it. */
497 base_section_offsets
= section_offsets
;
498 baseaddr
= ANOFFSET (section_offsets
, 0);
500 /* Follow the compilation unit sibling chain, building a partial symbol
501 table entry for each one. Save enough information about each compilation
502 unit to locate the full DWARF information later. */
504 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
505 dbfoff
, lnoffset
, objfile
);
507 do_cleanups (back_to
);
508 current_objfile
= NULL
;
516 record_minimal_symbol -- add entry to gdb's minimal symbol table
520 static void record_minimal_symbol (char *name, CORE_ADDR address,
521 enum minimal_symbol_type ms_type,
522 struct objfile *objfile)
526 Given a pointer to the name of a symbol that should be added to the
527 minimal symbol table, and the address associated with that
528 symbol, records this information for later use in building the
529 minimal symbol table.
534 record_minimal_symbol (name
, address
, ms_type
, objfile
)
537 enum minimal_symbol_type ms_type
;
538 struct objfile
*objfile
;
540 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
541 prim_record_minimal_symbol (name
, address
, ms_type
);
548 dwarfwarn -- issue a DWARF related warning
552 Issue warnings about DWARF related things that aren't serious enough
553 to warrant aborting with an error, but should not be ignored either.
554 This includes things like detectable corruption in DIE's, missing
555 DIE's, unimplemented features, etc.
557 In general, running across tags or attributes that we don't recognize
558 is not considered to be a problem and we should not issue warnings
563 We mostly follow the example of the error() routine, but without
564 returning to command level. It is arguable about whether warnings
565 should be issued at all, and if so, where they should go (stdout or
568 We assume that curdie is valid and contains at least the basic
569 information for the DIE where the problem was noticed.
580 fmt
= va_arg (ap
, char *);
582 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
583 if (curdie
-> at_name
)
585 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
587 vfprintf (stderr
, fmt
, ap
);
588 fprintf (stderr
, "\n");
597 read_lexical_block_scope -- process all dies in a lexical block
601 static void read_lexical_block_scope (struct dieinfo *dip,
602 char *thisdie, char *enddie)
606 Process all the DIES contained within a lexical block scope.
607 Start a new scope, process the dies, and then close the scope.
612 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
616 struct objfile
*objfile
;
618 register struct context_stack
*new;
620 push_context (0, dip
-> at_low_pc
);
621 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
622 new = pop_context ();
623 if (local_symbols
!= NULL
)
625 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
626 dip
-> at_high_pc
, objfile
);
628 local_symbols
= new -> locals
;
635 lookup_utype -- look up a user defined type from die reference
639 static type *lookup_utype (DIE_REF die_ref)
643 Given a DIE reference, lookup the user defined type associated with
644 that DIE, if it has been registered already. If not registered, then
645 return NULL. Alloc_utype() can be called to register an empty
646 type for this reference, which will be filled in later when the
647 actual referenced DIE is processed.
651 lookup_utype (die_ref
)
654 struct type
*type
= NULL
;
657 utypeidx
= (die_ref
- dbroff
) / 4;
658 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
660 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
664 type
= *(utypes
+ utypeidx
);
674 alloc_utype -- add a user defined type for die reference
678 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
682 Given a die reference DIE_REF, and a possible pointer to a user
683 defined type UTYPEP, register that this reference has a user
684 defined type and either use the specified type in UTYPEP or
685 make a new empty type that will be filled in later.
687 We should only be called after calling lookup_utype() to verify that
688 there is not currently a type registered for DIE_REF.
692 alloc_utype (die_ref
, utypep
)
699 utypeidx
= (die_ref
- dbroff
) / 4;
700 typep
= utypes
+ utypeidx
;
701 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
703 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
704 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
706 else if (*typep
!= NULL
)
709 SQUAWK (("internal error: dup user type allocation"));
715 utypep
= alloc_type (current_objfile
);
726 decode_die_type -- return a type for a specified die
730 static struct type *decode_die_type (struct dieinfo *dip)
734 Given a pointer to a die information structure DIP, decode the
735 type of the die and return a pointer to the decoded type. All
736 dies without specific types default to type int.
740 decode_die_type (dip
)
743 struct type
*type
= NULL
;
745 if (dip
-> at_fund_type
!= 0)
747 type
= decode_fund_type (dip
-> at_fund_type
);
749 else if (dip
-> at_mod_fund_type
!= NULL
)
751 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
753 else if (dip
-> at_user_def_type
)
755 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
757 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
760 else if (dip
-> at_mod_u_d_type
)
762 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
766 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
775 struct_type -- compute and return the type for a struct or union
779 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
780 char *enddie, struct objfile *objfile)
784 Given pointer to a die information structure for a die which
785 defines a union or structure (and MUST define one or the other),
786 and pointers to the raw die data that define the range of dies which
787 define the members, compute and return the user defined type for the
792 struct_type (dip
, thisdie
, enddie
, objfile
)
796 struct objfile
*objfile
;
800 struct nextfield
*next
;
803 struct nextfield
*list
= NULL
;
804 struct nextfield
*new;
811 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
813 /* No forward references created an empty type, so install one now */
814 type
= alloc_utype (dip
-> die_ref
, NULL
);
816 INIT_CPLUS_SPECIFIC(type
);
817 switch (dip
-> die_tag
)
819 case TAG_structure_type
:
820 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
824 TYPE_CODE (type
) = TYPE_CODE_UNION
;
828 /* Should never happen */
829 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
831 SQUAWK (("missing structure or union tag"));
834 /* Some compilers try to be helpful by inventing "fake" names for
835 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
836 Thanks, but no thanks... */
837 if (dip
-> at_name
!= NULL
838 && *dip
-> at_name
!= '~'
839 && *dip
-> at_name
!= '.')
841 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
842 tpart1
, " ", dip
-> at_name
);
844 if (dip
-> at_byte_size
!= 0)
846 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
848 thisdie
+= dip
-> die_length
;
849 while (thisdie
< enddie
)
851 basicdieinfo (&mbr
, thisdie
, objfile
);
852 completedieinfo (&mbr
, objfile
);
853 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
857 else if (mbr
.at_sibling
!= 0)
859 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
863 nextdie
= thisdie
+ mbr
.die_length
;
868 /* Get space to record the next field's data. */
869 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
874 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
875 &objfile
-> type_obstack
);
876 list
-> field
.type
= decode_die_type (&mbr
);
877 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
878 /* Handle bit fields. */
879 list
-> field
.bitsize
= mbr
.at_bit_size
;
881 /* For big endian bits, the at_bit_offset gives the additional
882 bit offset from the MSB of the containing anonymous object to
883 the MSB of the field. We don't have to do anything special
884 since we don't need to know the size of the anonymous object. */
885 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
887 /* For little endian bits, we need to have a non-zero at_bit_size,
888 so that we know we are in fact dealing with a bitfield. Compute
889 the bit offset to the MSB of the anonymous object, subtract off
890 the number of bits from the MSB of the field to the MSB of the
891 object, and then subtract off the number of bits of the field
892 itself. The result is the bit offset of the LSB of the field. */
893 if (mbr
.at_bit_size
> 0)
895 list
-> field
.bitpos
+=
896 mbr
.at_byte_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
902 process_dies (thisdie
, nextdie
, objfile
);
907 /* Now create the vector of fields, and record how big it is. We may
908 not even have any fields, if this DIE was generated due to a reference
909 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
910 set, which clues gdb in to the fact that it needs to search elsewhere
911 for the full structure definition. */
914 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
918 TYPE_NFIELDS (type
) = nfields
;
919 TYPE_FIELDS (type
) = (struct field
*)
920 obstack_alloc (&objfile
-> type_obstack
,
921 sizeof (struct field
) * nfields
);
922 /* Copy the saved-up fields into the field vector. */
923 for (n
= nfields
; list
; list
= list
-> next
)
925 TYPE_FIELD (type
, --n
) = list
-> field
;
935 read_structure_scope -- process all dies within struct or union
939 static void read_structure_scope (struct dieinfo *dip,
940 char *thisdie, char *enddie, struct objfile *objfile)
944 Called when we find the DIE that starts a structure or union
945 scope (definition) to process all dies that define the members
946 of the structure or union. DIP is a pointer to the die info
947 struct for the DIE that names the structure or union.
951 Note that we need to call struct_type regardless of whether or not
952 the DIE has an at_name attribute, since it might be an anonymous
953 structure or union. This gets the type entered into our set of
956 However, if the structure is incomplete (an opaque struct/union)
957 then suppress creating a symbol table entry for it since gdb only
958 wants to find the one with the complete definition. Note that if
959 it is complete, we just call new_symbol, which does it's own
960 checking about whether the struct/union is anonymous or not (and
961 suppresses creating a symbol table entry itself).
966 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
970 struct objfile
*objfile
;
975 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
976 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
978 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
980 SYMBOL_TYPE (sym
) = type
;
989 decode_array_element_type -- decode type of the array elements
993 static struct type *decode_array_element_type (char *scan, char *end)
997 As the last step in decoding the array subscript information for an
998 array DIE, we need to decode the type of the array elements. We are
999 passed a pointer to this last part of the subscript information and
1000 must return the appropriate type. If the type attribute is not
1001 recognized, just warn about the problem and return type int.
1004 static struct type
*
1005 decode_array_element_type (scan
)
1010 unsigned short attribute
;
1011 unsigned short fundtype
;
1014 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1016 scan
+= SIZEOF_ATTRIBUTE
;
1017 if ((nbytes
= attribute_size (attribute
)) == -1)
1019 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1020 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1027 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1029 typep
= decode_fund_type (fundtype
);
1031 case AT_mod_fund_type
:
1032 typep
= decode_mod_fund_type (scan
);
1034 case AT_user_def_type
:
1035 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1037 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1039 typep
= alloc_utype (die_ref
, NULL
);
1042 case AT_mod_u_d_type
:
1043 typep
= decode_mod_u_d_type (scan
);
1046 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1047 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1058 decode_subscr_data -- decode array subscript and element type data
1062 static struct type *decode_subscr_data (char *scan, char *end)
1066 The array subscripts and the data type of the elements of an
1067 array are described by a list of data items, stored as a block
1068 of contiguous bytes. There is a data item describing each array
1069 dimension, and a final data item describing the element type.
1070 The data items are ordered the same as their appearance in the
1071 source (I.E. leftmost dimension first, next to leftmost second,
1074 We are passed a pointer to the start of the block of bytes
1075 containing the data items, and a pointer to the first byte past
1076 the data. This function decodes the data and returns a type.
1079 FIXME: This code only implements the forms currently used
1080 by the AT&T and GNU C compilers.
1082 The end pointer is supplied for error checking, maybe we should
1086 static struct type
*
1087 decode_subscr_data (scan
, end
)
1091 struct type
*typep
= NULL
;
1092 struct type
*nexttype
;
1093 unsigned int format
;
1094 unsigned short fundtype
;
1095 unsigned long lowbound
;
1096 unsigned long highbound
;
1099 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1101 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1105 typep
= decode_array_element_type (scan
);
1108 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1110 scan
+= SIZEOF_FMT_FT
;
1111 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1112 && fundtype
!= FT_unsigned_integer
)
1114 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1119 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1120 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1123 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1126 nexttype
= decode_subscr_data (scan
, end
);
1127 if (nexttype
!= NULL
)
1129 typep
= alloc_type (current_objfile
);
1130 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1131 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1132 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1133 TYPE_TARGET_TYPE (typep
) = nexttype
;
1144 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1147 SQUAWK (("unknown array subscript format %x", format
));
1157 dwarf_read_array_type -- read TAG_array_type DIE
1161 static void dwarf_read_array_type (struct dieinfo *dip)
1165 Extract all information from a TAG_array_type DIE and add to
1166 the user defined type vector.
1170 dwarf_read_array_type (dip
)
1171 struct dieinfo
*dip
;
1177 unsigned short blocksz
;
1180 if (dip
-> at_ordering
!= ORD_row_major
)
1182 /* FIXME: Can gdb even handle column major arrays? */
1183 SQUAWK (("array not row major; not handled correctly"));
1185 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1187 nbytes
= attribute_size (AT_subscr_data
);
1188 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1189 subend
= sub
+ nbytes
+ blocksz
;
1191 type
= decode_subscr_data (sub
, subend
);
1194 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1196 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1198 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1199 TYPE_TARGET_TYPE (utype
) =
1200 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1201 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1205 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1207 alloc_utype (dip
-> die_ref
, type
);
1211 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1212 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1213 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1223 read_tag_pointer_type -- read TAG_pointer_type DIE
1227 static void read_tag_pointer_type (struct dieinfo *dip)
1231 Extract all information from a TAG_pointer_type DIE and add to
1232 the user defined type vector.
1236 read_tag_pointer_type (dip
)
1237 struct dieinfo
*dip
;
1242 type
= decode_die_type (dip
);
1243 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1245 utype
= lookup_pointer_type (type
);
1246 alloc_utype (dip
-> die_ref
, utype
);
1250 TYPE_TARGET_TYPE (utype
) = type
;
1251 TYPE_POINTER_TYPE (type
) = utype
;
1253 /* We assume the machine has only one representation for pointers! */
1254 /* FIXME: This confuses host<->target data representations, and is a
1255 poor assumption besides. */
1257 TYPE_LENGTH (utype
) = sizeof (char *);
1258 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1266 read_subroutine_type -- process TAG_subroutine_type dies
1270 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1275 Handle DIES due to C code like:
1278 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1284 The parameter DIES are currently ignored. See if gdb has a way to
1285 include this info in it's type system, and decode them if so. Is
1286 this what the type structure's "arg_types" field is for? (FIXME)
1290 read_subroutine_type (dip
, thisdie
, enddie
)
1291 struct dieinfo
*dip
;
1295 struct type
*type
; /* Type that this function returns */
1296 struct type
*ftype
; /* Function that returns above type */
1298 /* Decode the type that this subroutine returns */
1300 type
= decode_die_type (dip
);
1302 /* Check to see if we already have a partially constructed user
1303 defined type for this DIE, from a forward reference. */
1305 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1307 /* This is the first reference to one of these types. Make
1308 a new one and place it in the user defined types. */
1309 ftype
= lookup_function_type (type
);
1310 alloc_utype (dip
-> die_ref
, ftype
);
1314 /* We have an existing partially constructed type, so bash it
1315 into the correct type. */
1316 TYPE_TARGET_TYPE (ftype
) = type
;
1317 TYPE_FUNCTION_TYPE (type
) = ftype
;
1318 TYPE_LENGTH (ftype
) = 1;
1319 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1327 read_enumeration -- process dies which define an enumeration
1331 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1332 char *enddie, struct objfile *objfile)
1336 Given a pointer to a die which begins an enumeration, process all
1337 the dies that define the members of the enumeration.
1341 Note that we need to call enum_type regardless of whether or not we
1342 have a symbol, since we might have an enum without a tag name (thus
1343 no symbol for the tagname).
1347 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1348 struct dieinfo
*dip
;
1351 struct objfile
*objfile
;
1356 type
= enum_type (dip
, objfile
);
1357 if ((sym
= new_symbol (dip
, objfile
)) != NULL
)
1359 SYMBOL_TYPE (sym
) = type
;
1367 enum_type -- decode and return a type for an enumeration
1371 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1375 Given a pointer to a die information structure for the die which
1376 starts an enumeration, process all the dies that define the members
1377 of the enumeration and return a type pointer for the enumeration.
1379 At the same time, for each member of the enumeration, create a
1380 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1381 and give it the type of the enumeration itself.
1385 Note that the DWARF specification explicitly mandates that enum
1386 constants occur in reverse order from the source program order,
1387 for "consistency" and because this ordering is easier for many
1388 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1389 Entries). Because gdb wants to see the enum members in program
1390 source order, we have to ensure that the order gets reversed while
1391 we are processing them.
1394 static struct type
*
1395 enum_type (dip
, objfile
)
1396 struct dieinfo
*dip
;
1397 struct objfile
*objfile
;
1401 struct nextfield
*next
;
1404 struct nextfield
*list
= NULL
;
1405 struct nextfield
*new;
1410 unsigned short blocksz
;
1414 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1416 /* No forward references created an empty type, so install one now */
1417 type
= alloc_utype (dip
-> die_ref
, NULL
);
1419 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1420 /* Some compilers try to be helpful by inventing "fake" names for
1421 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1422 Thanks, but no thanks... */
1423 if (dip
-> at_name
!= NULL
1424 && *dip
-> at_name
!= '~'
1425 && *dip
-> at_name
!= '.')
1427 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1428 " ", dip
-> at_name
);
1430 if (dip
-> at_byte_size
!= 0)
1432 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1434 if ((scan
= dip
-> at_element_list
) != NULL
)
1436 if (dip
-> short_element_list
)
1438 nbytes
= attribute_size (AT_short_element_list
);
1442 nbytes
= attribute_size (AT_element_list
);
1444 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1445 listend
= scan
+ nbytes
+ blocksz
;
1447 while (scan
< listend
)
1449 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1452 list
-> field
.type
= NULL
;
1453 list
-> field
.bitsize
= 0;
1454 list
-> field
.bitpos
=
1455 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1457 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1458 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1459 &objfile
-> type_obstack
);
1460 scan
+= strlen (scan
) + 1;
1462 /* Handcraft a new symbol for this enum member. */
1463 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1464 sizeof (struct symbol
));
1465 memset (sym
, 0, sizeof (struct symbol
));
1466 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1467 &objfile
->symbol_obstack
);
1468 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1469 SYMBOL_CLASS (sym
) = LOC_CONST
;
1470 SYMBOL_TYPE (sym
) = type
;
1471 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1472 add_symbol_to_list (sym
, list_in_scope
);
1474 /* Now create the vector of fields, and record how big it is. This is
1475 where we reverse the order, by pulling the members off the list in
1476 reverse order from how they were inserted. If we have no fields
1477 (this is apparently possible in C++) then skip building a field
1481 TYPE_NFIELDS (type
) = nfields
;
1482 TYPE_FIELDS (type
) = (struct field
*)
1483 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1484 /* Copy the saved-up fields into the field vector. */
1485 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1487 TYPE_FIELD (type
, n
++) = list
-> field
;
1498 read_func_scope -- process all dies within a function scope
1502 Process all dies within a given function scope. We are passed
1503 a die information structure pointer DIP for the die which
1504 starts the function scope, and pointers into the raw die data
1505 that define the dies within the function scope.
1507 For now, we ignore lexical block scopes within the function.
1508 The problem is that AT&T cc does not define a DWARF lexical
1509 block scope for the function itself, while gcc defines a
1510 lexical block scope for the function. We need to think about
1511 how to handle this difference, or if it is even a problem.
1516 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1517 struct dieinfo
*dip
;
1520 struct objfile
*objfile
;
1522 register struct context_stack
*new;
1524 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1525 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1527 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1528 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1530 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1532 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1533 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1535 new = push_context (0, dip
-> at_low_pc
);
1536 new -> name
= new_symbol (dip
, objfile
);
1537 list_in_scope
= &local_symbols
;
1538 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1539 new = pop_context ();
1540 /* Make a block for the local symbols within. */
1541 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1542 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1543 list_in_scope
= &file_symbols
;
1551 handle_producer -- process the AT_producer attribute
1555 Perform any operations that depend on finding a particular
1556 AT_producer attribute.
1561 handle_producer (producer
)
1565 /* If this compilation unit was compiled with g++ or gcc, then set the
1566 processing_gcc_compilation flag. */
1568 processing_gcc_compilation
=
1569 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1570 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1572 /* Select a demangling style if we can identify the producer and if
1573 the current style is auto. We leave the current style alone if it
1574 is not auto. We also leave the demangling style alone if we find a
1575 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1577 #if 1 /* Works, but is experimental. -fnf */
1578 if (current_demangling_style
== auto_demangling
)
1580 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1582 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1584 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1586 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1588 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1590 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1601 read_file_scope -- process all dies within a file scope
1605 Process all dies within a given file scope. We are passed a
1606 pointer to the die information structure for the die which
1607 starts the file scope, and pointers into the raw die data which
1608 mark the range of dies within the file scope.
1610 When the partial symbol table is built, the file offset for the line
1611 number table for each compilation unit is saved in the partial symbol
1612 table entry for that compilation unit. As the symbols for each
1613 compilation unit are read, the line number table is read into memory
1614 and the variable lnbase is set to point to it. Thus all we have to
1615 do is use lnbase to access the line number table for the current
1620 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1621 struct dieinfo
*dip
;
1624 struct objfile
*objfile
;
1626 struct cleanup
*back_to
;
1627 struct symtab
*symtab
;
1629 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1630 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1632 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1633 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1635 if (dip
-> at_producer
!= NULL
)
1637 handle_producer (dip
-> at_producer
);
1639 numutypes
= (enddie
- thisdie
) / 4;
1640 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1641 back_to
= make_cleanup (free
, utypes
);
1642 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1643 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1644 decode_line_numbers (lnbase
);
1645 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1646 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1647 /* FIXME: The following may need to be expanded for other languages */
1648 switch (dip
-> at_language
)
1652 symtab
-> language
= language_c
;
1654 case LANG_C_PLUS_PLUS
:
1655 symtab
-> language
= language_cplus
;
1660 do_cleanups (back_to
);
1669 process_dies -- process a range of DWARF Information Entries
1673 static void process_dies (char *thisdie, char *enddie,
1674 struct objfile *objfile)
1678 Process all DIE's in a specified range. May be (and almost
1679 certainly will be) called recursively.
1683 process_dies (thisdie
, enddie
, objfile
)
1686 struct objfile
*objfile
;
1691 while (thisdie
< enddie
)
1693 basicdieinfo (&di
, thisdie
, objfile
);
1694 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1698 else if (di
.die_tag
== TAG_padding
)
1700 nextdie
= thisdie
+ di
.die_length
;
1704 completedieinfo (&di
, objfile
);
1705 if (di
.at_sibling
!= 0)
1707 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1711 nextdie
= thisdie
+ di
.die_length
;
1715 case TAG_compile_unit
:
1716 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1718 case TAG_global_subroutine
:
1719 case TAG_subroutine
:
1720 if (di
.has_at_low_pc
)
1722 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1725 case TAG_lexical_block
:
1726 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1728 case TAG_structure_type
:
1729 case TAG_union_type
:
1730 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1732 case TAG_enumeration_type
:
1733 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1735 case TAG_subroutine_type
:
1736 read_subroutine_type (&di
, thisdie
, nextdie
);
1738 case TAG_array_type
:
1739 dwarf_read_array_type (&di
);
1741 case TAG_pointer_type
:
1742 read_tag_pointer_type (&di
);
1745 new_symbol (&di
, objfile
);
1757 decode_line_numbers -- decode a line number table fragment
1761 static void decode_line_numbers (char *tblscan, char *tblend,
1762 long length, long base, long line, long pc)
1766 Translate the DWARF line number information to gdb form.
1768 The ".line" section contains one or more line number tables, one for
1769 each ".line" section from the objects that were linked.
1771 The AT_stmt_list attribute for each TAG_source_file entry in the
1772 ".debug" section contains the offset into the ".line" section for the
1773 start of the table for that file.
1775 The table itself has the following structure:
1777 <table length><base address><source statement entry>
1778 4 bytes 4 bytes 10 bytes
1780 The table length is the total size of the table, including the 4 bytes
1781 for the length information.
1783 The base address is the address of the first instruction generated
1784 for the source file.
1786 Each source statement entry has the following structure:
1788 <line number><statement position><address delta>
1789 4 bytes 2 bytes 4 bytes
1791 The line number is relative to the start of the file, starting with
1794 The statement position either -1 (0xFFFF) or the number of characters
1795 from the beginning of the line to the beginning of the statement.
1797 The address delta is the difference between the base address and
1798 the address of the first instruction for the statement.
1800 Note that we must copy the bytes from the packed table to our local
1801 variables before attempting to use them, to avoid alignment problems
1802 on some machines, particularly RISC processors.
1806 Does gdb expect the line numbers to be sorted? They are now by
1807 chance/luck, but are not required to be. (FIXME)
1809 The line with number 0 is unused, gdb apparently can discover the
1810 span of the last line some other way. How? (FIXME)
1814 decode_line_numbers (linetable
)
1819 unsigned long length
;
1824 if (linetable
!= NULL
)
1826 tblscan
= tblend
= linetable
;
1827 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1829 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1831 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1832 GET_UNSIGNED
, current_objfile
);
1833 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1835 while (tblscan
< tblend
)
1837 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1839 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1840 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1842 tblscan
+= SIZEOF_LINETBL_DELTA
;
1846 record_line (current_subfile
, line
, pc
);
1856 locval -- compute the value of a location attribute
1860 static int locval (char *loc)
1864 Given pointer to a string of bytes that define a location, compute
1865 the location and return the value.
1867 When computing values involving the current value of the frame pointer,
1868 the value zero is used, which results in a value relative to the frame
1869 pointer, rather than the absolute value. This is what GDB wants
1872 When the result is a register number, the global isreg flag is set,
1873 otherwise it is cleared. This is a kludge until we figure out a better
1874 way to handle the problem. Gdb's design does not mesh well with the
1875 DWARF notion of a location computing interpreter, which is a shame
1876 because the flexibility goes unused.
1880 Note that stack[0] is unused except as a default error return.
1881 Note that stack overflow is not yet handled.
1888 unsigned short nbytes
;
1889 unsigned short locsize
;
1890 auto long stack
[64];
1897 nbytes
= attribute_size (AT_location
);
1898 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
1900 end
= loc
+ locsize
;
1905 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
1908 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
1910 loc
+= SIZEOF_LOC_ATOM_CODE
;
1911 switch (loc_atom_code
)
1918 /* push register (number) */
1919 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1920 GET_UNSIGNED
, current_objfile
);
1921 loc
+= loc_value_size
;
1925 /* push value of register (number) */
1926 /* Actually, we compute the value as if register has 0 */
1928 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
1930 loc
+= loc_value_size
;
1933 stack
[++stacki
] = 0;
1937 stack
[++stacki
] = 0;
1938 SQUAWK (("BASEREG %d not handled!", regno
));
1942 /* push address (relocated address) */
1943 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1944 GET_UNSIGNED
, current_objfile
);
1945 loc
+= loc_value_size
;
1948 /* push constant (number) FIXME: signed or unsigned! */
1949 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
1950 GET_SIGNED
, current_objfile
);
1951 loc
+= loc_value_size
;
1954 /* pop, deref and push 2 bytes (as a long) */
1955 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
1957 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
1958 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
1960 case OP_ADD
: /* pop top 2 items, add, push result */
1961 stack
[stacki
- 1] += stack
[stacki
];
1966 return (stack
[stacki
]);
1973 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
1977 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
1981 When expanding a partial symbol table entry to a full symbol table
1982 entry, this is the function that gets called to read in the symbols
1983 for the compilation unit.
1985 Returns a pointer to the newly constructed symtab (which is now
1986 the new first one on the objfile's symtab list).
1989 static struct symtab
*
1990 read_ofile_symtab (pst
)
1991 struct partial_symtab
*pst
;
1993 struct cleanup
*back_to
;
1994 unsigned long lnsize
;
1997 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
1999 abfd
= pst
-> objfile
-> obfd
;
2000 current_objfile
= pst
-> objfile
;
2002 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2003 unit, seek to the location in the file, and read in all the DIE's. */
2006 dbbase
= xmalloc (DBLENGTH(pst
));
2007 dbroff
= DBROFF(pst
);
2008 foffset
= DBFOFF(pst
) + dbroff
;
2009 base_section_offsets
= pst
->section_offsets
;
2010 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2011 if (bfd_seek (abfd
, foffset
, 0) ||
2012 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2015 error ("can't read DWARF data");
2017 back_to
= make_cleanup (free
, dbbase
);
2019 /* If there is a line number table associated with this compilation unit
2020 then read the size of this fragment in bytes, from the fragment itself.
2021 Allocate a buffer for the fragment and read it in for future
2027 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2028 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2029 sizeof (lnsizedata
)))
2031 error ("can't read DWARF line number table size");
2033 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2034 GET_UNSIGNED
, pst
-> objfile
);
2035 lnbase
= xmalloc (lnsize
);
2036 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2037 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2040 error ("can't read DWARF line numbers");
2042 make_cleanup (free
, lnbase
);
2045 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
2046 do_cleanups (back_to
);
2047 current_objfile
= NULL
;
2048 return (pst
-> objfile
-> symtabs
);
2055 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2059 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2063 Called once for each partial symbol table entry that needs to be
2064 expanded into a full symbol table entry.
2069 psymtab_to_symtab_1 (pst
)
2070 struct partial_symtab
*pst
;
2073 struct cleanup
*old_chain
;
2079 warning ("psymtab for %s already read in. Shouldn't happen.",
2084 /* Read in all partial symtabs on which this one is dependent */
2085 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2087 if (!pst
-> dependencies
[i
] -> readin
)
2089 /* Inform about additional files that need to be read in. */
2092 fputs_filtered (" ", stdout
);
2094 fputs_filtered ("and ", stdout
);
2096 printf_filtered ("%s...",
2097 pst
-> dependencies
[i
] -> filename
);
2099 fflush (stdout
); /* Flush output */
2101 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2104 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2107 old_chain
= make_cleanup (really_free_pendings
, 0);
2108 pst
-> symtab
= read_ofile_symtab (pst
);
2111 printf_filtered ("%d DIE's, sorting...", diecount
);
2115 sort_symtab_syms (pst
-> symtab
);
2116 do_cleanups (old_chain
);
2127 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2131 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2135 This is the DWARF support entry point for building a full symbol
2136 table entry from a partial symbol table entry. We are passed a
2137 pointer to the partial symbol table entry that needs to be expanded.
2142 dwarf_psymtab_to_symtab (pst
)
2143 struct partial_symtab
*pst
;
2150 warning ("psymtab for %s already read in. Shouldn't happen.",
2155 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2157 /* Print the message now, before starting serious work, to avoid
2158 disconcerting pauses. */
2161 printf_filtered ("Reading in symbols for %s...",
2166 psymtab_to_symtab_1 (pst
);
2168 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2169 we need to do an equivalent or is this something peculiar to
2171 Match with global symbols. This only needs to be done once,
2172 after all of the symtabs and dependencies have been read in.
2174 scan_file_globals (pst
-> objfile
);
2177 /* Finish up the verbose info message. */
2180 printf_filtered ("done.\n");
2192 init_psymbol_list -- initialize storage for partial symbols
2196 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2200 Initializes storage for all of the partial symbols that will be
2201 created by dwarf_build_psymtabs and subsidiaries.
2205 init_psymbol_list (objfile
, total_symbols
)
2206 struct objfile
*objfile
;
2209 /* Free any previously allocated psymbol lists. */
2211 if (objfile
-> global_psymbols
.list
)
2213 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2215 if (objfile
-> static_psymbols
.list
)
2217 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2220 /* Current best guess is that there are approximately a twentieth
2221 of the total symbols (in a debugging file) are global or static
2224 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2225 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2226 objfile
-> global_psymbols
.next
=
2227 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2228 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2229 * sizeof (struct partial_symbol
));
2230 objfile
-> static_psymbols
.next
=
2231 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2232 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2233 * sizeof (struct partial_symbol
));
2240 add_enum_psymbol -- add enumeration members to partial symbol table
2244 Given pointer to a DIE that is known to be for an enumeration,
2245 extract the symbolic names of the enumeration members and add
2246 partial symbols for them.
2250 add_enum_psymbol (dip
, objfile
)
2251 struct dieinfo
*dip
;
2252 struct objfile
*objfile
;
2256 unsigned short blocksz
;
2259 if ((scan
= dip
-> at_element_list
) != NULL
)
2261 if (dip
-> short_element_list
)
2263 nbytes
= attribute_size (AT_short_element_list
);
2267 nbytes
= attribute_size (AT_element_list
);
2269 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2271 listend
= scan
+ blocksz
;
2272 while (scan
< listend
)
2274 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2275 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2276 objfile
-> static_psymbols
, 0);
2277 scan
+= strlen (scan
) + 1;
2286 add_partial_symbol -- add symbol to partial symbol table
2290 Given a DIE, if it is one of the types that we want to
2291 add to a partial symbol table, finish filling in the die info
2292 and then add a partial symbol table entry for it.
2297 add_partial_symbol (dip
, objfile
)
2298 struct dieinfo
*dip
;
2299 struct objfile
*objfile
;
2301 switch (dip
-> die_tag
)
2303 case TAG_global_subroutine
:
2304 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2306 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2307 VAR_NAMESPACE
, LOC_BLOCK
,
2308 objfile
-> global_psymbols
,
2311 case TAG_global_variable
:
2312 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2314 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2315 VAR_NAMESPACE
, LOC_STATIC
,
2316 objfile
-> global_psymbols
,
2319 case TAG_subroutine
:
2320 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2321 VAR_NAMESPACE
, LOC_BLOCK
,
2322 objfile
-> static_psymbols
,
2325 case TAG_local_variable
:
2326 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2327 VAR_NAMESPACE
, LOC_STATIC
,
2328 objfile
-> static_psymbols
,
2332 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2333 VAR_NAMESPACE
, LOC_TYPEDEF
,
2334 objfile
-> static_psymbols
,
2337 case TAG_structure_type
:
2338 case TAG_union_type
:
2339 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2340 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2341 objfile
-> static_psymbols
,
2344 case TAG_enumeration_type
:
2347 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2348 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2349 objfile
-> static_psymbols
,
2352 add_enum_psymbol (dip
, objfile
);
2361 scan_partial_symbols -- scan DIE's within a single compilation unit
2365 Process the DIE's within a single compilation unit, looking for
2366 interesting DIE's that contribute to the partial symbol table entry
2367 for this compilation unit. Since we cannot follow any sibling
2368 chains without reading the complete DIE info for every DIE,
2369 it is probably faster to just sequentially check each one to
2370 see if it is one of the types we are interested in, and if so,
2371 then extract all the attributes info and generate a partial
2376 Don't attempt to add anonymous structures or unions since they have
2377 no name. Anonymous enumerations however are processed, because we
2378 want to extract their member names (the check for a tag name is
2381 Also, for variables and subroutines, check that this is the place
2382 where the actual definition occurs, rather than just a reference
2387 scan_partial_symbols (thisdie
, enddie
, objfile
)
2390 struct objfile
*objfile
;
2395 while (thisdie
< enddie
)
2397 basicdieinfo (&di
, thisdie
, objfile
);
2398 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2404 nextdie
= thisdie
+ di
.die_length
;
2405 /* To avoid getting complete die information for every die, we
2406 only do it (below) for the cases we are interested in. */
2409 case TAG_global_subroutine
:
2410 case TAG_subroutine
:
2411 case TAG_global_variable
:
2412 case TAG_local_variable
:
2413 completedieinfo (&di
, objfile
);
2414 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2416 add_partial_symbol (&di
, objfile
);
2420 case TAG_structure_type
:
2421 case TAG_union_type
:
2422 completedieinfo (&di
, objfile
);
2425 add_partial_symbol (&di
, objfile
);
2428 case TAG_enumeration_type
:
2429 completedieinfo (&di
, objfile
);
2430 add_partial_symbol (&di
, objfile
);
2442 scan_compilation_units -- build a psymtab entry for each compilation
2446 This is the top level dwarf parsing routine for building partial
2449 It scans from the beginning of the DWARF table looking for the first
2450 TAG_compile_unit DIE, and then follows the sibling chain to locate
2451 each additional TAG_compile_unit DIE.
2453 For each TAG_compile_unit DIE it creates a partial symtab structure,
2454 calls a subordinate routine to collect all the compilation unit's
2455 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2456 new partial symtab structure into the partial symbol table. It also
2457 records the appropriate information in the partial symbol table entry
2458 to allow the chunk of DIE's and line number table for this compilation
2459 unit to be located and re-read later, to generate a complete symbol
2460 table entry for the compilation unit.
2462 Thus it effectively partitions up a chunk of DIE's for multiple
2463 compilation units into smaller DIE chunks and line number tables,
2464 and associates them with a partial symbol table entry.
2468 If any compilation unit has no line number table associated with
2469 it for some reason (a missing at_stmt_list attribute, rather than
2470 just one with a value of zero, which is valid) then we ensure that
2471 the recorded file offset is zero so that the routine which later
2472 reads line number table fragments knows that there is no fragment
2482 scan_compilation_units (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2486 unsigned int dbfoff
;
2487 unsigned int lnoffset
;
2488 struct objfile
*objfile
;
2492 struct partial_symtab
*pst
;
2497 while (thisdie
< enddie
)
2499 basicdieinfo (&di
, thisdie
, objfile
);
2500 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2504 else if (di
.die_tag
!= TAG_compile_unit
)
2506 nextdie
= thisdie
+ di
.die_length
;
2510 completedieinfo (&di
, objfile
);
2511 if (di
.at_sibling
!= 0)
2513 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2517 nextdie
= thisdie
+ di
.die_length
;
2519 curoff
= thisdie
- dbbase
;
2520 culength
= nextdie
- thisdie
;
2521 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2523 /* First allocate a new partial symbol table structure */
2525 pst
= start_psymtab_common (objfile
, base_section_offsets
, di
.at_name
,
2527 objfile
-> global_psymbols
.next
,
2528 objfile
-> static_psymbols
.next
);
2530 pst
-> texthigh
= di
.at_high_pc
;
2531 pst
-> read_symtab_private
= (char *)
2532 obstack_alloc (&objfile
-> psymbol_obstack
,
2533 sizeof (struct dwfinfo
));
2534 DBFOFF (pst
) = dbfoff
;
2535 DBROFF (pst
) = curoff
;
2536 DBLENGTH (pst
) = culength
;
2537 LNFOFF (pst
) = curlnoffset
;
2538 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2540 /* Now look for partial symbols */
2542 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2544 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2545 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2546 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2547 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2548 sort_pst_symbols (pst
);
2549 /* If there is already a psymtab or symtab for a file of this name,
2550 remove it. (If there is a symtab, more drastic things also
2551 happen.) This happens in VxWorks. */
2552 free_named_symtabs (pst
-> filename
);
2562 new_symbol -- make a symbol table entry for a new symbol
2566 static struct symbol *new_symbol (struct dieinfo *dip,
2567 struct objfile *objfile)
2571 Given a pointer to a DWARF information entry, figure out if we need
2572 to make a symbol table entry for it, and if so, create a new entry
2573 and return a pointer to it.
2576 static struct symbol
*
2577 new_symbol (dip
, objfile
)
2578 struct dieinfo
*dip
;
2579 struct objfile
*objfile
;
2581 struct symbol
*sym
= NULL
;
2583 if (dip
-> at_name
!= NULL
)
2585 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2586 sizeof (struct symbol
));
2587 memset (sym
, 0, sizeof (struct symbol
));
2588 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
, &objfile
->symbol_obstack
);
2589 /* default assumptions */
2590 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2591 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2592 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2593 switch (dip
-> die_tag
)
2596 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2597 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2599 case TAG_global_subroutine
:
2600 case TAG_subroutine
:
2601 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2602 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2603 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2604 if (dip
-> die_tag
== TAG_global_subroutine
)
2606 add_symbol_to_list (sym
, &global_symbols
);
2610 add_symbol_to_list (sym
, list_in_scope
);
2613 case TAG_global_variable
:
2614 if (dip
-> at_location
!= NULL
)
2616 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2617 add_symbol_to_list (sym
, &global_symbols
);
2618 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2619 SYMBOL_VALUE (sym
) += baseaddr
;
2622 case TAG_local_variable
:
2623 if (dip
-> at_location
!= NULL
)
2625 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2626 add_symbol_to_list (sym
, list_in_scope
);
2629 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2633 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2637 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2638 SYMBOL_VALUE (sym
) += baseaddr
;
2642 case TAG_formal_parameter
:
2643 if (dip
-> at_location
!= NULL
)
2645 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2647 add_symbol_to_list (sym
, list_in_scope
);
2650 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2654 SYMBOL_CLASS (sym
) = LOC_ARG
;
2657 case TAG_unspecified_parameters
:
2658 /* From varargs functions; gdb doesn't seem to have any interest in
2659 this information, so just ignore it for now. (FIXME?) */
2661 case TAG_structure_type
:
2662 case TAG_union_type
:
2663 case TAG_enumeration_type
:
2664 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2665 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2666 add_symbol_to_list (sym
, list_in_scope
);
2669 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2670 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2671 add_symbol_to_list (sym
, list_in_scope
);
2674 /* Not a tag we recognize. Hopefully we aren't processing trash
2675 data, but since we must specifically ignore things we don't
2676 recognize, there is nothing else we should do at this point. */
2687 decode_mod_fund_type -- decode a modified fundamental type
2691 static struct type *decode_mod_fund_type (char *typedata)
2695 Decode a block of data containing a modified fundamental
2696 type specification. TYPEDATA is a pointer to the block,
2697 which starts with a length containing the size of the rest
2698 of the block. At the end of the block is a fundmental type
2699 code value that gives the fundamental type. Everything
2700 in between are type modifiers.
2702 We simply compute the number of modifiers and call the general
2703 function decode_modified_type to do the actual work.
2706 static struct type
*
2707 decode_mod_fund_type (typedata
)
2710 struct type
*typep
= NULL
;
2711 unsigned short modcount
;
2714 /* Get the total size of the block, exclusive of the size itself */
2716 nbytes
= attribute_size (AT_mod_fund_type
);
2717 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2720 /* Deduct the size of the fundamental type bytes at the end of the block. */
2722 modcount
-= attribute_size (AT_fund_type
);
2724 /* Now do the actual decoding */
2726 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2734 decode_mod_u_d_type -- decode a modified user defined type
2738 static struct type *decode_mod_u_d_type (char *typedata)
2742 Decode a block of data containing a modified user defined
2743 type specification. TYPEDATA is a pointer to the block,
2744 which consists of a two byte length, containing the size
2745 of the rest of the block. At the end of the block is a
2746 four byte value that gives a reference to a user defined type.
2747 Everything in between are type modifiers.
2749 We simply compute the number of modifiers and call the general
2750 function decode_modified_type to do the actual work.
2753 static struct type
*
2754 decode_mod_u_d_type (typedata
)
2757 struct type
*typep
= NULL
;
2758 unsigned short modcount
;
2761 /* Get the total size of the block, exclusive of the size itself */
2763 nbytes
= attribute_size (AT_mod_u_d_type
);
2764 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2767 /* Deduct the size of the reference type bytes at the end of the block. */
2769 modcount
-= attribute_size (AT_user_def_type
);
2771 /* Now do the actual decoding */
2773 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2781 decode_modified_type -- decode modified user or fundamental type
2785 static struct type *decode_modified_type (char *modifiers,
2786 unsigned short modcount, int mtype)
2790 Decode a modified type, either a modified fundamental type or
2791 a modified user defined type. MODIFIERS is a pointer to the
2792 block of bytes that define MODCOUNT modifiers. Immediately
2793 following the last modifier is a short containing the fundamental
2794 type or a long containing the reference to the user defined
2795 type. Which one is determined by MTYPE, which is either
2796 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2797 type we are generating.
2799 We call ourself recursively to generate each modified type,`
2800 until MODCOUNT reaches zero, at which point we have consumed
2801 all the modifiers and generate either the fundamental type or
2802 user defined type. When the recursion unwinds, each modifier
2803 is applied in turn to generate the full modified type.
2807 If we find a modifier that we don't recognize, and it is not one
2808 of those reserved for application specific use, then we issue a
2809 warning and simply ignore the modifier.
2813 We currently ignore MOD_const and MOD_volatile. (FIXME)
2817 static struct type
*
2818 decode_modified_type (modifiers
, modcount
, mtype
)
2820 unsigned int modcount
;
2823 struct type
*typep
= NULL
;
2824 unsigned short fundtype
;
2833 case AT_mod_fund_type
:
2834 nbytes
= attribute_size (AT_fund_type
);
2835 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2837 typep
= decode_fund_type (fundtype
);
2839 case AT_mod_u_d_type
:
2840 nbytes
= attribute_size (AT_user_def_type
);
2841 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
2843 if ((typep
= lookup_utype (die_ref
)) == NULL
)
2845 typep
= alloc_utype (die_ref
, NULL
);
2849 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
2850 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2856 modifier
= *modifiers
++;
2857 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
2860 case MOD_pointer_to
:
2861 typep
= lookup_pointer_type (typep
);
2863 case MOD_reference_to
:
2864 typep
= lookup_reference_type (typep
);
2867 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
2870 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
2873 if (!(MOD_lo_user
<= (unsigned char) modifier
2874 && (unsigned char) modifier
<= MOD_hi_user
))
2876 SQUAWK (("unknown type modifier %u",
2877 (unsigned char) modifier
));
2889 decode_fund_type -- translate basic DWARF type to gdb base type
2893 Given an integer that is one of the fundamental DWARF types,
2894 translate it to one of the basic internal gdb types and return
2895 a pointer to the appropriate gdb type (a "struct type *").
2899 If we encounter a fundamental type that we are unprepared to
2900 deal with, and it is not in the range of those types defined
2901 as application specific types, then we issue a warning and
2902 treat the type as an "int".
2905 static struct type
*
2906 decode_fund_type (fundtype
)
2907 unsigned int fundtype
;
2909 struct type
*typep
= NULL
;
2915 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2918 case FT_boolean
: /* Was FT_set in AT&T version */
2919 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
2922 case FT_pointer
: /* (void *) */
2923 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
2924 typep
= lookup_pointer_type (typep
);
2928 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
2931 case FT_signed_char
:
2932 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
2935 case FT_unsigned_char
:
2936 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
2940 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
2943 case FT_signed_short
:
2944 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
2947 case FT_unsigned_short
:
2948 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
2952 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2955 case FT_signed_integer
:
2956 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
2959 case FT_unsigned_integer
:
2960 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2964 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
2967 case FT_signed_long
:
2968 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
2971 case FT_unsigned_long
:
2972 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2976 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
2979 case FT_signed_long_long
:
2980 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
2983 case FT_unsigned_long_long
:
2984 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
2988 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2991 case FT_dbl_prec_float
:
2992 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
2995 case FT_ext_prec_float
:
2996 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3000 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3003 case FT_dbl_prec_complex
:
3004 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3007 case FT_ext_prec_complex
:
3008 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3013 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3015 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3016 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3026 create_name -- allocate a fresh copy of a string on an obstack
3030 Given a pointer to a string and a pointer to an obstack, allocates
3031 a fresh copy of the string on the specified obstack.
3036 create_name (name
, obstackp
)
3038 struct obstack
*obstackp
;
3043 length
= strlen (name
) + 1;
3044 newname
= (char *) obstack_alloc (obstackp
, length
);
3045 strcpy (newname
, name
);
3053 basicdieinfo -- extract the minimal die info from raw die data
3057 void basicdieinfo (char *diep, struct dieinfo *dip,
3058 struct objfile *objfile)
3062 Given a pointer to raw DIE data, and a pointer to an instance of a
3063 die info structure, this function extracts the basic information
3064 from the DIE data required to continue processing this DIE, along
3065 with some bookkeeping information about the DIE.
3067 The information we absolutely must have includes the DIE tag,
3068 and the DIE length. If we need the sibling reference, then we
3069 will have to call completedieinfo() to process all the remaining
3072 Note that since there is no guarantee that the data is properly
3073 aligned in memory for the type of access required (indirection
3074 through anything other than a char pointer), and there is no
3075 guarantee that it is in the same byte order as the gdb host,
3076 we call a function which deals with both alignment and byte
3077 swapping issues. Possibly inefficient, but quite portable.
3079 We also take care of some other basic things at this point, such
3080 as ensuring that the instance of the die info structure starts
3081 out completely zero'd and that curdie is initialized for use
3082 in error reporting if we have a problem with the current die.
3086 All DIE's must have at least a valid length, thus the minimum
3087 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3088 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3089 are forced to be TAG_padding DIES.
3091 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3092 that if a padding DIE is used for alignment and the amount needed is
3093 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3094 enough to align to the next alignment boundry.
3098 basicdieinfo (dip
, diep
, objfile
)
3099 struct dieinfo
*dip
;
3101 struct objfile
*objfile
;
3104 memset (dip
, 0, sizeof (struct dieinfo
));
3106 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3107 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3109 if (dip
-> die_length
< SIZEOF_DIE_LENGTH
)
3111 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3113 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3115 dip
-> die_tag
= TAG_padding
;
3119 diep
+= SIZEOF_DIE_LENGTH
;
3120 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3129 completedieinfo -- finish reading the information for a given DIE
3133 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3137 Given a pointer to an already partially initialized die info structure,
3138 scan the raw DIE data and finish filling in the die info structure
3139 from the various attributes found.
3141 Note that since there is no guarantee that the data is properly
3142 aligned in memory for the type of access required (indirection
3143 through anything other than a char pointer), and there is no
3144 guarantee that it is in the same byte order as the gdb host,
3145 we call a function which deals with both alignment and byte
3146 swapping issues. Possibly inefficient, but quite portable.
3150 Each time we are called, we increment the diecount variable, which
3151 keeps an approximate count of the number of dies processed for
3152 each compilation unit. This information is presented to the user
3153 if the info_verbose flag is set.
3158 completedieinfo (dip
, objfile
)
3159 struct dieinfo
*dip
;
3160 struct objfile
*objfile
;
3162 char *diep
; /* Current pointer into raw DIE data */
3163 char *end
; /* Terminate DIE scan here */
3164 unsigned short attr
; /* Current attribute being scanned */
3165 unsigned short form
; /* Form of the attribute */
3166 int nbytes
; /* Size of next field to read */
3170 end
= diep
+ dip
-> die_length
;
3171 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3174 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3175 diep
+= SIZEOF_ATTRIBUTE
;
3176 if ((nbytes
= attribute_size (attr
)) == -1)
3178 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3185 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3189 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3193 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3197 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3201 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3203 dip
-> has_at_stmt_list
= 1;
3206 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3208 dip
-> at_low_pc
+= baseaddr
;
3209 dip
-> has_at_low_pc
= 1;
3212 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3214 dip
-> at_high_pc
+= baseaddr
;
3217 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3220 case AT_user_def_type
:
3221 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3222 GET_UNSIGNED
, objfile
);
3225 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3229 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3233 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3237 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3241 dip
-> at_location
= diep
;
3243 case AT_mod_fund_type
:
3244 dip
-> at_mod_fund_type
= diep
;
3246 case AT_subscr_data
:
3247 dip
-> at_subscr_data
= diep
;
3249 case AT_mod_u_d_type
:
3250 dip
-> at_mod_u_d_type
= diep
;
3252 case AT_element_list
:
3253 dip
-> at_element_list
= diep
;
3254 dip
-> short_element_list
= 0;
3256 case AT_short_element_list
:
3257 dip
-> at_element_list
= diep
;
3258 dip
-> short_element_list
= 1;
3260 case AT_discr_value
:
3261 dip
-> at_discr_value
= diep
;
3263 case AT_string_length
:
3264 dip
-> at_string_length
= diep
;
3267 dip
-> at_name
= diep
;
3270 /* For now, ignore any "hostname:" portion, since gdb doesn't
3271 know how to deal with it. (FIXME). */
3272 dip
-> at_comp_dir
= strrchr (diep
, ':');
3273 if (dip
-> at_comp_dir
!= NULL
)
3275 dip
-> at_comp_dir
++;
3279 dip
-> at_comp_dir
= diep
;
3283 dip
-> at_producer
= diep
;
3285 case AT_start_scope
:
3286 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3289 case AT_stride_size
:
3290 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3294 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3298 dip
-> at_prototyped
= diep
;
3301 /* Found an attribute that we are unprepared to handle. However
3302 it is specifically one of the design goals of DWARF that
3303 consumers should ignore unknown attributes. As long as the
3304 form is one that we recognize (so we know how to skip it),
3305 we can just ignore the unknown attribute. */
3308 form
= FORM_FROM_ATTR (attr
);
3322 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3325 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3328 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3331 diep
+= strlen (diep
) + 1;
3334 SQUAWK (("unknown attribute form (0x%x)", form
));
3335 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3346 target_to_host -- swap in target data to host
3350 target_to_host (char *from, int nbytes, int signextend,
3351 struct objfile *objfile)
3355 Given pointer to data in target format in FROM, a byte count for
3356 the size of the data in NBYTES, a flag indicating whether or not
3357 the data is signed in SIGNEXTEND, and a pointer to the current
3358 objfile in OBJFILE, convert the data to host format and return
3359 the converted value.
3363 FIXME: If we read data that is known to be signed, and expect to
3364 use it as signed data, then we need to explicitly sign extend the
3365 result until the bfd library is able to do this for us.
3369 static unsigned long
3370 target_to_host (from
, nbytes
, signextend
, objfile
)
3373 int signextend
; /* FIXME: Unused */
3374 struct objfile
*objfile
;
3376 unsigned long rtnval
;
3381 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3384 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3387 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3390 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3393 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3404 attribute_size -- compute size of data for a DWARF attribute
3408 static int attribute_size (unsigned int attr)
3412 Given a DWARF attribute in ATTR, compute the size of the first
3413 piece of data associated with this attribute and return that
3416 Returns -1 for unrecognized attributes.
3421 attribute_size (attr
)
3424 int nbytes
; /* Size of next data for this attribute */
3425 unsigned short form
; /* Form of the attribute */
3427 form
= FORM_FROM_ATTR (attr
);
3430 case FORM_STRING
: /* A variable length field is next */
3433 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3434 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3437 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3438 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3439 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3442 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3445 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3446 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3449 SQUAWK (("unknown attribute form (0x%x)", form
));