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 has_at_byte_size
:1;
208 unsigned int short_element_list
:1;
211 static int diecount
; /* Approximate count of dies for compilation unit */
212 static struct dieinfo
*curdie
; /* For warnings and such */
214 static char *dbbase
; /* Base pointer to dwarf info */
215 static int dbroff
; /* Relative offset from start of .debug section */
216 static char *lnbase
; /* Base pointer to line section */
217 static int isreg
; /* Kludge to identify register variables */
218 static int offreg
; /* Kludge to identify basereg references */
220 /* This value is added to each symbol value. FIXME: Generalize to
221 the section_offsets structure used by dbxread. */
222 static CORE_ADDR baseaddr
; /* Add to each symbol value */
224 /* The section offsets used in the current psymtab or symtab. FIXME,
225 only used to pass one value (baseaddr) at the moment. */
226 static struct section_offsets
*base_section_offsets
;
228 /* Each partial symbol table entry contains a pointer to private data for the
229 read_symtab() function to use when expanding a partial symbol table entry
230 to a full symbol table entry. For DWARF debugging info, this data is
231 contained in the following structure and macros are provided for easy
232 access to the members given a pointer to a partial symbol table entry.
234 dbfoff Always the absolute file offset to the start of the ".debug"
235 section for the file containing the DIE's being accessed.
237 dbroff Relative offset from the start of the ".debug" access to the
238 first DIE to be accessed. When building the partial symbol
239 table, this value will be zero since we are accessing the
240 entire ".debug" section. When expanding a partial symbol
241 table entry, this value will be the offset to the first
242 DIE for the compilation unit containing the symbol that
243 triggers the expansion.
245 dblength The size of the chunk of DIE's being examined, in bytes.
247 lnfoff The absolute file offset to the line table fragment. Ignored
248 when building partial symbol tables, but used when expanding
249 them, and contains the absolute file offset to the fragment
250 of the ".line" section containing the line numbers for the
251 current compilation unit.
255 int dbfoff
; /* Absolute file offset to start of .debug section */
256 int dbroff
; /* Relative offset from start of .debug section */
257 int dblength
; /* Size of the chunk of DIE's being examined */
258 int lnfoff
; /* Absolute file offset to line table fragment */
261 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
262 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
263 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
264 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
266 /* The generic symbol table building routines have separate lists for
267 file scope symbols and all all other scopes (local scopes). So
268 we need to select the right one to pass to add_symbol_to_list().
269 We do it by keeping a pointer to the correct list in list_in_scope.
271 FIXME: The original dwarf code just treated the file scope as the first
272 local scope, and all other local scopes as nested local scopes, and worked
273 fine. Check to see if we really need to distinguish these in buildsym.c */
275 struct pending
**list_in_scope
= &file_symbols
;
277 /* DIES which have user defined types or modified user defined types refer to
278 other DIES for the type information. Thus we need to associate the offset
279 of a DIE for a user defined type with a pointer to the type information.
281 Originally this was done using a simple but expensive algorithm, with an
282 array of unsorted structures, each containing an offset/type-pointer pair.
283 This array was scanned linearly each time a lookup was done. The result
284 was that gdb was spending over half it's startup time munging through this
285 array of pointers looking for a structure that had the right offset member.
287 The second attempt used the same array of structures, but the array was
288 sorted using qsort each time a new offset/type was recorded, and a binary
289 search was used to find the type pointer for a given DIE offset. This was
290 even slower, due to the overhead of sorting the array each time a new
291 offset/type pair was entered.
293 The third attempt uses a fixed size array of type pointers, indexed by a
294 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
295 we can divide any DIE offset by 4 to obtain a unique index into this fixed
296 size array. Since each element is a 4 byte pointer, it takes exactly as
297 much memory to hold this array as to hold the DWARF info for a given
298 compilation unit. But it gets freed as soon as we are done with it. */
300 static struct type
**utypes
; /* Pointer to array of user type pointers */
301 static int numutypes
; /* Max number of user type pointers */
303 /* Record the language for the compilation unit which is currently being
304 processed. We know it once we have seen the TAG_compile_unit DIE,
305 and we need it while processing the DIE's for that compilation unit.
306 It is eventually saved in the symtab structure, but we don't finalize
307 the symtab struct until we have processed all the DIE's for the
310 static enum language cu_language
;
312 /* Forward declarations of static functions so we don't have to worry
313 about ordering within this file. */
316 attribute_size
PARAMS ((unsigned int));
319 target_to_host
PARAMS ((char *, int, int, struct objfile
*));
322 add_enum_psymbol
PARAMS ((struct dieinfo
*, struct objfile
*));
325 handle_producer
PARAMS ((char *));
328 read_file_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
331 read_func_scope
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
334 read_lexical_block_scope
PARAMS ((struct dieinfo
*, char *, char *,
341 scan_partial_symbols
PARAMS ((char *, char *, struct objfile
*));
344 scan_compilation_units
PARAMS ((char *, char *, char *, unsigned int,
345 unsigned int, struct objfile
*));
348 add_partial_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
351 init_psymbol_list
PARAMS ((struct objfile
*, int));
354 basicdieinfo
PARAMS ((struct dieinfo
*, char *, struct objfile
*));
357 completedieinfo
PARAMS ((struct dieinfo
*, struct objfile
*));
360 dwarf_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
363 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
365 static struct symtab
*
366 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
369 process_dies
PARAMS ((char *, char *, struct objfile
*));
372 read_structure_scope
PARAMS ((struct dieinfo
*, char *, char *,
376 decode_array_element_type
PARAMS ((char *));
379 decode_subscr_data
PARAMS ((char *, char *));
382 dwarf_read_array_type
PARAMS ((struct dieinfo
*));
385 read_tag_pointer_type
PARAMS ((struct dieinfo
*dip
));
388 read_subroutine_type
PARAMS ((struct dieinfo
*, char *, char *));
391 read_enumeration
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
394 struct_type
PARAMS ((struct dieinfo
*, char *, char *, struct objfile
*));
397 enum_type
PARAMS ((struct dieinfo
*, struct objfile
*));
400 decode_line_numbers
PARAMS ((char *));
403 decode_die_type
PARAMS ((struct dieinfo
*));
406 decode_mod_fund_type
PARAMS ((char *));
409 decode_mod_u_d_type
PARAMS ((char *));
412 decode_modified_type
PARAMS ((char *, unsigned int, int));
415 decode_fund_type
PARAMS ((unsigned int));
418 create_name
PARAMS ((char *, struct obstack
*));
421 lookup_utype
PARAMS ((DIE_REF
));
424 alloc_utype
PARAMS ((DIE_REF
, struct type
*));
426 static struct symbol
*
427 new_symbol
PARAMS ((struct dieinfo
*, struct objfile
*));
430 synthesize_typedef
PARAMS ((struct dieinfo
*, struct objfile
*,
434 locval
PARAMS ((char *));
437 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
441 set_cu_language
PARAMS ((struct dieinfo
*));
447 set_cu_language -- set local copy of language for compilation unit
452 set_cu_language (struct dieinfo *dip)
456 Decode the language attribute for a compilation unit DIE and
457 remember what the language was. We use this at various times
458 when processing DIE's for a given compilation unit.
467 set_cu_language (dip
)
470 switch (dip
-> at_language
)
474 cu_language
= language_c
;
476 case LANG_C_PLUS_PLUS
:
477 cu_language
= language_cplus
;
487 cu_language
= language_unknown
;
496 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
500 void dwarf_build_psymtabs (int desc, char *filename,
501 struct section_offsets *section_offsets,
502 int mainline, unsigned int dbfoff, unsigned int dbsize,
503 unsigned int lnoffset, unsigned int lnsize,
504 struct objfile *objfile)
508 This function is called upon to build partial symtabs from files
509 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
511 It is passed a file descriptor for an open file containing the DIES
512 and line number information, the corresponding filename for that
513 file, a base address for relocating the symbols, a flag indicating
514 whether or not this debugging information is from a "main symbol
515 table" rather than a shared library or dynamically linked file,
516 and file offset/size pairs for the DIE information and line number
526 dwarf_build_psymtabs (desc
, filename
, section_offsets
, mainline
, dbfoff
, dbsize
,
527 lnoffset
, lnsize
, objfile
)
530 struct section_offsets
*section_offsets
;
534 unsigned int lnoffset
;
536 struct objfile
*objfile
;
538 struct cleanup
*back_to
;
540 current_objfile
= objfile
;
541 dbbase
= xmalloc (dbsize
);
543 if ((lseek (desc
, dbfoff
, 0) != dbfoff
) ||
544 (read (desc
, dbbase
, dbsize
) != dbsize
))
547 error ("can't read DWARF data from '%s'", filename
);
549 back_to
= make_cleanup (free
, dbbase
);
551 /* If we are reinitializing, or if we have never loaded syms yet, init.
552 Since we have no idea how many DIES we are looking at, we just guess
553 some arbitrary value. */
555 if (mainline
|| objfile
-> global_psymbols
.size
== 0 ||
556 objfile
-> static_psymbols
.size
== 0)
558 init_psymbol_list (objfile
, 1024);
561 /* Save the relocation factor where everybody can see it. */
563 base_section_offsets
= section_offsets
;
564 baseaddr
= ANOFFSET (section_offsets
, 0);
566 /* Follow the compilation unit sibling chain, building a partial symbol
567 table entry for each one. Save enough information about each compilation
568 unit to locate the full DWARF information later. */
570 scan_compilation_units (filename
, dbbase
, dbbase
+ dbsize
,
571 dbfoff
, lnoffset
, objfile
);
573 do_cleanups (back_to
);
574 current_objfile
= NULL
;
582 record_minimal_symbol -- add entry to gdb's minimal symbol table
586 static void record_minimal_symbol (char *name, CORE_ADDR address,
587 enum minimal_symbol_type ms_type,
588 struct objfile *objfile)
592 Given a pointer to the name of a symbol that should be added to the
593 minimal symbol table, and the address associated with that
594 symbol, records this information for later use in building the
595 minimal symbol table.
600 record_minimal_symbol (name
, address
, ms_type
, objfile
)
603 enum minimal_symbol_type ms_type
;
604 struct objfile
*objfile
;
606 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
607 prim_record_minimal_symbol (name
, address
, ms_type
);
614 dwarfwarn -- issue a DWARF related warning
618 Issue warnings about DWARF related things that aren't serious enough
619 to warrant aborting with an error, but should not be ignored either.
620 This includes things like detectable corruption in DIE's, missing
621 DIE's, unimplemented features, etc.
623 In general, running across tags or attributes that we don't recognize
624 is not considered to be a problem and we should not issue warnings
629 We mostly follow the example of the error() routine, but without
630 returning to command level. It is arguable about whether warnings
631 should be issued at all, and if so, where they should go (stdout or
634 We assume that curdie is valid and contains at least the basic
635 information for the DIE where the problem was noticed.
646 fmt
= va_arg (ap
, char *);
648 fprintf (stderr
, "warning: DWARF ref 0x%x: ", curdie
-> die_ref
);
649 if (curdie
-> at_name
)
651 fprintf (stderr
, "'%s': ", curdie
-> at_name
);
653 vfprintf (stderr
, fmt
, ap
);
654 fprintf (stderr
, "\n");
663 read_lexical_block_scope -- process all dies in a lexical block
667 static void read_lexical_block_scope (struct dieinfo *dip,
668 char *thisdie, char *enddie)
672 Process all the DIES contained within a lexical block scope.
673 Start a new scope, process the dies, and then close the scope.
678 read_lexical_block_scope (dip
, thisdie
, enddie
, objfile
)
682 struct objfile
*objfile
;
684 register struct context_stack
*new;
686 push_context (0, dip
-> at_low_pc
);
687 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
688 new = pop_context ();
689 if (local_symbols
!= NULL
)
691 finish_block (0, &local_symbols
, new -> old_blocks
, new -> start_addr
,
692 dip
-> at_high_pc
, objfile
);
694 local_symbols
= new -> locals
;
701 lookup_utype -- look up a user defined type from die reference
705 static type *lookup_utype (DIE_REF die_ref)
709 Given a DIE reference, lookup the user defined type associated with
710 that DIE, if it has been registered already. If not registered, then
711 return NULL. Alloc_utype() can be called to register an empty
712 type for this reference, which will be filled in later when the
713 actual referenced DIE is processed.
717 lookup_utype (die_ref
)
720 struct type
*type
= NULL
;
723 utypeidx
= (die_ref
- dbroff
) / 4;
724 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
726 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
730 type
= *(utypes
+ utypeidx
);
740 alloc_utype -- add a user defined type for die reference
744 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
748 Given a die reference DIE_REF, and a possible pointer to a user
749 defined type UTYPEP, register that this reference has a user
750 defined type and either use the specified type in UTYPEP or
751 make a new empty type that will be filled in later.
753 We should only be called after calling lookup_utype() to verify that
754 there is not currently a type registered for DIE_REF.
758 alloc_utype (die_ref
, utypep
)
765 utypeidx
= (die_ref
- dbroff
) / 4;
766 typep
= utypes
+ utypeidx
;
767 if ((utypeidx
< 0) || (utypeidx
>= numutypes
))
769 utypep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
770 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", die_ref
);
772 else if (*typep
!= NULL
)
775 SQUAWK (("internal error: dup user type allocation"));
781 utypep
= alloc_type (current_objfile
);
792 decode_die_type -- return a type for a specified die
796 static struct type *decode_die_type (struct dieinfo *dip)
800 Given a pointer to a die information structure DIP, decode the
801 type of the die and return a pointer to the decoded type. All
802 dies without specific types default to type int.
806 decode_die_type (dip
)
809 struct type
*type
= NULL
;
811 if (dip
-> at_fund_type
!= 0)
813 type
= decode_fund_type (dip
-> at_fund_type
);
815 else if (dip
-> at_mod_fund_type
!= NULL
)
817 type
= decode_mod_fund_type (dip
-> at_mod_fund_type
);
819 else if (dip
-> at_user_def_type
)
821 if ((type
= lookup_utype (dip
-> at_user_def_type
)) == NULL
)
823 type
= alloc_utype (dip
-> at_user_def_type
, NULL
);
826 else if (dip
-> at_mod_u_d_type
)
828 type
= decode_mod_u_d_type (dip
-> at_mod_u_d_type
);
832 type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
841 struct_type -- compute and return the type for a struct or union
845 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
846 char *enddie, struct objfile *objfile)
850 Given pointer to a die information structure for a die which
851 defines a union or structure (and MUST define one or the other),
852 and pointers to the raw die data that define the range of dies which
853 define the members, compute and return the user defined type for the
858 struct_type (dip
, thisdie
, enddie
, objfile
)
862 struct objfile
*objfile
;
866 struct nextfield
*next
;
869 struct nextfield
*list
= NULL
;
870 struct nextfield
*new;
878 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
880 /* No forward references created an empty type, so install one now */
881 type
= alloc_utype (dip
-> die_ref
, NULL
);
883 INIT_CPLUS_SPECIFIC(type
);
884 switch (dip
-> die_tag
)
887 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
890 case TAG_structure_type
:
891 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
895 TYPE_CODE (type
) = TYPE_CODE_UNION
;
899 /* Should never happen */
900 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
902 SQUAWK (("missing class, structure, or union tag"));
905 /* Some compilers try to be helpful by inventing "fake" names for
906 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
907 Thanks, but no thanks... */
908 if (dip
-> at_name
!= NULL
909 && *dip
-> at_name
!= '~'
910 && *dip
-> at_name
!= '.')
912 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
,
913 tpart1
, " ", dip
-> at_name
);
915 /* Use whatever size is known. Zero is a valid size. We might however
916 wish to check has_at_byte_size to make sure that some byte size was
917 given explicitly, but DWARF doesn't specify that explicit sizes of
918 zero have to present, so complaining about missing sizes should
919 probably not be the default. */
920 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
921 thisdie
+= dip
-> die_length
;
922 while (thisdie
< enddie
)
924 basicdieinfo (&mbr
, thisdie
, objfile
);
925 completedieinfo (&mbr
, objfile
);
926 if (mbr
.die_length
<= SIZEOF_DIE_LENGTH
)
930 else if (mbr
.at_sibling
!= 0)
932 nextdie
= dbbase
+ mbr
.at_sibling
- dbroff
;
936 nextdie
= thisdie
+ mbr
.die_length
;
941 /* Get space to record the next field's data. */
942 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
947 obsavestring (mbr
.at_name
, strlen (mbr
.at_name
),
948 &objfile
-> type_obstack
);
949 list
-> field
.type
= decode_die_type (&mbr
);
950 list
-> field
.bitpos
= 8 * locval (mbr
.at_location
);
951 /* Handle bit fields. */
952 list
-> field
.bitsize
= mbr
.at_bit_size
;
954 /* For big endian bits, the at_bit_offset gives the additional
955 bit offset from the MSB of the containing anonymous object to
956 the MSB of the field. We don't have to do anything special
957 since we don't need to know the size of the anonymous object. */
958 list
-> field
.bitpos
+= mbr
.at_bit_offset
;
960 /* For little endian bits, we need to have a non-zero at_bit_size,
961 so that we know we are in fact dealing with a bitfield. Compute
962 the bit offset to the MSB of the anonymous object, subtract off
963 the number of bits from the MSB of the field to the MSB of the
964 object, and then subtract off the number of bits of the field
965 itself. The result is the bit offset of the LSB of the field. */
966 if (mbr
.at_bit_size
> 0)
968 if (mbr
.has_at_byte_size
)
970 /* The size of the anonymous object containing the bit field
971 is explicit, so use the indicated size (in bytes). */
972 anonymous_size
= mbr
.at_byte_size
;
976 /* The size of the anonymous object containing the bit field
977 matches the size of an object of the bit field's type.
978 DWARF allows at_byte_size to be left out in such cases,
979 as a debug information size optimization. */
980 anonymous_size
= TYPE_LENGTH (list
-> field
.type
);
982 list
-> field
.bitpos
+=
983 anonymous_size
* 8 - mbr
.at_bit_offset
- mbr
.at_bit_size
;
989 process_dies (thisdie
, nextdie
, objfile
);
994 /* Now create the vector of fields, and record how big it is. We may
995 not even have any fields, if this DIE was generated due to a reference
996 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
997 set, which clues gdb in to the fact that it needs to search elsewhere
998 for the full structure definition. */
1001 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1005 TYPE_NFIELDS (type
) = nfields
;
1006 TYPE_FIELDS (type
) = (struct field
*)
1007 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1008 /* Copy the saved-up fields into the field vector. */
1009 for (n
= nfields
; list
; list
= list
-> next
)
1011 TYPE_FIELD (type
, --n
) = list
-> field
;
1021 read_structure_scope -- process all dies within struct or union
1025 static void read_structure_scope (struct dieinfo *dip,
1026 char *thisdie, char *enddie, struct objfile *objfile)
1030 Called when we find the DIE that starts a structure or union
1031 scope (definition) to process all dies that define the members
1032 of the structure or union. DIP is a pointer to the die info
1033 struct for the DIE that names the structure or union.
1037 Note that we need to call struct_type regardless of whether or not
1038 the DIE has an at_name attribute, since it might be an anonymous
1039 structure or union. This gets the type entered into our set of
1042 However, if the structure is incomplete (an opaque struct/union)
1043 then suppress creating a symbol table entry for it since gdb only
1044 wants to find the one with the complete definition. Note that if
1045 it is complete, we just call new_symbol, which does it's own
1046 checking about whether the struct/union is anonymous or not (and
1047 suppresses creating a symbol table entry itself).
1052 read_structure_scope (dip
, thisdie
, enddie
, objfile
)
1053 struct dieinfo
*dip
;
1056 struct objfile
*objfile
;
1061 type
= struct_type (dip
, thisdie
, enddie
, objfile
);
1062 if (!(TYPE_FLAGS (type
) & TYPE_FLAG_STUB
))
1064 sym
= new_symbol (dip
, objfile
);
1067 SYMBOL_TYPE (sym
) = type
;
1068 if (cu_language
== language_cplus
)
1070 synthesize_typedef (dip
, objfile
, type
);
1080 decode_array_element_type -- decode type of the array elements
1084 static struct type *decode_array_element_type (char *scan, char *end)
1088 As the last step in decoding the array subscript information for an
1089 array DIE, we need to decode the type of the array elements. We are
1090 passed a pointer to this last part of the subscript information and
1091 must return the appropriate type. If the type attribute is not
1092 recognized, just warn about the problem and return type int.
1095 static struct type
*
1096 decode_array_element_type (scan
)
1101 unsigned short attribute
;
1102 unsigned short fundtype
;
1105 attribute
= target_to_host (scan
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
,
1107 scan
+= SIZEOF_ATTRIBUTE
;
1108 if ((nbytes
= attribute_size (attribute
)) == -1)
1110 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1111 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1118 fundtype
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1120 typep
= decode_fund_type (fundtype
);
1122 case AT_mod_fund_type
:
1123 typep
= decode_mod_fund_type (scan
);
1125 case AT_user_def_type
:
1126 die_ref
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1128 if ((typep
= lookup_utype (die_ref
)) == NULL
)
1130 typep
= alloc_utype (die_ref
, NULL
);
1133 case AT_mod_u_d_type
:
1134 typep
= decode_mod_u_d_type (scan
);
1137 SQUAWK (("bad array element type attribute 0x%x", attribute
));
1138 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1149 decode_subscr_data -- decode array subscript and element type data
1153 static struct type *decode_subscr_data (char *scan, char *end)
1157 The array subscripts and the data type of the elements of an
1158 array are described by a list of data items, stored as a block
1159 of contiguous bytes. There is a data item describing each array
1160 dimension, and a final data item describing the element type.
1161 The data items are ordered the same as their appearance in the
1162 source (I.E. leftmost dimension first, next to leftmost second,
1165 We are passed a pointer to the start of the block of bytes
1166 containing the data items, and a pointer to the first byte past
1167 the data. This function decodes the data and returns a type.
1170 FIXME: This code only implements the forms currently used
1171 by the AT&T and GNU C compilers.
1173 The end pointer is supplied for error checking, maybe we should
1177 static struct type
*
1178 decode_subscr_data (scan
, end
)
1182 struct type
*typep
= NULL
;
1183 struct type
*nexttype
;
1184 unsigned int format
;
1185 unsigned short fundtype
;
1186 unsigned long lowbound
;
1187 unsigned long highbound
;
1190 format
= target_to_host (scan
, SIZEOF_FORMAT_SPECIFIER
, GET_UNSIGNED
,
1192 scan
+= SIZEOF_FORMAT_SPECIFIER
;
1196 typep
= decode_array_element_type (scan
);
1199 fundtype
= target_to_host (scan
, SIZEOF_FMT_FT
, GET_UNSIGNED
,
1201 scan
+= SIZEOF_FMT_FT
;
1202 if (fundtype
!= FT_integer
&& fundtype
!= FT_signed_integer
1203 && fundtype
!= FT_unsigned_integer
)
1205 SQUAWK (("array subscripts must be integral types, not type 0x%x",
1210 nbytes
= TARGET_FT_LONG_SIZE (current_objfile
);
1211 lowbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1214 highbound
= target_to_host (scan
, nbytes
, GET_UNSIGNED
,
1217 nexttype
= decode_subscr_data (scan
, end
);
1218 if (nexttype
!= NULL
)
1220 typep
= alloc_type (current_objfile
);
1221 TYPE_CODE (typep
) = TYPE_CODE_ARRAY
;
1222 TYPE_LENGTH (typep
) = TYPE_LENGTH (nexttype
);
1223 TYPE_LENGTH (typep
) *= (highbound
- lowbound
) + 1;
1224 TYPE_TARGET_TYPE (typep
) = nexttype
;
1235 SQUAWK (("array subscript format 0x%x not handled yet", format
));
1238 SQUAWK (("unknown array subscript format %x", format
));
1248 dwarf_read_array_type -- read TAG_array_type DIE
1252 static void dwarf_read_array_type (struct dieinfo *dip)
1256 Extract all information from a TAG_array_type DIE and add to
1257 the user defined type vector.
1261 dwarf_read_array_type (dip
)
1262 struct dieinfo
*dip
;
1268 unsigned short blocksz
;
1271 if (dip
-> at_ordering
!= ORD_row_major
)
1273 /* FIXME: Can gdb even handle column major arrays? */
1274 SQUAWK (("array not row major; not handled correctly"));
1276 if ((sub
= dip
-> at_subscr_data
) != NULL
)
1278 nbytes
= attribute_size (AT_subscr_data
);
1279 blocksz
= target_to_host (sub
, nbytes
, GET_UNSIGNED
, current_objfile
);
1280 subend
= sub
+ nbytes
+ blocksz
;
1282 type
= decode_subscr_data (sub
, subend
);
1285 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1287 utype
= alloc_utype (dip
-> die_ref
, NULL
);
1289 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1290 TYPE_TARGET_TYPE (utype
) =
1291 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1292 TYPE_LENGTH (utype
) = 1 * TYPE_LENGTH (TYPE_TARGET_TYPE (utype
));
1296 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1298 alloc_utype (dip
-> die_ref
, type
);
1302 TYPE_CODE (utype
) = TYPE_CODE_ARRAY
;
1303 TYPE_LENGTH (utype
) = TYPE_LENGTH (type
);
1304 TYPE_TARGET_TYPE (utype
) = TYPE_TARGET_TYPE (type
);
1314 read_tag_pointer_type -- read TAG_pointer_type DIE
1318 static void read_tag_pointer_type (struct dieinfo *dip)
1322 Extract all information from a TAG_pointer_type DIE and add to
1323 the user defined type vector.
1327 read_tag_pointer_type (dip
)
1328 struct dieinfo
*dip
;
1333 type
= decode_die_type (dip
);
1334 if ((utype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1336 utype
= lookup_pointer_type (type
);
1337 alloc_utype (dip
-> die_ref
, utype
);
1341 TYPE_TARGET_TYPE (utype
) = type
;
1342 TYPE_POINTER_TYPE (type
) = utype
;
1344 /* We assume the machine has only one representation for pointers! */
1345 /* FIXME: This confuses host<->target data representations, and is a
1346 poor assumption besides. */
1348 TYPE_LENGTH (utype
) = sizeof (char *);
1349 TYPE_CODE (utype
) = TYPE_CODE_PTR
;
1357 read_subroutine_type -- process TAG_subroutine_type dies
1361 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1366 Handle DIES due to C code like:
1369 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1375 The parameter DIES are currently ignored. See if gdb has a way to
1376 include this info in it's type system, and decode them if so. Is
1377 this what the type structure's "arg_types" field is for? (FIXME)
1381 read_subroutine_type (dip
, thisdie
, enddie
)
1382 struct dieinfo
*dip
;
1386 struct type
*type
; /* Type that this function returns */
1387 struct type
*ftype
; /* Function that returns above type */
1389 /* Decode the type that this subroutine returns */
1391 type
= decode_die_type (dip
);
1393 /* Check to see if we already have a partially constructed user
1394 defined type for this DIE, from a forward reference. */
1396 if ((ftype
= lookup_utype (dip
-> die_ref
)) == NULL
)
1398 /* This is the first reference to one of these types. Make
1399 a new one and place it in the user defined types. */
1400 ftype
= lookup_function_type (type
);
1401 alloc_utype (dip
-> die_ref
, ftype
);
1405 /* We have an existing partially constructed type, so bash it
1406 into the correct type. */
1407 TYPE_TARGET_TYPE (ftype
) = type
;
1408 TYPE_FUNCTION_TYPE (type
) = ftype
;
1409 TYPE_LENGTH (ftype
) = 1;
1410 TYPE_CODE (ftype
) = TYPE_CODE_FUNC
;
1418 read_enumeration -- process dies which define an enumeration
1422 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1423 char *enddie, struct objfile *objfile)
1427 Given a pointer to a die which begins an enumeration, process all
1428 the dies that define the members of the enumeration.
1432 Note that we need to call enum_type regardless of whether or not we
1433 have a symbol, since we might have an enum without a tag name (thus
1434 no symbol for the tagname).
1438 read_enumeration (dip
, thisdie
, enddie
, objfile
)
1439 struct dieinfo
*dip
;
1442 struct objfile
*objfile
;
1447 type
= enum_type (dip
, objfile
);
1448 sym
= new_symbol (dip
, objfile
);
1451 SYMBOL_TYPE (sym
) = type
;
1452 if (cu_language
== language_cplus
)
1454 synthesize_typedef (dip
, objfile
, type
);
1463 enum_type -- decode and return a type for an enumeration
1467 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1471 Given a pointer to a die information structure for the die which
1472 starts an enumeration, process all the dies that define the members
1473 of the enumeration and return a type pointer for the enumeration.
1475 At the same time, for each member of the enumeration, create a
1476 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1477 and give it the type of the enumeration itself.
1481 Note that the DWARF specification explicitly mandates that enum
1482 constants occur in reverse order from the source program order,
1483 for "consistency" and because this ordering is easier for many
1484 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1485 Entries). Because gdb wants to see the enum members in program
1486 source order, we have to ensure that the order gets reversed while
1487 we are processing them.
1490 static struct type
*
1491 enum_type (dip
, objfile
)
1492 struct dieinfo
*dip
;
1493 struct objfile
*objfile
;
1497 struct nextfield
*next
;
1500 struct nextfield
*list
= NULL
;
1501 struct nextfield
*new;
1506 unsigned short blocksz
;
1510 if ((type
= lookup_utype (dip
-> die_ref
)) == NULL
)
1512 /* No forward references created an empty type, so install one now */
1513 type
= alloc_utype (dip
-> die_ref
, NULL
);
1515 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1516 /* Some compilers try to be helpful by inventing "fake" names for
1517 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1518 Thanks, but no thanks... */
1519 if (dip
-> at_name
!= NULL
1520 && *dip
-> at_name
!= '~'
1521 && *dip
-> at_name
!= '.')
1523 TYPE_NAME (type
) = obconcat (&objfile
-> type_obstack
, "enum",
1524 " ", dip
-> at_name
);
1526 if (dip
-> at_byte_size
!= 0)
1528 TYPE_LENGTH (type
) = dip
-> at_byte_size
;
1530 if ((scan
= dip
-> at_element_list
) != NULL
)
1532 if (dip
-> short_element_list
)
1534 nbytes
= attribute_size (AT_short_element_list
);
1538 nbytes
= attribute_size (AT_element_list
);
1540 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
1541 listend
= scan
+ nbytes
+ blocksz
;
1543 while (scan
< listend
)
1545 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1548 list
-> field
.type
= NULL
;
1549 list
-> field
.bitsize
= 0;
1550 list
-> field
.bitpos
=
1551 target_to_host (scan
, TARGET_FT_LONG_SIZE (objfile
), GET_SIGNED
,
1553 scan
+= TARGET_FT_LONG_SIZE (objfile
);
1554 list
-> field
.name
= obsavestring (scan
, strlen (scan
),
1555 &objfile
-> type_obstack
);
1556 scan
+= strlen (scan
) + 1;
1558 /* Handcraft a new symbol for this enum member. */
1559 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1560 sizeof (struct symbol
));
1561 memset (sym
, 0, sizeof (struct symbol
));
1562 SYMBOL_NAME (sym
) = create_name (list
-> field
.name
,
1563 &objfile
->symbol_obstack
);
1564 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1565 SYMBOL_CLASS (sym
) = LOC_CONST
;
1566 SYMBOL_TYPE (sym
) = type
;
1567 SYMBOL_VALUE (sym
) = list
-> field
.bitpos
;
1568 add_symbol_to_list (sym
, list_in_scope
);
1570 /* Now create the vector of fields, and record how big it is. This is
1571 where we reverse the order, by pulling the members off the list in
1572 reverse order from how they were inserted. If we have no fields
1573 (this is apparently possible in C++) then skip building a field
1577 TYPE_NFIELDS (type
) = nfields
;
1578 TYPE_FIELDS (type
) = (struct field
*)
1579 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct field
) * nfields
);
1580 /* Copy the saved-up fields into the field vector. */
1581 for (n
= 0; (n
< nfields
) && (list
!= NULL
); list
= list
-> next
)
1583 TYPE_FIELD (type
, n
++) = list
-> field
;
1594 read_func_scope -- process all dies within a function scope
1598 Process all dies within a given function scope. We are passed
1599 a die information structure pointer DIP for the die which
1600 starts the function scope, and pointers into the raw die data
1601 that define the dies within the function scope.
1603 For now, we ignore lexical block scopes within the function.
1604 The problem is that AT&T cc does not define a DWARF lexical
1605 block scope for the function itself, while gcc defines a
1606 lexical block scope for the function. We need to think about
1607 how to handle this difference, or if it is even a problem.
1612 read_func_scope (dip
, thisdie
, enddie
, objfile
)
1613 struct dieinfo
*dip
;
1616 struct objfile
*objfile
;
1618 register struct context_stack
*new;
1620 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1621 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1623 objfile
-> ei
.entry_func_lowpc
= dip
-> at_low_pc
;
1624 objfile
-> ei
.entry_func_highpc
= dip
-> at_high_pc
;
1626 if (STREQ (dip
-> at_name
, "main")) /* FIXME: hardwired name */
1628 objfile
-> ei
.main_func_lowpc
= dip
-> at_low_pc
;
1629 objfile
-> ei
.main_func_highpc
= dip
-> at_high_pc
;
1631 new = push_context (0, dip
-> at_low_pc
);
1632 new -> name
= new_symbol (dip
, objfile
);
1633 list_in_scope
= &local_symbols
;
1634 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1635 new = pop_context ();
1636 /* Make a block for the local symbols within. */
1637 finish_block (new -> name
, &local_symbols
, new -> old_blocks
,
1638 new -> start_addr
, dip
-> at_high_pc
, objfile
);
1639 list_in_scope
= &file_symbols
;
1647 handle_producer -- process the AT_producer attribute
1651 Perform any operations that depend on finding a particular
1652 AT_producer attribute.
1657 handle_producer (producer
)
1661 /* If this compilation unit was compiled with g++ or gcc, then set the
1662 processing_gcc_compilation flag. */
1664 processing_gcc_compilation
=
1665 STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
))
1666 || STREQN (producer
, GCC_PRODUCER
, strlen (GCC_PRODUCER
));
1668 /* Select a demangling style if we can identify the producer and if
1669 the current style is auto. We leave the current style alone if it
1670 is not auto. We also leave the demangling style alone if we find a
1671 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1673 #if 1 /* Works, but is experimental. -fnf */
1674 if (AUTO_DEMANGLING
)
1676 if (STREQN (producer
, GPLUS_PRODUCER
, strlen (GPLUS_PRODUCER
)))
1678 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1680 else if (STREQN (producer
, LCC_PRODUCER
, strlen (LCC_PRODUCER
)))
1682 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING
);
1684 else if (STREQN (producer
, CFRONT_PRODUCER
, strlen (CFRONT_PRODUCER
)))
1686 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING
);
1697 read_file_scope -- process all dies within a file scope
1701 Process all dies within a given file scope. We are passed a
1702 pointer to the die information structure for the die which
1703 starts the file scope, and pointers into the raw die data which
1704 mark the range of dies within the file scope.
1706 When the partial symbol table is built, the file offset for the line
1707 number table for each compilation unit is saved in the partial symbol
1708 table entry for that compilation unit. As the symbols for each
1709 compilation unit are read, the line number table is read into memory
1710 and the variable lnbase is set to point to it. Thus all we have to
1711 do is use lnbase to access the line number table for the current
1716 read_file_scope (dip
, thisdie
, enddie
, objfile
)
1717 struct dieinfo
*dip
;
1720 struct objfile
*objfile
;
1722 struct cleanup
*back_to
;
1723 struct symtab
*symtab
;
1725 if (objfile
-> ei
.entry_point
>= dip
-> at_low_pc
&&
1726 objfile
-> ei
.entry_point
< dip
-> at_high_pc
)
1728 objfile
-> ei
.entry_file_lowpc
= dip
-> at_low_pc
;
1729 objfile
-> ei
.entry_file_highpc
= dip
-> at_high_pc
;
1731 set_cu_language (dip
);
1732 if (dip
-> at_producer
!= NULL
)
1734 handle_producer (dip
-> at_producer
);
1736 numutypes
= (enddie
- thisdie
) / 4;
1737 utypes
= (struct type
**) xmalloc (numutypes
* sizeof (struct type
*));
1738 back_to
= make_cleanup (free
, utypes
);
1739 memset (utypes
, 0, numutypes
* sizeof (struct type
*));
1740 start_symtab (dip
-> at_name
, dip
-> at_comp_dir
, dip
-> at_low_pc
);
1741 decode_line_numbers (lnbase
);
1742 process_dies (thisdie
+ dip
-> die_length
, enddie
, objfile
);
1743 symtab
= end_symtab (dip
-> at_high_pc
, 0, 0, objfile
);
1746 symtab
-> language
= cu_language
;
1748 do_cleanups (back_to
);
1757 process_dies -- process a range of DWARF Information Entries
1761 static void process_dies (char *thisdie, char *enddie,
1762 struct objfile *objfile)
1766 Process all DIE's in a specified range. May be (and almost
1767 certainly will be) called recursively.
1771 process_dies (thisdie
, enddie
, objfile
)
1774 struct objfile
*objfile
;
1779 while (thisdie
< enddie
)
1781 basicdieinfo (&di
, thisdie
, objfile
);
1782 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
1786 else if (di
.die_tag
== TAG_padding
)
1788 nextdie
= thisdie
+ di
.die_length
;
1792 completedieinfo (&di
, objfile
);
1793 if (di
.at_sibling
!= 0)
1795 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
1799 nextdie
= thisdie
+ di
.die_length
;
1803 case TAG_compile_unit
:
1804 read_file_scope (&di
, thisdie
, nextdie
, objfile
);
1806 case TAG_global_subroutine
:
1807 case TAG_subroutine
:
1808 if (di
.has_at_low_pc
)
1810 read_func_scope (&di
, thisdie
, nextdie
, objfile
);
1813 case TAG_lexical_block
:
1814 read_lexical_block_scope (&di
, thisdie
, nextdie
, objfile
);
1816 case TAG_class_type
:
1817 case TAG_structure_type
:
1818 case TAG_union_type
:
1819 read_structure_scope (&di
, thisdie
, nextdie
, objfile
);
1821 case TAG_enumeration_type
:
1822 read_enumeration (&di
, thisdie
, nextdie
, objfile
);
1824 case TAG_subroutine_type
:
1825 read_subroutine_type (&di
, thisdie
, nextdie
);
1827 case TAG_array_type
:
1828 dwarf_read_array_type (&di
);
1830 case TAG_pointer_type
:
1831 read_tag_pointer_type (&di
);
1834 new_symbol (&di
, objfile
);
1846 decode_line_numbers -- decode a line number table fragment
1850 static void decode_line_numbers (char *tblscan, char *tblend,
1851 long length, long base, long line, long pc)
1855 Translate the DWARF line number information to gdb form.
1857 The ".line" section contains one or more line number tables, one for
1858 each ".line" section from the objects that were linked.
1860 The AT_stmt_list attribute for each TAG_source_file entry in the
1861 ".debug" section contains the offset into the ".line" section for the
1862 start of the table for that file.
1864 The table itself has the following structure:
1866 <table length><base address><source statement entry>
1867 4 bytes 4 bytes 10 bytes
1869 The table length is the total size of the table, including the 4 bytes
1870 for the length information.
1872 The base address is the address of the first instruction generated
1873 for the source file.
1875 Each source statement entry has the following structure:
1877 <line number><statement position><address delta>
1878 4 bytes 2 bytes 4 bytes
1880 The line number is relative to the start of the file, starting with
1883 The statement position either -1 (0xFFFF) or the number of characters
1884 from the beginning of the line to the beginning of the statement.
1886 The address delta is the difference between the base address and
1887 the address of the first instruction for the statement.
1889 Note that we must copy the bytes from the packed table to our local
1890 variables before attempting to use them, to avoid alignment problems
1891 on some machines, particularly RISC processors.
1895 Does gdb expect the line numbers to be sorted? They are now by
1896 chance/luck, but are not required to be. (FIXME)
1898 The line with number 0 is unused, gdb apparently can discover the
1899 span of the last line some other way. How? (FIXME)
1903 decode_line_numbers (linetable
)
1908 unsigned long length
;
1913 if (linetable
!= NULL
)
1915 tblscan
= tblend
= linetable
;
1916 length
= target_to_host (tblscan
, SIZEOF_LINETBL_LENGTH
, GET_UNSIGNED
,
1918 tblscan
+= SIZEOF_LINETBL_LENGTH
;
1920 base
= target_to_host (tblscan
, TARGET_FT_POINTER_SIZE (objfile
),
1921 GET_UNSIGNED
, current_objfile
);
1922 tblscan
+= TARGET_FT_POINTER_SIZE (objfile
);
1924 while (tblscan
< tblend
)
1926 line
= target_to_host (tblscan
, SIZEOF_LINETBL_LINENO
, GET_UNSIGNED
,
1928 tblscan
+= SIZEOF_LINETBL_LINENO
+ SIZEOF_LINETBL_STMT
;
1929 pc
= target_to_host (tblscan
, SIZEOF_LINETBL_DELTA
, GET_UNSIGNED
,
1931 tblscan
+= SIZEOF_LINETBL_DELTA
;
1935 record_line (current_subfile
, line
, pc
);
1945 locval -- compute the value of a location attribute
1949 static int locval (char *loc)
1953 Given pointer to a string of bytes that define a location, compute
1954 the location and return the value.
1956 When computing values involving the current value of the frame pointer,
1957 the value zero is used, which results in a value relative to the frame
1958 pointer, rather than the absolute value. This is what GDB wants
1961 When the result is a register number, the global isreg flag is set,
1962 otherwise it is cleared. This is a kludge until we figure out a better
1963 way to handle the problem. Gdb's design does not mesh well with the
1964 DWARF notion of a location computing interpreter, which is a shame
1965 because the flexibility goes unused.
1969 Note that stack[0] is unused except as a default error return.
1970 Note that stack overflow is not yet handled.
1977 unsigned short nbytes
;
1978 unsigned short locsize
;
1979 auto long stack
[64];
1986 nbytes
= attribute_size (AT_location
);
1987 locsize
= target_to_host (loc
, nbytes
, GET_UNSIGNED
, current_objfile
);
1989 end
= loc
+ locsize
;
1994 loc_value_size
= TARGET_FT_LONG_SIZE (current_objfile
);
1997 loc_atom_code
= target_to_host (loc
, SIZEOF_LOC_ATOM_CODE
, GET_UNSIGNED
,
1999 loc
+= SIZEOF_LOC_ATOM_CODE
;
2000 switch (loc_atom_code
)
2007 /* push register (number) */
2008 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2009 GET_UNSIGNED
, current_objfile
);
2010 loc
+= loc_value_size
;
2014 /* push value of register (number) */
2015 /* Actually, we compute the value as if register has 0 */
2017 regno
= target_to_host (loc
, loc_value_size
, GET_UNSIGNED
,
2019 loc
+= loc_value_size
;
2022 stack
[++stacki
] = 0;
2026 stack
[++stacki
] = 0;
2027 SQUAWK (("BASEREG %d not handled!", regno
));
2031 /* push address (relocated address) */
2032 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2033 GET_UNSIGNED
, current_objfile
);
2034 loc
+= loc_value_size
;
2037 /* push constant (number) FIXME: signed or unsigned! */
2038 stack
[++stacki
] = target_to_host (loc
, loc_value_size
,
2039 GET_SIGNED
, current_objfile
);
2040 loc
+= loc_value_size
;
2043 /* pop, deref and push 2 bytes (as a long) */
2044 SQUAWK (("OP_DEREF2 address 0x%x not handled", stack
[stacki
]));
2046 case OP_DEREF4
: /* pop, deref and push 4 bytes (as a long) */
2047 SQUAWK (("OP_DEREF4 address 0x%x not handled", stack
[stacki
]));
2049 case OP_ADD
: /* pop top 2 items, add, push result */
2050 stack
[stacki
- 1] += stack
[stacki
];
2055 return (stack
[stacki
]);
2062 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2066 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2070 When expanding a partial symbol table entry to a full symbol table
2071 entry, this is the function that gets called to read in the symbols
2072 for the compilation unit.
2074 Returns a pointer to the newly constructed symtab (which is now
2075 the new first one on the objfile's symtab list).
2078 static struct symtab
*
2079 read_ofile_symtab (pst
)
2080 struct partial_symtab
*pst
;
2082 struct cleanup
*back_to
;
2083 unsigned long lnsize
;
2086 char lnsizedata
[SIZEOF_LINETBL_LENGTH
];
2088 abfd
= pst
-> objfile
-> obfd
;
2089 current_objfile
= pst
-> objfile
;
2091 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2092 unit, seek to the location in the file, and read in all the DIE's. */
2095 dbbase
= xmalloc (DBLENGTH(pst
));
2096 dbroff
= DBROFF(pst
);
2097 foffset
= DBFOFF(pst
) + dbroff
;
2098 base_section_offsets
= pst
->section_offsets
;
2099 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
2100 if (bfd_seek (abfd
, foffset
, 0) ||
2101 (bfd_read (dbbase
, DBLENGTH(pst
), 1, abfd
) != DBLENGTH(pst
)))
2104 error ("can't read DWARF data");
2106 back_to
= make_cleanup (free
, dbbase
);
2108 /* If there is a line number table associated with this compilation unit
2109 then read the size of this fragment in bytes, from the fragment itself.
2110 Allocate a buffer for the fragment and read it in for future
2116 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2117 (bfd_read ((PTR
) lnsizedata
, sizeof (lnsizedata
), 1, abfd
) !=
2118 sizeof (lnsizedata
)))
2120 error ("can't read DWARF line number table size");
2122 lnsize
= target_to_host (lnsizedata
, SIZEOF_LINETBL_LENGTH
,
2123 GET_UNSIGNED
, pst
-> objfile
);
2124 lnbase
= xmalloc (lnsize
);
2125 if (bfd_seek (abfd
, LNFOFF (pst
), 0) ||
2126 (bfd_read (lnbase
, lnsize
, 1, abfd
) != lnsize
))
2129 error ("can't read DWARF line numbers");
2131 make_cleanup (free
, lnbase
);
2134 process_dies (dbbase
, dbbase
+ DBLENGTH(pst
), pst
-> objfile
);
2135 do_cleanups (back_to
);
2136 current_objfile
= NULL
;
2137 return (pst
-> objfile
-> symtabs
);
2144 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2148 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2152 Called once for each partial symbol table entry that needs to be
2153 expanded into a full symbol table entry.
2158 psymtab_to_symtab_1 (pst
)
2159 struct partial_symtab
*pst
;
2162 struct cleanup
*old_chain
;
2168 warning ("psymtab for %s already read in. Shouldn't happen.",
2173 /* Read in all partial symtabs on which this one is dependent */
2174 for (i
= 0; i
< pst
-> number_of_dependencies
; i
++)
2176 if (!pst
-> dependencies
[i
] -> readin
)
2178 /* Inform about additional files that need to be read in. */
2181 fputs_filtered (" ", stdout
);
2183 fputs_filtered ("and ", stdout
);
2185 printf_filtered ("%s...",
2186 pst
-> dependencies
[i
] -> filename
);
2188 fflush (stdout
); /* Flush output */
2190 psymtab_to_symtab_1 (pst
-> dependencies
[i
]);
2193 if (DBLENGTH (pst
)) /* Otherwise it's a dummy */
2196 old_chain
= make_cleanup (really_free_pendings
, 0);
2197 pst
-> symtab
= read_ofile_symtab (pst
);
2200 printf_filtered ("%d DIE's, sorting...", diecount
);
2204 sort_symtab_syms (pst
-> symtab
);
2205 do_cleanups (old_chain
);
2216 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2220 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2224 This is the DWARF support entry point for building a full symbol
2225 table entry from a partial symbol table entry. We are passed a
2226 pointer to the partial symbol table entry that needs to be expanded.
2231 dwarf_psymtab_to_symtab (pst
)
2232 struct partial_symtab
*pst
;
2239 warning ("psymtab for %s already read in. Shouldn't happen.",
2244 if (DBLENGTH (pst
) || pst
-> number_of_dependencies
)
2246 /* Print the message now, before starting serious work, to avoid
2247 disconcerting pauses. */
2250 printf_filtered ("Reading in symbols for %s...",
2255 psymtab_to_symtab_1 (pst
);
2257 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2258 we need to do an equivalent or is this something peculiar to
2260 Match with global symbols. This only needs to be done once,
2261 after all of the symtabs and dependencies have been read in.
2263 scan_file_globals (pst
-> objfile
);
2266 /* Finish up the verbose info message. */
2269 printf_filtered ("done.\n");
2281 init_psymbol_list -- initialize storage for partial symbols
2285 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2289 Initializes storage for all of the partial symbols that will be
2290 created by dwarf_build_psymtabs and subsidiaries.
2294 init_psymbol_list (objfile
, total_symbols
)
2295 struct objfile
*objfile
;
2298 /* Free any previously allocated psymbol lists. */
2300 if (objfile
-> global_psymbols
.list
)
2302 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2304 if (objfile
-> static_psymbols
.list
)
2306 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2309 /* Current best guess is that there are approximately a twentieth
2310 of the total symbols (in a debugging file) are global or static
2313 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2314 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2315 objfile
-> global_psymbols
.next
=
2316 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
2317 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
2318 * sizeof (struct partial_symbol
));
2319 objfile
-> static_psymbols
.next
=
2320 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
2321 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
2322 * sizeof (struct partial_symbol
));
2329 add_enum_psymbol -- add enumeration members to partial symbol table
2333 Given pointer to a DIE that is known to be for an enumeration,
2334 extract the symbolic names of the enumeration members and add
2335 partial symbols for them.
2339 add_enum_psymbol (dip
, objfile
)
2340 struct dieinfo
*dip
;
2341 struct objfile
*objfile
;
2345 unsigned short blocksz
;
2348 if ((scan
= dip
-> at_element_list
) != NULL
)
2350 if (dip
-> short_element_list
)
2352 nbytes
= attribute_size (AT_short_element_list
);
2356 nbytes
= attribute_size (AT_element_list
);
2358 blocksz
= target_to_host (scan
, nbytes
, GET_UNSIGNED
, objfile
);
2360 listend
= scan
+ blocksz
;
2361 while (scan
< listend
)
2363 scan
+= TARGET_FT_LONG_SIZE (objfile
);
2364 ADD_PSYMBOL_TO_LIST (scan
, strlen (scan
), VAR_NAMESPACE
, LOC_CONST
,
2365 objfile
-> static_psymbols
, 0);
2366 scan
+= strlen (scan
) + 1;
2375 add_partial_symbol -- add symbol to partial symbol table
2379 Given a DIE, if it is one of the types that we want to
2380 add to a partial symbol table, finish filling in the die info
2381 and then add a partial symbol table entry for it.
2385 The caller must ensure that the DIE has a valid name attribute.
2389 add_partial_symbol (dip
, objfile
)
2390 struct dieinfo
*dip
;
2391 struct objfile
*objfile
;
2393 switch (dip
-> die_tag
)
2395 case TAG_global_subroutine
:
2396 record_minimal_symbol (dip
-> at_name
, dip
-> at_low_pc
, mst_text
,
2398 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2399 VAR_NAMESPACE
, LOC_BLOCK
,
2400 objfile
-> global_psymbols
,
2403 case TAG_global_variable
:
2404 record_minimal_symbol (dip
-> at_name
, locval (dip
-> at_location
),
2406 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2407 VAR_NAMESPACE
, LOC_STATIC
,
2408 objfile
-> global_psymbols
,
2411 case TAG_subroutine
:
2412 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2413 VAR_NAMESPACE
, LOC_BLOCK
,
2414 objfile
-> static_psymbols
,
2417 case TAG_local_variable
:
2418 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2419 VAR_NAMESPACE
, LOC_STATIC
,
2420 objfile
-> static_psymbols
,
2424 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2425 VAR_NAMESPACE
, LOC_TYPEDEF
,
2426 objfile
-> static_psymbols
,
2429 case TAG_class_type
:
2430 case TAG_structure_type
:
2431 case TAG_union_type
:
2432 case TAG_enumeration_type
:
2433 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2434 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2435 objfile
-> static_psymbols
,
2437 if (cu_language
== language_cplus
)
2439 /* For C++, these implicitly act as typedefs as well. */
2440 ADD_PSYMBOL_TO_LIST (dip
-> at_name
, strlen (dip
-> at_name
),
2441 VAR_NAMESPACE
, LOC_TYPEDEF
,
2442 objfile
-> static_psymbols
,
2453 scan_partial_symbols -- scan DIE's within a single compilation unit
2457 Process the DIE's within a single compilation unit, looking for
2458 interesting DIE's that contribute to the partial symbol table entry
2459 for this compilation unit.
2463 There are some DIE's that may appear both at file scope and within
2464 the scope of a function. We are only interested in the ones at file
2465 scope, and the only way to tell them apart is to keep track of the
2466 scope. For example, consider the test case:
2471 for which the relevant DWARF segment has the structure:
2474 0x23 global subrtn sibling 0x9b
2476 fund_type FT_integer
2481 0x23 local var sibling 0x97
2483 fund_type FT_integer
2484 location OP_BASEREG 0xe
2491 0x1d local var sibling 0xb8
2493 fund_type FT_integer
2494 location OP_ADDR 0x800025dc
2499 We want to include the symbol 'i' in the partial symbol table, but
2500 not the symbol 'j'. In essence, we want to skip all the dies within
2501 the scope of a TAG_global_subroutine DIE.
2503 Don't attempt to add anonymous structures or unions since they have
2504 no name. Anonymous enumerations however are processed, because we
2505 want to extract their member names (the check for a tag name is
2508 Also, for variables and subroutines, check that this is the place
2509 where the actual definition occurs, rather than just a reference
2514 scan_partial_symbols (thisdie
, enddie
, objfile
)
2517 struct objfile
*objfile
;
2523 while (thisdie
< enddie
)
2525 basicdieinfo (&di
, thisdie
, objfile
);
2526 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2532 nextdie
= thisdie
+ di
.die_length
;
2533 /* To avoid getting complete die information for every die, we
2534 only do it (below) for the cases we are interested in. */
2537 case TAG_global_subroutine
:
2538 case TAG_subroutine
:
2539 completedieinfo (&di
, objfile
);
2540 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2542 add_partial_symbol (&di
, objfile
);
2543 /* If there is a sibling attribute, adjust the nextdie
2544 pointer to skip the entire scope of the subroutine.
2545 Apply some sanity checking to make sure we don't
2546 overrun or underrun the range of remaining DIE's */
2547 if (di
.at_sibling
!= 0)
2549 temp
= dbbase
+ di
.at_sibling
- dbroff
;
2550 if ((temp
< thisdie
) || (temp
>= enddie
))
2552 dwarfwarn ("reference to DIE (0x%x) outside compilation unit", di
.at_sibling
);
2561 case TAG_global_variable
:
2562 case TAG_local_variable
:
2563 completedieinfo (&di
, objfile
);
2564 if (di
.at_name
&& (di
.has_at_low_pc
|| di
.at_location
))
2566 add_partial_symbol (&di
, objfile
);
2570 case TAG_class_type
:
2571 case TAG_structure_type
:
2572 case TAG_union_type
:
2573 completedieinfo (&di
, objfile
);
2576 add_partial_symbol (&di
, objfile
);
2579 case TAG_enumeration_type
:
2580 completedieinfo (&di
, objfile
);
2583 add_partial_symbol (&di
, objfile
);
2585 add_enum_psymbol (&di
, objfile
);
2597 scan_compilation_units -- build a psymtab entry for each compilation
2601 This is the top level dwarf parsing routine for building partial
2604 It scans from the beginning of the DWARF table looking for the first
2605 TAG_compile_unit DIE, and then follows the sibling chain to locate
2606 each additional TAG_compile_unit DIE.
2608 For each TAG_compile_unit DIE it creates a partial symtab structure,
2609 calls a subordinate routine to collect all the compilation unit's
2610 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2611 new partial symtab structure into the partial symbol table. It also
2612 records the appropriate information in the partial symbol table entry
2613 to allow the chunk of DIE's and line number table for this compilation
2614 unit to be located and re-read later, to generate a complete symbol
2615 table entry for the compilation unit.
2617 Thus it effectively partitions up a chunk of DIE's for multiple
2618 compilation units into smaller DIE chunks and line number tables,
2619 and associates them with a partial symbol table entry.
2623 If any compilation unit has no line number table associated with
2624 it for some reason (a missing at_stmt_list attribute, rather than
2625 just one with a value of zero, which is valid) then we ensure that
2626 the recorded file offset is zero so that the routine which later
2627 reads line number table fragments knows that there is no fragment
2637 scan_compilation_units (filename
, thisdie
, enddie
, dbfoff
, lnoffset
, objfile
)
2641 unsigned int dbfoff
;
2642 unsigned int lnoffset
;
2643 struct objfile
*objfile
;
2647 struct partial_symtab
*pst
;
2652 while (thisdie
< enddie
)
2654 basicdieinfo (&di
, thisdie
, objfile
);
2655 if (di
.die_length
< SIZEOF_DIE_LENGTH
)
2659 else if (di
.die_tag
!= TAG_compile_unit
)
2661 nextdie
= thisdie
+ di
.die_length
;
2665 completedieinfo (&di
, objfile
);
2666 set_cu_language (&di
);
2667 if (di
.at_sibling
!= 0)
2669 nextdie
= dbbase
+ di
.at_sibling
- dbroff
;
2673 nextdie
= thisdie
+ di
.die_length
;
2675 curoff
= thisdie
- dbbase
;
2676 culength
= nextdie
- thisdie
;
2677 curlnoffset
= di
.has_at_stmt_list
? lnoffset
+ di
.at_stmt_list
: 0;
2679 /* First allocate a new partial symbol table structure */
2681 pst
= start_psymtab_common (objfile
, base_section_offsets
,
2682 di
.at_name
, di
.at_low_pc
,
2683 objfile
-> global_psymbols
.next
,
2684 objfile
-> static_psymbols
.next
);
2686 pst
-> texthigh
= di
.at_high_pc
;
2687 pst
-> read_symtab_private
= (char *)
2688 obstack_alloc (&objfile
-> psymbol_obstack
,
2689 sizeof (struct dwfinfo
));
2690 DBFOFF (pst
) = dbfoff
;
2691 DBROFF (pst
) = curoff
;
2692 DBLENGTH (pst
) = culength
;
2693 LNFOFF (pst
) = curlnoffset
;
2694 pst
-> read_symtab
= dwarf_psymtab_to_symtab
;
2696 /* Now look for partial symbols */
2698 scan_partial_symbols (thisdie
+ di
.die_length
, nextdie
, objfile
);
2700 pst
-> n_global_syms
= objfile
-> global_psymbols
.next
-
2701 (objfile
-> global_psymbols
.list
+ pst
-> globals_offset
);
2702 pst
-> n_static_syms
= objfile
-> static_psymbols
.next
-
2703 (objfile
-> static_psymbols
.list
+ pst
-> statics_offset
);
2704 sort_pst_symbols (pst
);
2705 /* If there is already a psymtab or symtab for a file of this name,
2706 remove it. (If there is a symtab, more drastic things also
2707 happen.) This happens in VxWorks. */
2708 free_named_symtabs (pst
-> filename
);
2718 new_symbol -- make a symbol table entry for a new symbol
2722 static struct symbol *new_symbol (struct dieinfo *dip,
2723 struct objfile *objfile)
2727 Given a pointer to a DWARF information entry, figure out if we need
2728 to make a symbol table entry for it, and if so, create a new entry
2729 and return a pointer to it.
2732 static struct symbol
*
2733 new_symbol (dip
, objfile
)
2734 struct dieinfo
*dip
;
2735 struct objfile
*objfile
;
2737 struct symbol
*sym
= NULL
;
2739 if (dip
-> at_name
!= NULL
)
2741 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
,
2742 sizeof (struct symbol
));
2743 memset (sym
, 0, sizeof (struct symbol
));
2744 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2745 &objfile
->symbol_obstack
);
2746 /* default assumptions */
2747 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2748 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2749 SYMBOL_TYPE (sym
) = decode_die_type (dip
);
2750 switch (dip
-> die_tag
)
2753 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2754 SYMBOL_CLASS (sym
) = LOC_LABEL
;
2756 case TAG_global_subroutine
:
2757 case TAG_subroutine
:
2758 SYMBOL_VALUE (sym
) = dip
-> at_low_pc
;
2759 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
2760 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2761 if (dip
-> die_tag
== TAG_global_subroutine
)
2763 add_symbol_to_list (sym
, &global_symbols
);
2767 add_symbol_to_list (sym
, list_in_scope
);
2770 case TAG_global_variable
:
2771 if (dip
-> at_location
!= NULL
)
2773 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2774 add_symbol_to_list (sym
, &global_symbols
);
2775 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2776 SYMBOL_VALUE (sym
) += baseaddr
;
2779 case TAG_local_variable
:
2780 if (dip
-> at_location
!= NULL
)
2782 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2783 add_symbol_to_list (sym
, list_in_scope
);
2786 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
2790 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2794 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2795 SYMBOL_VALUE (sym
) += baseaddr
;
2799 case TAG_formal_parameter
:
2800 if (dip
-> at_location
!= NULL
)
2802 SYMBOL_VALUE (sym
) = locval (dip
-> at_location
);
2804 add_symbol_to_list (sym
, list_in_scope
);
2807 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
2811 SYMBOL_CLASS (sym
) = LOC_ARG
;
2814 case TAG_unspecified_parameters
:
2815 /* From varargs functions; gdb doesn't seem to have any interest in
2816 this information, so just ignore it for now. (FIXME?) */
2818 case TAG_class_type
:
2819 case TAG_structure_type
:
2820 case TAG_union_type
:
2821 case TAG_enumeration_type
:
2822 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2823 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2824 add_symbol_to_list (sym
, list_in_scope
);
2827 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2828 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2829 add_symbol_to_list (sym
, list_in_scope
);
2832 /* Not a tag we recognize. Hopefully we aren't processing trash
2833 data, but since we must specifically ignore things we don't
2834 recognize, there is nothing else we should do at this point. */
2845 synthesize_typedef -- make a symbol table entry for a "fake" typedef
2849 static void synthesize_typedef (struct dieinfo *dip,
2850 struct objfile *objfile,
2855 Given a pointer to a DWARF information entry, synthesize a typedef
2856 for the name in the DIE, using the specified type.
2858 This is used for C++ class, structs, unions, and enumerations to
2859 set up the tag name as a type.
2864 synthesize_typedef (dip
, objfile
, type
)
2865 struct dieinfo
*dip
;
2866 struct objfile
*objfile
;
2869 struct symbol
*sym
= NULL
;
2871 if (dip
-> at_name
!= NULL
)
2873 sym
= (struct symbol
*)
2874 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2875 memset (sym
, 0, sizeof (struct symbol
));
2876 SYMBOL_NAME (sym
) = create_name (dip
-> at_name
,
2877 &objfile
->symbol_obstack
);
2878 SYMBOL_TYPE (sym
) = type
;
2879 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2880 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2881 add_symbol_to_list (sym
, list_in_scope
);
2889 decode_mod_fund_type -- decode a modified fundamental type
2893 static struct type *decode_mod_fund_type (char *typedata)
2897 Decode a block of data containing a modified fundamental
2898 type specification. TYPEDATA is a pointer to the block,
2899 which starts with a length containing the size of the rest
2900 of the block. At the end of the block is a fundmental type
2901 code value that gives the fundamental type. Everything
2902 in between are type modifiers.
2904 We simply compute the number of modifiers and call the general
2905 function decode_modified_type to do the actual work.
2908 static struct type
*
2909 decode_mod_fund_type (typedata
)
2912 struct type
*typep
= NULL
;
2913 unsigned short modcount
;
2916 /* Get the total size of the block, exclusive of the size itself */
2918 nbytes
= attribute_size (AT_mod_fund_type
);
2919 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2922 /* Deduct the size of the fundamental type bytes at the end of the block. */
2924 modcount
-= attribute_size (AT_fund_type
);
2926 /* Now do the actual decoding */
2928 typep
= decode_modified_type (typedata
, modcount
, AT_mod_fund_type
);
2936 decode_mod_u_d_type -- decode a modified user defined type
2940 static struct type *decode_mod_u_d_type (char *typedata)
2944 Decode a block of data containing a modified user defined
2945 type specification. TYPEDATA is a pointer to the block,
2946 which consists of a two byte length, containing the size
2947 of the rest of the block. At the end of the block is a
2948 four byte value that gives a reference to a user defined type.
2949 Everything in between are type modifiers.
2951 We simply compute the number of modifiers and call the general
2952 function decode_modified_type to do the actual work.
2955 static struct type
*
2956 decode_mod_u_d_type (typedata
)
2959 struct type
*typep
= NULL
;
2960 unsigned short modcount
;
2963 /* Get the total size of the block, exclusive of the size itself */
2965 nbytes
= attribute_size (AT_mod_u_d_type
);
2966 modcount
= target_to_host (typedata
, nbytes
, GET_UNSIGNED
, current_objfile
);
2969 /* Deduct the size of the reference type bytes at the end of the block. */
2971 modcount
-= attribute_size (AT_user_def_type
);
2973 /* Now do the actual decoding */
2975 typep
= decode_modified_type (typedata
, modcount
, AT_mod_u_d_type
);
2983 decode_modified_type -- decode modified user or fundamental type
2987 static struct type *decode_modified_type (char *modifiers,
2988 unsigned short modcount, int mtype)
2992 Decode a modified type, either a modified fundamental type or
2993 a modified user defined type. MODIFIERS is a pointer to the
2994 block of bytes that define MODCOUNT modifiers. Immediately
2995 following the last modifier is a short containing the fundamental
2996 type or a long containing the reference to the user defined
2997 type. Which one is determined by MTYPE, which is either
2998 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
2999 type we are generating.
3001 We call ourself recursively to generate each modified type,`
3002 until MODCOUNT reaches zero, at which point we have consumed
3003 all the modifiers and generate either the fundamental type or
3004 user defined type. When the recursion unwinds, each modifier
3005 is applied in turn to generate the full modified type.
3009 If we find a modifier that we don't recognize, and it is not one
3010 of those reserved for application specific use, then we issue a
3011 warning and simply ignore the modifier.
3015 We currently ignore MOD_const and MOD_volatile. (FIXME)
3019 static struct type
*
3020 decode_modified_type (modifiers
, modcount
, mtype
)
3022 unsigned int modcount
;
3025 struct type
*typep
= NULL
;
3026 unsigned short fundtype
;
3035 case AT_mod_fund_type
:
3036 nbytes
= attribute_size (AT_fund_type
);
3037 fundtype
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3039 typep
= decode_fund_type (fundtype
);
3041 case AT_mod_u_d_type
:
3042 nbytes
= attribute_size (AT_user_def_type
);
3043 die_ref
= target_to_host (modifiers
, nbytes
, GET_UNSIGNED
,
3045 if ((typep
= lookup_utype (die_ref
)) == NULL
)
3047 typep
= alloc_utype (die_ref
, NULL
);
3051 SQUAWK (("botched modified type decoding (mtype 0x%x)", mtype
));
3052 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3058 modifier
= *modifiers
++;
3059 typep
= decode_modified_type (modifiers
, --modcount
, mtype
);
3062 case MOD_pointer_to
:
3063 typep
= lookup_pointer_type (typep
);
3065 case MOD_reference_to
:
3066 typep
= lookup_reference_type (typep
);
3069 SQUAWK (("type modifier 'const' ignored")); /* FIXME */
3072 SQUAWK (("type modifier 'volatile' ignored")); /* FIXME */
3075 if (!(MOD_lo_user
<= (unsigned char) modifier
3076 && (unsigned char) modifier
<= MOD_hi_user
))
3078 SQUAWK (("unknown type modifier %u",
3079 (unsigned char) modifier
));
3091 decode_fund_type -- translate basic DWARF type to gdb base type
3095 Given an integer that is one of the fundamental DWARF types,
3096 translate it to one of the basic internal gdb types and return
3097 a pointer to the appropriate gdb type (a "struct type *").
3101 If we encounter a fundamental type that we are unprepared to
3102 deal with, and it is not in the range of those types defined
3103 as application specific types, then we issue a warning and
3104 treat the type as an "int".
3107 static struct type
*
3108 decode_fund_type (fundtype
)
3109 unsigned int fundtype
;
3111 struct type
*typep
= NULL
;
3117 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3120 case FT_boolean
: /* Was FT_set in AT&T version */
3121 typep
= lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
3124 case FT_pointer
: /* (void *) */
3125 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3126 typep
= lookup_pointer_type (typep
);
3130 typep
= lookup_fundamental_type (current_objfile
, FT_CHAR
);
3133 case FT_signed_char
:
3134 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
3137 case FT_unsigned_char
:
3138 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
3142 typep
= lookup_fundamental_type (current_objfile
, FT_SHORT
);
3145 case FT_signed_short
:
3146 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_SHORT
);
3149 case FT_unsigned_short
:
3150 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
3154 typep
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
3157 case FT_signed_integer
:
3158 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_INTEGER
);
3161 case FT_unsigned_integer
:
3162 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
3166 typep
= lookup_fundamental_type (current_objfile
, FT_LONG
);
3169 case FT_signed_long
:
3170 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG
);
3173 case FT_unsigned_long
:
3174 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
3178 typep
= lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
3181 case FT_signed_long_long
:
3182 typep
= lookup_fundamental_type (current_objfile
, FT_SIGNED_LONG_LONG
);
3185 case FT_unsigned_long_long
:
3186 typep
= lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
3190 typep
= lookup_fundamental_type (current_objfile
, FT_FLOAT
);
3193 case FT_dbl_prec_float
:
3194 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
3197 case FT_ext_prec_float
:
3198 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
3202 typep
= lookup_fundamental_type (current_objfile
, FT_COMPLEX
);
3205 case FT_dbl_prec_complex
:
3206 typep
= lookup_fundamental_type (current_objfile
, FT_DBL_PREC_COMPLEX
);
3209 case FT_ext_prec_complex
:
3210 typep
= lookup_fundamental_type (current_objfile
, FT_EXT_PREC_COMPLEX
);
3215 if ((typep
== NULL
) && !(FT_lo_user
<= fundtype
&& fundtype
<= FT_hi_user
))
3217 SQUAWK (("unexpected fundamental type 0x%x", fundtype
));
3218 typep
= lookup_fundamental_type (current_objfile
, FT_VOID
);
3228 create_name -- allocate a fresh copy of a string on an obstack
3232 Given a pointer to a string and a pointer to an obstack, allocates
3233 a fresh copy of the string on the specified obstack.
3238 create_name (name
, obstackp
)
3240 struct obstack
*obstackp
;
3245 length
= strlen (name
) + 1;
3246 newname
= (char *) obstack_alloc (obstackp
, length
);
3247 strcpy (newname
, name
);
3255 basicdieinfo -- extract the minimal die info from raw die data
3259 void basicdieinfo (char *diep, struct dieinfo *dip,
3260 struct objfile *objfile)
3264 Given a pointer to raw DIE data, and a pointer to an instance of a
3265 die info structure, this function extracts the basic information
3266 from the DIE data required to continue processing this DIE, along
3267 with some bookkeeping information about the DIE.
3269 The information we absolutely must have includes the DIE tag,
3270 and the DIE length. If we need the sibling reference, then we
3271 will have to call completedieinfo() to process all the remaining
3274 Note that since there is no guarantee that the data is properly
3275 aligned in memory for the type of access required (indirection
3276 through anything other than a char pointer), and there is no
3277 guarantee that it is in the same byte order as the gdb host,
3278 we call a function which deals with both alignment and byte
3279 swapping issues. Possibly inefficient, but quite portable.
3281 We also take care of some other basic things at this point, such
3282 as ensuring that the instance of the die info structure starts
3283 out completely zero'd and that curdie is initialized for use
3284 in error reporting if we have a problem with the current die.
3288 All DIE's must have at least a valid length, thus the minimum
3289 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3290 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3291 are forced to be TAG_padding DIES.
3293 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3294 that if a padding DIE is used for alignment and the amount needed is
3295 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3296 enough to align to the next alignment boundry.
3300 basicdieinfo (dip
, diep
, objfile
)
3301 struct dieinfo
*dip
;
3303 struct objfile
*objfile
;
3306 memset (dip
, 0, sizeof (struct dieinfo
));
3308 dip
-> die_ref
= dbroff
+ (diep
- dbbase
);
3309 dip
-> die_length
= target_to_host (diep
, SIZEOF_DIE_LENGTH
, GET_UNSIGNED
,
3311 if (dip
-> die_length
< SIZEOF_DIE_LENGTH
)
3313 dwarfwarn ("malformed DIE, bad length (%d bytes)", dip
-> die_length
);
3315 else if (dip
-> die_length
< (SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
))
3317 dip
-> die_tag
= TAG_padding
;
3321 diep
+= SIZEOF_DIE_LENGTH
;
3322 dip
-> die_tag
= target_to_host (diep
, SIZEOF_DIE_TAG
, GET_UNSIGNED
,
3331 completedieinfo -- finish reading the information for a given DIE
3335 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3339 Given a pointer to an already partially initialized die info structure,
3340 scan the raw DIE data and finish filling in the die info structure
3341 from the various attributes found.
3343 Note that since there is no guarantee that the data is properly
3344 aligned in memory for the type of access required (indirection
3345 through anything other than a char pointer), and there is no
3346 guarantee that it is in the same byte order as the gdb host,
3347 we call a function which deals with both alignment and byte
3348 swapping issues. Possibly inefficient, but quite portable.
3352 Each time we are called, we increment the diecount variable, which
3353 keeps an approximate count of the number of dies processed for
3354 each compilation unit. This information is presented to the user
3355 if the info_verbose flag is set.
3360 completedieinfo (dip
, objfile
)
3361 struct dieinfo
*dip
;
3362 struct objfile
*objfile
;
3364 char *diep
; /* Current pointer into raw DIE data */
3365 char *end
; /* Terminate DIE scan here */
3366 unsigned short attr
; /* Current attribute being scanned */
3367 unsigned short form
; /* Form of the attribute */
3368 int nbytes
; /* Size of next field to read */
3372 end
= diep
+ dip
-> die_length
;
3373 diep
+= SIZEOF_DIE_LENGTH
+ SIZEOF_DIE_TAG
;
3376 attr
= target_to_host (diep
, SIZEOF_ATTRIBUTE
, GET_UNSIGNED
, objfile
);
3377 diep
+= SIZEOF_ATTRIBUTE
;
3378 if ((nbytes
= attribute_size (attr
)) == -1)
3380 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3387 dip
-> at_fund_type
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3391 dip
-> at_ordering
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3395 dip
-> at_bit_offset
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3399 dip
-> at_sibling
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3403 dip
-> at_stmt_list
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3405 dip
-> has_at_stmt_list
= 1;
3408 dip
-> at_low_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3410 dip
-> at_low_pc
+= baseaddr
;
3411 dip
-> has_at_low_pc
= 1;
3414 dip
-> at_high_pc
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3416 dip
-> at_high_pc
+= baseaddr
;
3419 dip
-> at_language
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3422 case AT_user_def_type
:
3423 dip
-> at_user_def_type
= target_to_host (diep
, nbytes
,
3424 GET_UNSIGNED
, objfile
);
3427 dip
-> at_byte_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3429 dip
-> has_at_byte_size
= 1;
3432 dip
-> at_bit_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3436 dip
-> at_member
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3440 dip
-> at_discr
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3444 dip
-> at_location
= diep
;
3446 case AT_mod_fund_type
:
3447 dip
-> at_mod_fund_type
= diep
;
3449 case AT_subscr_data
:
3450 dip
-> at_subscr_data
= diep
;
3452 case AT_mod_u_d_type
:
3453 dip
-> at_mod_u_d_type
= diep
;
3455 case AT_element_list
:
3456 dip
-> at_element_list
= diep
;
3457 dip
-> short_element_list
= 0;
3459 case AT_short_element_list
:
3460 dip
-> at_element_list
= diep
;
3461 dip
-> short_element_list
= 1;
3463 case AT_discr_value
:
3464 dip
-> at_discr_value
= diep
;
3466 case AT_string_length
:
3467 dip
-> at_string_length
= diep
;
3470 dip
-> at_name
= diep
;
3473 /* For now, ignore any "hostname:" portion, since gdb doesn't
3474 know how to deal with it. (FIXME). */
3475 dip
-> at_comp_dir
= strrchr (diep
, ':');
3476 if (dip
-> at_comp_dir
!= NULL
)
3478 dip
-> at_comp_dir
++;
3482 dip
-> at_comp_dir
= diep
;
3486 dip
-> at_producer
= diep
;
3488 case AT_start_scope
:
3489 dip
-> at_start_scope
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3492 case AT_stride_size
:
3493 dip
-> at_stride_size
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3497 dip
-> at_src_info
= target_to_host (diep
, nbytes
, GET_UNSIGNED
,
3501 dip
-> at_prototyped
= diep
;
3504 /* Found an attribute that we are unprepared to handle. However
3505 it is specifically one of the design goals of DWARF that
3506 consumers should ignore unknown attributes. As long as the
3507 form is one that we recognize (so we know how to skip it),
3508 we can just ignore the unknown attribute. */
3511 form
= FORM_FROM_ATTR (attr
);
3525 diep
+= TARGET_FT_POINTER_SIZE (objfile
);
3528 diep
+= 2 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3531 diep
+= 4 + target_to_host (diep
, nbytes
, GET_UNSIGNED
, objfile
);
3534 diep
+= strlen (diep
) + 1;
3537 SQUAWK (("unknown attribute form (0x%x)", form
));
3538 SQUAWK (("unknown attribute length, skipped remaining attributes"));;
3549 target_to_host -- swap in target data to host
3553 target_to_host (char *from, int nbytes, int signextend,
3554 struct objfile *objfile)
3558 Given pointer to data in target format in FROM, a byte count for
3559 the size of the data in NBYTES, a flag indicating whether or not
3560 the data is signed in SIGNEXTEND, and a pointer to the current
3561 objfile in OBJFILE, convert the data to host format and return
3562 the converted value.
3566 FIXME: If we read data that is known to be signed, and expect to
3567 use it as signed data, then we need to explicitly sign extend the
3568 result until the bfd library is able to do this for us.
3572 static unsigned long
3573 target_to_host (from
, nbytes
, signextend
, objfile
)
3576 int signextend
; /* FIXME: Unused */
3577 struct objfile
*objfile
;
3579 unsigned long rtnval
;
3584 rtnval
= bfd_get_64 (objfile
-> obfd
, (bfd_byte
*) from
);
3587 rtnval
= bfd_get_32 (objfile
-> obfd
, (bfd_byte
*) from
);
3590 rtnval
= bfd_get_16 (objfile
-> obfd
, (bfd_byte
*) from
);
3593 rtnval
= bfd_get_8 (objfile
-> obfd
, (bfd_byte
*) from
);
3596 dwarfwarn ("no bfd support for %d byte data object", nbytes
);
3607 attribute_size -- compute size of data for a DWARF attribute
3611 static int attribute_size (unsigned int attr)
3615 Given a DWARF attribute in ATTR, compute the size of the first
3616 piece of data associated with this attribute and return that
3619 Returns -1 for unrecognized attributes.
3624 attribute_size (attr
)
3627 int nbytes
; /* Size of next data for this attribute */
3628 unsigned short form
; /* Form of the attribute */
3630 form
= FORM_FROM_ATTR (attr
);
3633 case FORM_STRING
: /* A variable length field is next */
3636 case FORM_DATA2
: /* Next 2 byte field is the data itself */
3637 case FORM_BLOCK2
: /* Next 2 byte field is a block length */
3640 case FORM_DATA4
: /* Next 4 byte field is the data itself */
3641 case FORM_BLOCK4
: /* Next 4 byte field is a block length */
3642 case FORM_REF
: /* Next 4 byte field is a DIE offset */
3645 case FORM_DATA8
: /* Next 8 byte field is the data itself */
3648 case FORM_ADDR
: /* Next field size is target sizeof(void *) */
3649 nbytes
= TARGET_FT_POINTER_SIZE (objfile
);
3652 SQUAWK (("unknown attribute form (0x%x)", form
));