2003-06-01 Andrew Cagney <cagney@redhat.com>
[platform/upstream/binutils.git] / gdb / dwarfread.c
1 /* DWARF debugging format support for GDB.
2
3    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4    2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5
6    Written by Fred Fish at Cygnus Support.  Portions based on dbxread.c,
7    mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
8
9    This file is part of GDB.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 2 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
24
25 /*
26    If you are looking for DWARF-2 support, you are in the wrong file.
27    Go look in dwarf2read.c.  This file is for the original DWARF.
28
29    DWARF (also known as DWARF-1) is headed for obsoletion.
30
31    In gcc 3.2.1, these targets prefer dwarf-1:
32
33      i[34567]86-sequent-ptx4*   # TD-R2
34      i[34567]86-sequent-sysv4*  # TD-R2
35      i[34567]86-dg-dgux*        # obsolete in gcc 3.2.1, to be removed in 3.3
36      m88k-dg-dgux*              # TD-R2
37      mips-sni-sysv4             # TD-R2
38      sparc-hal-solaris2*        # TD-R2
39
40     Configurations marked with "# TD-R2" are on Zach Weinberg's list
41     of "Target Deprecation, Round 2".  This is a candidate list of
42     targets to be deprecated in gcc 3.3 and removed in gcc 3.4.
43
44       http://gcc.gnu.org/ml/gcc/2002-12/msg00702.html
45
46     gcc 2.95.3 had many configurations which prefer dwarf-1.
47     We may have to support dwarf-1 as long as we support gcc 2.95.3.
48     This could use more analysis.
49
50     DG/UX (Data General Unix) used dwarf-1 for its native format.
51     DG/UX uses gcc for its system C compiler, but they have their
52     own linker and their own debuggers.
53
54     Takis Psarogiannakopoulos has a complete gnu toolchain for DG/UX
55     with gcc 2.95.3, gdb 5.1, and debug formats of dwarf-2 and stabs.
56     For more info, see PR gdb/979 and PR gdb/1013; also:
57
58       http://sources.redhat.com/ml/gdb/2003-02/msg00074.html
59
60     There may be non-gcc compilers that still emit dwarf-1.
61
62     -- chastain 2003-02-04
63 */
64
65 /*
66
67    FIXME: Do we need to generate dependencies in partial symtabs?
68    (Perhaps we don't need to).
69
70    FIXME: Resolve minor differences between what information we put in the
71    partial symbol table and what dbxread puts in.  For example, we don't yet
72    put enum constants there.  And dbxread seems to invent a lot of typedefs
73    we never see.  Use the new printpsym command to see the partial symbol table
74    contents.
75
76    FIXME: Figure out a better way to tell gdb about the name of the function
77    contain the user's entry point (I.E. main())
78
79    FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
80    other things to work on, if you get bored. :-)
81
82  */
83
84 #include "defs.h"
85 #include "symtab.h"
86 #include "gdbtypes.h"
87 #include "symfile.h"
88 #include "objfiles.h"
89 #include "elf/dwarf.h"
90 #include "buildsym.h"
91 #include "demangle.h"
92 #include "expression.h"         /* Needed for enum exp_opcode in language.h, sigh... */
93 #include "language.h"
94 #include "complaints.h"
95
96 #include <fcntl.h>
97 #include "gdb_string.h"
98
99 /* Some macros to provide DIE info for complaints. */
100
101 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
102 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
103
104 /* Complaints that can be issued during DWARF debug info reading. */
105
106 static void
107 bad_die_ref_complaint (int arg1, const char *arg2, int arg3)
108 {
109   complaint (&symfile_complaints,
110              "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit",
111              arg1, arg2, arg3);
112 }
113
114 static void
115 unknown_attribute_form_complaint (int arg1, const char *arg2, int arg3)
116 {
117   complaint (&symfile_complaints,
118              "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", arg1, arg2,
119              arg3);
120 }
121
122 static void
123 dup_user_type_definition_complaint (int arg1, const char *arg2)
124 {
125   complaint (&symfile_complaints,
126              "DIE @ 0x%x \"%s\", internal error: duplicate user type definition",
127              arg1, arg2);
128 }
129
130 static void
131 bad_array_element_type_complaint (int arg1, const char *arg2, int arg3)
132 {
133   complaint (&symfile_complaints,
134              "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", arg1,
135              arg2, arg3);
136 }
137
138 typedef unsigned int DIE_REF;   /* Reference to a DIE */
139
140 #ifndef GCC_PRODUCER
141 #define GCC_PRODUCER "GNU C "
142 #endif
143
144 #ifndef GPLUS_PRODUCER
145 #define GPLUS_PRODUCER "GNU C++ "
146 #endif
147
148 #ifndef LCC_PRODUCER
149 #define LCC_PRODUCER "NCR C/C++"
150 #endif
151
152 /* Flags to target_to_host() that tell whether or not the data object is
153    expected to be signed.  Used, for example, when fetching a signed
154    integer in the target environment which is used as a signed integer
155    in the host environment, and the two environments have different sized
156    ints.  In this case, *somebody* has to sign extend the smaller sized
157    int. */
158
159 #define GET_UNSIGNED    0       /* No sign extension required */
160 #define GET_SIGNED      1       /* Sign extension required */
161
162 /* Defines for things which are specified in the document "DWARF Debugging
163    Information Format" published by UNIX International, Programming Languages
164    SIG.  These defines are based on revision 1.0.0, Jan 20, 1992. */
165
166 #define SIZEOF_DIE_LENGTH       4
167 #define SIZEOF_DIE_TAG          2
168 #define SIZEOF_ATTRIBUTE        2
169 #define SIZEOF_FORMAT_SPECIFIER 1
170 #define SIZEOF_FMT_FT           2
171 #define SIZEOF_LINETBL_LENGTH   4
172 #define SIZEOF_LINETBL_LINENO   4
173 #define SIZEOF_LINETBL_STMT     2
174 #define SIZEOF_LINETBL_DELTA    4
175 #define SIZEOF_LOC_ATOM_CODE    1
176
177 #define FORM_FROM_ATTR(attr)    ((attr) & 0xF)  /* Implicitly specified */
178
179 /* Macros that return the sizes of various types of data in the target
180    environment.
181
182    FIXME:  Currently these are just compile time constants (as they are in
183    other parts of gdb as well).  They need to be able to get the right size
184    either from the bfd or possibly from the DWARF info.  It would be nice if
185    the DWARF producer inserted DIES that describe the fundamental types in
186    the target environment into the DWARF info, similar to the way dbx stabs
187    producers produce information about their fundamental types. */
188
189 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
190 #define TARGET_FT_LONG_SIZE(objfile)    (TARGET_LONG_BIT / TARGET_CHAR_BIT)
191
192 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
193    FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
194    However, the Issue 2 DWARF specification from AT&T defines it as
195    a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
196    For backwards compatibility with the AT&T compiler produced executables
197    we define AT_short_element_list for this variant. */
198
199 #define AT_short_element_list    (0x00f0|FORM_BLOCK2)
200
201 /* The DWARF debugging information consists of two major pieces,
202    one is a block of DWARF Information Entries (DIE's) and the other
203    is a line number table.  The "struct dieinfo" structure contains
204    the information for a single DIE, the one currently being processed.
205
206    In order to make it easier to randomly access the attribute fields
207    of the current DIE, which are specifically unordered within the DIE,
208    each DIE is scanned and an instance of the "struct dieinfo"
209    structure is initialized.
210
211    Initialization is done in two levels.  The first, done by basicdieinfo(),
212    just initializes those fields that are vital to deciding whether or not
213    to use this DIE, how to skip past it, etc.  The second, done by the
214    function completedieinfo(), fills in the rest of the information.
215
216    Attributes which have block forms are not interpreted at the time
217    the DIE is scanned, instead we just save pointers to the start
218    of their value fields.
219
220    Some fields have a flag <name>_p that is set when the value of the
221    field is valid (I.E. we found a matching attribute in the DIE).  Since
222    we may want to test for the presence of some attributes in the DIE,
223    such as AT_low_pc, without restricting the values of the field,
224    we need someway to note that we found such an attribute.
225
226  */
227
228 typedef char BLOCK;
229
230 struct dieinfo
231   {
232     char *die;                  /* Pointer to the raw DIE data */
233     unsigned long die_length;   /* Length of the raw DIE data */
234     DIE_REF die_ref;            /* Offset of this DIE */
235     unsigned short die_tag;     /* Tag for this DIE */
236     unsigned long at_padding;
237     unsigned long at_sibling;
238     BLOCK *at_location;
239     char *at_name;
240     unsigned short at_fund_type;
241     BLOCK *at_mod_fund_type;
242     unsigned long at_user_def_type;
243     BLOCK *at_mod_u_d_type;
244     unsigned short at_ordering;
245     BLOCK *at_subscr_data;
246     unsigned long at_byte_size;
247     unsigned short at_bit_offset;
248     unsigned long at_bit_size;
249     BLOCK *at_element_list;
250     unsigned long at_stmt_list;
251     CORE_ADDR at_low_pc;
252     CORE_ADDR at_high_pc;
253     unsigned long at_language;
254     unsigned long at_member;
255     unsigned long at_discr;
256     BLOCK *at_discr_value;
257     BLOCK *at_string_length;
258     char *at_comp_dir;
259     char *at_producer;
260     unsigned long at_start_scope;
261     unsigned long at_stride_size;
262     unsigned long at_src_info;
263     char *at_prototyped;
264     unsigned int has_at_low_pc:1;
265     unsigned int has_at_stmt_list:1;
266     unsigned int has_at_byte_size:1;
267     unsigned int short_element_list:1;
268
269     /* Kludge to identify register variables */
270
271     unsigned int isreg;
272
273     /* Kludge to identify optimized out variables */
274
275     unsigned int optimized_out;
276
277     /* Kludge to identify basereg references.
278        Nonzero if we have an offset relative to a basereg.  */
279
280     unsigned int offreg;
281
282     /* Kludge to identify which base register is it relative to.  */
283
284     unsigned int basereg;
285   };
286
287 static int diecount;            /* Approximate count of dies for compilation unit */
288 static struct dieinfo *curdie;  /* For warnings and such */
289
290 static char *dbbase;            /* Base pointer to dwarf info */
291 static int dbsize;              /* Size of dwarf info in bytes */
292 static int dbroff;              /* Relative offset from start of .debug section */
293 static char *lnbase;            /* Base pointer to line section */
294
295 /* This value is added to each symbol value.  FIXME:  Generalize to 
296    the section_offsets structure used by dbxread (once this is done,
297    pass the appropriate section number to end_symtab).  */
298 static CORE_ADDR baseaddr;      /* Add to each symbol value */
299
300 /* The section offsets used in the current psymtab or symtab.  FIXME,
301    only used to pass one value (baseaddr) at the moment.  */
302 static struct section_offsets *base_section_offsets;
303
304 /* We put a pointer to this structure in the read_symtab_private field
305    of the psymtab.  */
306
307 struct dwfinfo
308   {
309     /* Always the absolute file offset to the start of the ".debug"
310        section for the file containing the DIE's being accessed.  */
311     file_ptr dbfoff;
312     /* Relative offset from the start of the ".debug" section to the
313        first DIE to be accessed.  When building the partial symbol
314        table, this value will be zero since we are accessing the
315        entire ".debug" section.  When expanding a partial symbol
316        table entry, this value will be the offset to the first
317        DIE for the compilation unit containing the symbol that
318        triggers the expansion.  */
319     int dbroff;
320     /* The size of the chunk of DIE's being examined, in bytes.  */
321     int dblength;
322     /* The absolute file offset to the line table fragment.  Ignored
323        when building partial symbol tables, but used when expanding
324        them, and contains the absolute file offset to the fragment
325        of the ".line" section containing the line numbers for the
326        current compilation unit.  */
327     file_ptr lnfoff;
328   };
329
330 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
331 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
332 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
333 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
334
335 /* The generic symbol table building routines have separate lists for
336    file scope symbols and all all other scopes (local scopes).  So
337    we need to select the right one to pass to add_symbol_to_list().
338    We do it by keeping a pointer to the correct list in list_in_scope.
339
340    FIXME:  The original dwarf code just treated the file scope as the first
341    local scope, and all other local scopes as nested local scopes, and worked
342    fine.  Check to see if we really need to distinguish these in buildsym.c */
343
344 struct pending **list_in_scope = &file_symbols;
345
346 /* DIES which have user defined types or modified user defined types refer to
347    other DIES for the type information.  Thus we need to associate the offset
348    of a DIE for a user defined type with a pointer to the type information.
349
350    Originally this was done using a simple but expensive algorithm, with an
351    array of unsorted structures, each containing an offset/type-pointer pair.
352    This array was scanned linearly each time a lookup was done.  The result
353    was that gdb was spending over half it's startup time munging through this
354    array of pointers looking for a structure that had the right offset member.
355
356    The second attempt used the same array of structures, but the array was
357    sorted using qsort each time a new offset/type was recorded, and a binary
358    search was used to find the type pointer for a given DIE offset.  This was
359    even slower, due to the overhead of sorting the array each time a new
360    offset/type pair was entered.
361
362    The third attempt uses a fixed size array of type pointers, indexed by a
363    value derived from the DIE offset.  Since the minimum DIE size is 4 bytes,
364    we can divide any DIE offset by 4 to obtain a unique index into this fixed
365    size array.  Since each element is a 4 byte pointer, it takes exactly as
366    much memory to hold this array as to hold the DWARF info for a given
367    compilation unit.  But it gets freed as soon as we are done with it.
368    This has worked well in practice, as a reasonable tradeoff between memory
369    consumption and speed, without having to resort to much more complicated
370    algorithms. */
371
372 static struct type **utypes;    /* Pointer to array of user type pointers */
373 static int numutypes;           /* Max number of user type pointers */
374
375 /* Maintain an array of referenced fundamental types for the current
376    compilation unit being read.  For DWARF version 1, we have to construct
377    the fundamental types on the fly, since no information about the
378    fundamental types is supplied.  Each such fundamental type is created by
379    calling a language dependent routine to create the type, and then a
380    pointer to that type is then placed in the array at the index specified
381    by it's FT_<TYPENAME> value.  The array has a fixed size set by the
382    FT_NUM_MEMBERS compile time constant, which is the number of predefined
383    fundamental types gdb knows how to construct. */
384
385 static struct type *ftypes[FT_NUM_MEMBERS];     /* Fundamental types */
386
387 /* Record the language for the compilation unit which is currently being
388    processed.  We know it once we have seen the TAG_compile_unit DIE,
389    and we need it while processing the DIE's for that compilation unit.
390    It is eventually saved in the symtab structure, but we don't finalize
391    the symtab struct until we have processed all the DIE's for the
392    compilation unit.  We also need to get and save a pointer to the 
393    language struct for this language, so we can call the language
394    dependent routines for doing things such as creating fundamental
395    types. */
396
397 static enum language cu_language;
398 static const struct language_defn *cu_language_defn;
399
400 /* Forward declarations of static functions so we don't have to worry
401    about ordering within this file.  */
402
403 static void free_utypes (void *);
404
405 static int attribute_size (unsigned int);
406
407 static CORE_ADDR target_to_host (char *, int, int, struct objfile *);
408
409 static void add_enum_psymbol (struct dieinfo *, struct objfile *);
410
411 static void handle_producer (char *);
412
413 static void read_file_scope (struct dieinfo *, char *, char *,
414                              struct objfile *);
415
416 static void read_func_scope (struct dieinfo *, char *, char *,
417                              struct objfile *);
418
419 static void read_lexical_block_scope (struct dieinfo *, char *, char *,
420                                       struct objfile *);
421
422 static void scan_partial_symbols (char *, char *, struct objfile *);
423
424 static void scan_compilation_units (char *, char *, file_ptr, file_ptr,
425                                     struct objfile *);
426
427 static void add_partial_symbol (struct dieinfo *, struct objfile *);
428
429 static void basicdieinfo (struct dieinfo *, char *, struct objfile *);
430
431 static void completedieinfo (struct dieinfo *, struct objfile *);
432
433 static void dwarf_psymtab_to_symtab (struct partial_symtab *);
434
435 static void psymtab_to_symtab_1 (struct partial_symtab *);
436
437 static void read_ofile_symtab (struct partial_symtab *);
438
439 static void process_dies (char *, char *, struct objfile *);
440
441 static void read_structure_scope (struct dieinfo *, char *, char *,
442                                   struct objfile *);
443
444 static struct type *decode_array_element_type (char *);
445
446 static struct type *decode_subscript_data_item (char *, char *);
447
448 static void dwarf_read_array_type (struct dieinfo *);
449
450 static void read_tag_pointer_type (struct dieinfo *dip);
451
452 static void read_tag_string_type (struct dieinfo *dip);
453
454 static void read_subroutine_type (struct dieinfo *, char *, char *);
455
456 static void read_enumeration (struct dieinfo *, char *, char *,
457                               struct objfile *);
458
459 static struct type *struct_type (struct dieinfo *, char *, char *,
460                                  struct objfile *);
461
462 static struct type *enum_type (struct dieinfo *, struct objfile *);
463
464 static void decode_line_numbers (char *);
465
466 static struct type *decode_die_type (struct dieinfo *);
467
468 static struct type *decode_mod_fund_type (char *);
469
470 static struct type *decode_mod_u_d_type (char *);
471
472 static struct type *decode_modified_type (char *, unsigned int, int);
473
474 static struct type *decode_fund_type (unsigned int);
475
476 static char *create_name (char *, struct obstack *);
477
478 static struct type *lookup_utype (DIE_REF);
479
480 static struct type *alloc_utype (DIE_REF, struct type *);
481
482 static struct symbol *new_symbol (struct dieinfo *, struct objfile *);
483
484 static void synthesize_typedef (struct dieinfo *, struct objfile *,
485                                 struct type *);
486
487 static int locval (struct dieinfo *);
488
489 static void set_cu_language (struct dieinfo *);
490
491 static struct type *dwarf_fundamental_type (struct objfile *, int);
492
493
494 /*
495
496    LOCAL FUNCTION
497
498    dwarf_fundamental_type -- lookup or create a fundamental type
499
500    SYNOPSIS
501
502    struct type *
503    dwarf_fundamental_type (struct objfile *objfile, int typeid)
504
505    DESCRIPTION
506
507    DWARF version 1 doesn't supply any fundamental type information,
508    so gdb has to construct such types.  It has a fixed number of
509    fundamental types that it knows how to construct, which is the
510    union of all types that it knows how to construct for all languages
511    that it knows about.  These are enumerated in gdbtypes.h.
512
513    As an example, assume we find a DIE that references a DWARF
514    fundamental type of FT_integer.  We first look in the ftypes
515    array to see if we already have such a type, indexed by the
516    gdb internal value of FT_INTEGER.  If so, we simply return a
517    pointer to that type.  If not, then we ask an appropriate
518    language dependent routine to create a type FT_INTEGER, using
519    defaults reasonable for the current target machine, and install
520    that type in ftypes for future reference.
521
522    RETURNS
523
524    Pointer to a fundamental type.
525
526  */
527
528 static struct type *
529 dwarf_fundamental_type (struct objfile *objfile, int typeid)
530 {
531   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
532     {
533       error ("internal error - invalid fundamental type id %d", typeid);
534     }
535
536   /* Look for this particular type in the fundamental type vector.  If one is
537      not found, create and install one appropriate for the current language
538      and the current target machine. */
539
540   if (ftypes[typeid] == NULL)
541     {
542       ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
543     }
544
545   return (ftypes[typeid]);
546 }
547
548 /*
549
550    LOCAL FUNCTION
551
552    set_cu_language -- set local copy of language for compilation unit
553
554    SYNOPSIS
555
556    void
557    set_cu_language (struct dieinfo *dip)
558
559    DESCRIPTION
560
561    Decode the language attribute for a compilation unit DIE and
562    remember what the language was.  We use this at various times
563    when processing DIE's for a given compilation unit.
564
565    RETURNS
566
567    No return value.
568
569  */
570
571 static void
572 set_cu_language (struct dieinfo *dip)
573 {
574   switch (dip->at_language)
575     {
576     case LANG_C89:
577     case LANG_C:
578       cu_language = language_c;
579       break;
580     case LANG_C_PLUS_PLUS:
581       cu_language = language_cplus;
582       break;
583     case LANG_MODULA2:
584       cu_language = language_m2;
585       break;
586     case LANG_FORTRAN77:
587     case LANG_FORTRAN90:
588       cu_language = language_fortran;
589       break;
590     case LANG_ADA83:
591     case LANG_COBOL74:
592     case LANG_COBOL85:
593     case LANG_PASCAL83:
594       /* We don't know anything special about these yet. */
595       cu_language = language_unknown;
596       break;
597     default:
598       /* If no at_language, try to deduce one from the filename */
599       cu_language = deduce_language_from_filename (dip->at_name);
600       break;
601     }
602   cu_language_defn = language_def (cu_language);
603 }
604
605 /*
606
607    GLOBAL FUNCTION
608
609    dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
610
611    SYNOPSIS
612
613    void dwarf_build_psymtabs (struct objfile *objfile,
614    int mainline, file_ptr dbfoff, unsigned int dbfsize,
615    file_ptr lnoffset, unsigned int lnsize)
616
617    DESCRIPTION
618
619    This function is called upon to build partial symtabs from files
620    containing DIE's (Dwarf Information Entries) and DWARF line numbers.
621
622    It is passed a bfd* containing the DIES
623    and line number information, the corresponding filename for that
624    file, a base address for relocating the symbols, a flag indicating
625    whether or not this debugging information is from a "main symbol
626    table" rather than a shared library or dynamically linked file,
627    and file offset/size pairs for the DIE information and line number
628    information.
629
630    RETURNS
631
632    No return value.
633
634  */
635
636 void
637 dwarf_build_psymtabs (struct objfile *objfile, int mainline, file_ptr dbfoff,
638                       unsigned int dbfsize, file_ptr lnoffset,
639                       unsigned int lnsize)
640 {
641   bfd *abfd = objfile->obfd;
642   struct cleanup *back_to;
643
644   current_objfile = objfile;
645   dbsize = dbfsize;
646   dbbase = xmalloc (dbsize);
647   dbroff = 0;
648   if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) ||
649       (bfd_bread (dbbase, dbsize, abfd) != dbsize))
650     {
651       xfree (dbbase);
652       error ("can't read DWARF data from '%s'", bfd_get_filename (abfd));
653     }
654   back_to = make_cleanup (xfree, dbbase);
655
656   /* If we are reinitializing, or if we have never loaded syms yet, init.
657      Since we have no idea how many DIES we are looking at, we just guess
658      some arbitrary value. */
659
660   if (mainline
661       || (objfile->global_psymbols.size == 0
662           && objfile->static_psymbols.size == 0))
663     {
664       init_psymbol_list (objfile, 1024);
665     }
666
667   /* Save the relocation factor where everybody can see it.  */
668
669   base_section_offsets = objfile->section_offsets;
670   baseaddr = ANOFFSET (objfile->section_offsets, 0);
671
672   /* Follow the compilation unit sibling chain, building a partial symbol
673      table entry for each one.  Save enough information about each compilation
674      unit to locate the full DWARF information later. */
675
676   scan_compilation_units (dbbase, dbbase + dbsize, dbfoff, lnoffset, objfile);
677
678   do_cleanups (back_to);
679   current_objfile = NULL;
680 }
681
682 /*
683
684    LOCAL FUNCTION
685
686    read_lexical_block_scope -- process all dies in a lexical block
687
688    SYNOPSIS
689
690    static void read_lexical_block_scope (struct dieinfo *dip,
691    char *thisdie, char *enddie)
692
693    DESCRIPTION
694
695    Process all the DIES contained within a lexical block scope.
696    Start a new scope, process the dies, and then close the scope.
697
698  */
699
700 static void
701 read_lexical_block_scope (struct dieinfo *dip, char *thisdie, char *enddie,
702                           struct objfile *objfile)
703 {
704   struct context_stack *new;
705
706   push_context (0, dip->at_low_pc);
707   process_dies (thisdie + dip->die_length, enddie, objfile);
708   new = pop_context ();
709   if (local_symbols != NULL)
710     {
711       finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
712                     dip->at_high_pc, objfile);
713     }
714   local_symbols = new->locals;
715 }
716
717 /*
718
719    LOCAL FUNCTION
720
721    lookup_utype -- look up a user defined type from die reference
722
723    SYNOPSIS
724
725    static type *lookup_utype (DIE_REF die_ref)
726
727    DESCRIPTION
728
729    Given a DIE reference, lookup the user defined type associated with
730    that DIE, if it has been registered already.  If not registered, then
731    return NULL.  Alloc_utype() can be called to register an empty
732    type for this reference, which will be filled in later when the
733    actual referenced DIE is processed.
734  */
735
736 static struct type *
737 lookup_utype (DIE_REF die_ref)
738 {
739   struct type *type = NULL;
740   int utypeidx;
741
742   utypeidx = (die_ref - dbroff) / 4;
743   if ((utypeidx < 0) || (utypeidx >= numutypes))
744     {
745       bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
746     }
747   else
748     {
749       type = *(utypes + utypeidx);
750     }
751   return (type);
752 }
753
754
755 /*
756
757    LOCAL FUNCTION
758
759    alloc_utype  -- add a user defined type for die reference
760
761    SYNOPSIS
762
763    static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
764
765    DESCRIPTION
766
767    Given a die reference DIE_REF, and a possible pointer to a user
768    defined type UTYPEP, register that this reference has a user
769    defined type and either use the specified type in UTYPEP or
770    make a new empty type that will be filled in later.
771
772    We should only be called after calling lookup_utype() to verify that
773    there is not currently a type registered for DIE_REF.
774  */
775
776 static struct type *
777 alloc_utype (DIE_REF die_ref, struct type *utypep)
778 {
779   struct type **typep;
780   int utypeidx;
781
782   utypeidx = (die_ref - dbroff) / 4;
783   typep = utypes + utypeidx;
784   if ((utypeidx < 0) || (utypeidx >= numutypes))
785     {
786       utypep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
787       bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
788     }
789   else if (*typep != NULL)
790     {
791       utypep = *typep;
792       complaint (&symfile_complaints,
793                  "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation",
794                  DIE_ID, DIE_NAME);
795     }
796   else
797     {
798       if (utypep == NULL)
799         {
800           utypep = alloc_type (current_objfile);
801         }
802       *typep = utypep;
803     }
804   return (utypep);
805 }
806
807 /*
808
809    LOCAL FUNCTION
810
811    free_utypes -- free the utypes array and reset pointer & count
812
813    SYNOPSIS
814
815    static void free_utypes (void *dummy)
816
817    DESCRIPTION
818
819    Called via do_cleanups to free the utypes array, reset the pointer to NULL,
820    and set numutypes back to zero.  This ensures that the utypes does not get
821    referenced after being freed.
822  */
823
824 static void
825 free_utypes (void *dummy)
826 {
827   xfree (utypes);
828   utypes = NULL;
829   numutypes = 0;
830 }
831
832
833 /*
834
835    LOCAL FUNCTION
836
837    decode_die_type -- return a type for a specified die
838
839    SYNOPSIS
840
841    static struct type *decode_die_type (struct dieinfo *dip)
842
843    DESCRIPTION
844
845    Given a pointer to a die information structure DIP, decode the
846    type of the die and return a pointer to the decoded type.  All
847    dies without specific types default to type int.
848  */
849
850 static struct type *
851 decode_die_type (struct dieinfo *dip)
852 {
853   struct type *type = NULL;
854
855   if (dip->at_fund_type != 0)
856     {
857       type = decode_fund_type (dip->at_fund_type);
858     }
859   else if (dip->at_mod_fund_type != NULL)
860     {
861       type = decode_mod_fund_type (dip->at_mod_fund_type);
862     }
863   else if (dip->at_user_def_type)
864     {
865       type = lookup_utype (dip->at_user_def_type);
866       if (type == NULL)
867         {
868           type = alloc_utype (dip->at_user_def_type, NULL);
869         }
870     }
871   else if (dip->at_mod_u_d_type)
872     {
873       type = decode_mod_u_d_type (dip->at_mod_u_d_type);
874     }
875   else
876     {
877       type = dwarf_fundamental_type (current_objfile, FT_VOID);
878     }
879   return (type);
880 }
881
882 /*
883
884    LOCAL FUNCTION
885
886    struct_type -- compute and return the type for a struct or union
887
888    SYNOPSIS
889
890    static struct type *struct_type (struct dieinfo *dip, char *thisdie,
891    char *enddie, struct objfile *objfile)
892
893    DESCRIPTION
894
895    Given pointer to a die information structure for a die which
896    defines a union or structure (and MUST define one or the other),
897    and pointers to the raw die data that define the range of dies which
898    define the members, compute and return the user defined type for the
899    structure or union.
900  */
901
902 static struct type *
903 struct_type (struct dieinfo *dip, char *thisdie, char *enddie,
904              struct objfile *objfile)
905 {
906   struct type *type;
907   struct nextfield
908     {
909       struct nextfield *next;
910       struct field field;
911     };
912   struct nextfield *list = NULL;
913   struct nextfield *new;
914   int nfields = 0;
915   int n;
916   struct dieinfo mbr;
917   char *nextdie;
918   int anonymous_size;
919
920   type = lookup_utype (dip->die_ref);
921   if (type == NULL)
922     {
923       /* No forward references created an empty type, so install one now */
924       type = alloc_utype (dip->die_ref, NULL);
925     }
926   INIT_CPLUS_SPECIFIC (type);
927   switch (dip->die_tag)
928     {
929     case TAG_class_type:
930       TYPE_CODE (type) = TYPE_CODE_CLASS;
931       break;
932     case TAG_structure_type:
933       TYPE_CODE (type) = TYPE_CODE_STRUCT;
934       break;
935     case TAG_union_type:
936       TYPE_CODE (type) = TYPE_CODE_UNION;
937       break;
938     default:
939       /* Should never happen */
940       TYPE_CODE (type) = TYPE_CODE_UNDEF;
941       complaint (&symfile_complaints,
942                  "DIE @ 0x%x \"%s\", missing class, structure, or union tag",
943                  DIE_ID, DIE_NAME);
944       break;
945     }
946   /* Some compilers try to be helpful by inventing "fake" names for
947      anonymous enums, structures, and unions, like "~0fake" or ".0fake".
948      Thanks, but no thanks... */
949   if (dip->at_name != NULL
950       && *dip->at_name != '~'
951       && *dip->at_name != '.')
952     {
953       TYPE_TAG_NAME (type) = obconcat (&objfile->type_obstack,
954                                        "", "", dip->at_name);
955     }
956   /* Use whatever size is known.  Zero is a valid size.  We might however
957      wish to check has_at_byte_size to make sure that some byte size was
958      given explicitly, but DWARF doesn't specify that explicit sizes of
959      zero have to present, so complaining about missing sizes should 
960      probably not be the default. */
961   TYPE_LENGTH (type) = dip->at_byte_size;
962   thisdie += dip->die_length;
963   while (thisdie < enddie)
964     {
965       basicdieinfo (&mbr, thisdie, objfile);
966       completedieinfo (&mbr, objfile);
967       if (mbr.die_length <= SIZEOF_DIE_LENGTH)
968         {
969           break;
970         }
971       else if (mbr.at_sibling != 0)
972         {
973           nextdie = dbbase + mbr.at_sibling - dbroff;
974         }
975       else
976         {
977           nextdie = thisdie + mbr.die_length;
978         }
979       switch (mbr.die_tag)
980         {
981         case TAG_member:
982           /* Get space to record the next field's data.  */
983           new = (struct nextfield *) alloca (sizeof (struct nextfield));
984           new->next = list;
985           list = new;
986           /* Save the data.  */
987           list->field.name =
988             obsavestring (mbr.at_name, strlen (mbr.at_name),
989                           &objfile->type_obstack);
990           FIELD_TYPE (list->field) = decode_die_type (&mbr);
991           FIELD_BITPOS (list->field) = 8 * locval (&mbr);
992           FIELD_STATIC_KIND (list->field) = 0;
993           /* Handle bit fields. */
994           FIELD_BITSIZE (list->field) = mbr.at_bit_size;
995           if (BITS_BIG_ENDIAN)
996             {
997               /* For big endian bits, the at_bit_offset gives the
998                  additional bit offset from the MSB of the containing
999                  anonymous object to the MSB of the field.  We don't
1000                  have to do anything special since we don't need to
1001                  know the size of the anonymous object. */
1002               FIELD_BITPOS (list->field) += mbr.at_bit_offset;
1003             }
1004           else
1005             {
1006               /* For little endian bits, we need to have a non-zero
1007                  at_bit_size, so that we know we are in fact dealing
1008                  with a bitfield.  Compute the bit offset to the MSB
1009                  of the anonymous object, subtract off the number of
1010                  bits from the MSB of the field to the MSB of the
1011                  object, and then subtract off the number of bits of
1012                  the field itself.  The result is the bit offset of
1013                  the LSB of the field. */
1014               if (mbr.at_bit_size > 0)
1015                 {
1016                   if (mbr.has_at_byte_size)
1017                     {
1018                       /* The size of the anonymous object containing
1019                          the bit field is explicit, so use the
1020                          indicated size (in bytes). */
1021                       anonymous_size = mbr.at_byte_size;
1022                     }
1023                   else
1024                     {
1025                       /* The size of the anonymous object containing
1026                          the bit field matches the size of an object
1027                          of the bit field's type.  DWARF allows
1028                          at_byte_size to be left out in such cases, as
1029                          a debug information size optimization. */
1030                       anonymous_size = TYPE_LENGTH (list->field.type);
1031                     }
1032                   FIELD_BITPOS (list->field) +=
1033                     anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size;
1034                 }
1035             }
1036           nfields++;
1037           break;
1038         default:
1039           process_dies (thisdie, nextdie, objfile);
1040           break;
1041         }
1042       thisdie = nextdie;
1043     }
1044   /* Now create the vector of fields, and record how big it is.  We may
1045      not even have any fields, if this DIE was generated due to a reference
1046      to an anonymous structure or union.  In this case, TYPE_FLAG_STUB is
1047      set, which clues gdb in to the fact that it needs to search elsewhere
1048      for the full structure definition. */
1049   if (nfields == 0)
1050     {
1051       TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1052     }
1053   else
1054     {
1055       TYPE_NFIELDS (type) = nfields;
1056       TYPE_FIELDS (type) = (struct field *)
1057         TYPE_ALLOC (type, sizeof (struct field) * nfields);
1058       /* Copy the saved-up fields into the field vector.  */
1059       for (n = nfields; list; list = list->next)
1060         {
1061           TYPE_FIELD (type, --n) = list->field;
1062         }
1063     }
1064   return (type);
1065 }
1066
1067 /*
1068
1069    LOCAL FUNCTION
1070
1071    read_structure_scope -- process all dies within struct or union
1072
1073    SYNOPSIS
1074
1075    static void read_structure_scope (struct dieinfo *dip,
1076    char *thisdie, char *enddie, struct objfile *objfile)
1077
1078    DESCRIPTION
1079
1080    Called when we find the DIE that starts a structure or union
1081    scope (definition) to process all dies that define the members
1082    of the structure or union.  DIP is a pointer to the die info
1083    struct for the DIE that names the structure or union.
1084
1085    NOTES
1086
1087    Note that we need to call struct_type regardless of whether or not
1088    the DIE has an at_name attribute, since it might be an anonymous
1089    structure or union.  This gets the type entered into our set of
1090    user defined types.
1091
1092    However, if the structure is incomplete (an opaque struct/union)
1093    then suppress creating a symbol table entry for it since gdb only
1094    wants to find the one with the complete definition.  Note that if
1095    it is complete, we just call new_symbol, which does it's own
1096    checking about whether the struct/union is anonymous or not (and
1097    suppresses creating a symbol table entry itself).
1098
1099  */
1100
1101 static void
1102 read_structure_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1103                       struct objfile *objfile)
1104 {
1105   struct type *type;
1106   struct symbol *sym;
1107
1108   type = struct_type (dip, thisdie, enddie, objfile);
1109   if (!TYPE_STUB (type))
1110     {
1111       sym = new_symbol (dip, objfile);
1112       if (sym != NULL)
1113         {
1114           SYMBOL_TYPE (sym) = type;
1115           if (cu_language == language_cplus)
1116             {
1117               synthesize_typedef (dip, objfile, type);
1118             }
1119         }
1120     }
1121 }
1122
1123 /*
1124
1125    LOCAL FUNCTION
1126
1127    decode_array_element_type -- decode type of the array elements
1128
1129    SYNOPSIS
1130
1131    static struct type *decode_array_element_type (char *scan, char *end)
1132
1133    DESCRIPTION
1134
1135    As the last step in decoding the array subscript information for an
1136    array DIE, we need to decode the type of the array elements.  We are
1137    passed a pointer to this last part of the subscript information and
1138    must return the appropriate type.  If the type attribute is not
1139    recognized, just warn about the problem and return type int.
1140  */
1141
1142 static struct type *
1143 decode_array_element_type (char *scan)
1144 {
1145   struct type *typep;
1146   DIE_REF die_ref;
1147   unsigned short attribute;
1148   unsigned short fundtype;
1149   int nbytes;
1150
1151   attribute = target_to_host (scan, SIZEOF_ATTRIBUTE, GET_UNSIGNED,
1152                               current_objfile);
1153   scan += SIZEOF_ATTRIBUTE;
1154   nbytes = attribute_size (attribute);
1155   if (nbytes == -1)
1156     {
1157       bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
1158       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1159     }
1160   else
1161     {
1162       switch (attribute)
1163         {
1164         case AT_fund_type:
1165           fundtype = target_to_host (scan, nbytes, GET_UNSIGNED,
1166                                      current_objfile);
1167           typep = decode_fund_type (fundtype);
1168           break;
1169         case AT_mod_fund_type:
1170           typep = decode_mod_fund_type (scan);
1171           break;
1172         case AT_user_def_type:
1173           die_ref = target_to_host (scan, nbytes, GET_UNSIGNED,
1174                                     current_objfile);
1175           typep = lookup_utype (die_ref);
1176           if (typep == NULL)
1177             {
1178               typep = alloc_utype (die_ref, NULL);
1179             }
1180           break;
1181         case AT_mod_u_d_type:
1182           typep = decode_mod_u_d_type (scan);
1183           break;
1184         default:
1185           bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
1186           typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1187           break;
1188         }
1189     }
1190   return (typep);
1191 }
1192
1193 /*
1194
1195    LOCAL FUNCTION
1196
1197    decode_subscript_data_item -- decode array subscript item
1198
1199    SYNOPSIS
1200
1201    static struct type *
1202    decode_subscript_data_item (char *scan, char *end)
1203
1204    DESCRIPTION
1205
1206    The array subscripts and the data type of the elements of an
1207    array are described by a list of data items, stored as a block
1208    of contiguous bytes.  There is a data item describing each array
1209    dimension, and a final data item describing the element type.
1210    The data items are ordered the same as their appearance in the
1211    source (I.E. leftmost dimension first, next to leftmost second,
1212    etc).
1213
1214    The data items describing each array dimension consist of four
1215    parts: (1) a format specifier, (2) type type of the subscript
1216    index, (3) a description of the low bound of the array dimension,
1217    and (4) a description of the high bound of the array dimension.
1218
1219    The last data item is the description of the type of each of
1220    the array elements.
1221
1222    We are passed a pointer to the start of the block of bytes
1223    containing the remaining data items, and a pointer to the first
1224    byte past the data.  This function recursively decodes the
1225    remaining data items and returns a type.
1226
1227    If we somehow fail to decode some data, we complain about it
1228    and return a type "array of int".
1229
1230    BUGS
1231    FIXME:  This code only implements the forms currently used
1232    by the AT&T and GNU C compilers.
1233
1234    The end pointer is supplied for error checking, maybe we should
1235    use it for that...
1236  */
1237
1238 static struct type *
1239 decode_subscript_data_item (char *scan, char *end)
1240 {
1241   struct type *typep = NULL;    /* Array type we are building */
1242   struct type *nexttype;        /* Type of each element (may be array) */
1243   struct type *indextype;       /* Type of this index */
1244   struct type *rangetype;
1245   unsigned int format;
1246   unsigned short fundtype;
1247   unsigned long lowbound;
1248   unsigned long highbound;
1249   int nbytes;
1250
1251   format = target_to_host (scan, SIZEOF_FORMAT_SPECIFIER, GET_UNSIGNED,
1252                            current_objfile);
1253   scan += SIZEOF_FORMAT_SPECIFIER;
1254   switch (format)
1255     {
1256     case FMT_ET:
1257       typep = decode_array_element_type (scan);
1258       break;
1259     case FMT_FT_C_C:
1260       fundtype = target_to_host (scan, SIZEOF_FMT_FT, GET_UNSIGNED,
1261                                  current_objfile);
1262       indextype = decode_fund_type (fundtype);
1263       scan += SIZEOF_FMT_FT;
1264       nbytes = TARGET_FT_LONG_SIZE (current_objfile);
1265       lowbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1266       scan += nbytes;
1267       highbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1268       scan += nbytes;
1269       nexttype = decode_subscript_data_item (scan, end);
1270       if (nexttype == NULL)
1271         {
1272           /* Munged subscript data or other problem, fake it. */
1273           complaint (&symfile_complaints,
1274                      "DIE @ 0x%x \"%s\", can't decode subscript data items",
1275                      DIE_ID, DIE_NAME);
1276           nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1277         }
1278       rangetype = create_range_type ((struct type *) NULL, indextype,
1279                                      lowbound, highbound);
1280       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1281       break;
1282     case FMT_FT_C_X:
1283     case FMT_FT_X_C:
1284     case FMT_FT_X_X:
1285     case FMT_UT_C_C:
1286     case FMT_UT_C_X:
1287     case FMT_UT_X_C:
1288     case FMT_UT_X_X:
1289       complaint (&symfile_complaints,
1290                  "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet",
1291                  DIE_ID, DIE_NAME, format);
1292       nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1293       rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1294       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1295       break;
1296     default:
1297       complaint (&symfile_complaints,
1298                  "DIE @ 0x%x \"%s\", unknown array subscript format %x", DIE_ID,
1299                  DIE_NAME, format);
1300       nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1301       rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1302       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1303       break;
1304     }
1305   return (typep);
1306 }
1307
1308 /*
1309
1310    LOCAL FUNCTION
1311
1312    dwarf_read_array_type -- read TAG_array_type DIE
1313
1314    SYNOPSIS
1315
1316    static void dwarf_read_array_type (struct dieinfo *dip)
1317
1318    DESCRIPTION
1319
1320    Extract all information from a TAG_array_type DIE and add to
1321    the user defined type vector.
1322  */
1323
1324 static void
1325 dwarf_read_array_type (struct dieinfo *dip)
1326 {
1327   struct type *type;
1328   struct type *utype;
1329   char *sub;
1330   char *subend;
1331   unsigned short blocksz;
1332   int nbytes;
1333
1334   if (dip->at_ordering != ORD_row_major)
1335     {
1336       /* FIXME:  Can gdb even handle column major arrays? */
1337       complaint (&symfile_complaints,
1338                  "DIE @ 0x%x \"%s\", array not row major; not handled correctly",
1339                  DIE_ID, DIE_NAME);
1340     }
1341   sub = dip->at_subscr_data;
1342   if (sub != NULL)
1343     {
1344       nbytes = attribute_size (AT_subscr_data);
1345       blocksz = target_to_host (sub, nbytes, GET_UNSIGNED, current_objfile);
1346       subend = sub + nbytes + blocksz;
1347       sub += nbytes;
1348       type = decode_subscript_data_item (sub, subend);
1349       utype = lookup_utype (dip->die_ref);
1350       if (utype == NULL)
1351         {
1352           /* Install user defined type that has not been referenced yet. */
1353           alloc_utype (dip->die_ref, type);
1354         }
1355       else if (TYPE_CODE (utype) == TYPE_CODE_UNDEF)
1356         {
1357           /* Ick!  A forward ref has already generated a blank type in our
1358              slot, and this type probably already has things pointing to it
1359              (which is what caused it to be created in the first place).
1360              If it's just a place holder we can plop our fully defined type
1361              on top of it.  We can't recover the space allocated for our
1362              new type since it might be on an obstack, but we could reuse
1363              it if we kept a list of them, but it might not be worth it
1364              (FIXME). */
1365           *utype = *type;
1366         }
1367       else
1368         {
1369           /* Double ick!  Not only is a type already in our slot, but
1370              someone has decorated it.  Complain and leave it alone. */
1371           dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1372         }
1373     }
1374 }
1375
1376 /*
1377
1378    LOCAL FUNCTION
1379
1380    read_tag_pointer_type -- read TAG_pointer_type DIE
1381
1382    SYNOPSIS
1383
1384    static void read_tag_pointer_type (struct dieinfo *dip)
1385
1386    DESCRIPTION
1387
1388    Extract all information from a TAG_pointer_type DIE and add to
1389    the user defined type vector.
1390  */
1391
1392 static void
1393 read_tag_pointer_type (struct dieinfo *dip)
1394 {
1395   struct type *type;
1396   struct type *utype;
1397
1398   type = decode_die_type (dip);
1399   utype = lookup_utype (dip->die_ref);
1400   if (utype == NULL)
1401     {
1402       utype = lookup_pointer_type (type);
1403       alloc_utype (dip->die_ref, utype);
1404     }
1405   else
1406     {
1407       TYPE_TARGET_TYPE (utype) = type;
1408       TYPE_POINTER_TYPE (type) = utype;
1409
1410       /* We assume the machine has only one representation for pointers!  */
1411       /* FIXME:  Possably a poor assumption  */
1412       TYPE_LENGTH (utype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
1413       TYPE_CODE (utype) = TYPE_CODE_PTR;
1414     }
1415 }
1416
1417 /*
1418
1419    LOCAL FUNCTION
1420
1421    read_tag_string_type -- read TAG_string_type DIE
1422
1423    SYNOPSIS
1424
1425    static void read_tag_string_type (struct dieinfo *dip)
1426
1427    DESCRIPTION
1428
1429    Extract all information from a TAG_string_type DIE and add to
1430    the user defined type vector.  It isn't really a user defined
1431    type, but it behaves like one, with other DIE's using an
1432    AT_user_def_type attribute to reference it.
1433  */
1434
1435 static void
1436 read_tag_string_type (struct dieinfo *dip)
1437 {
1438   struct type *utype;
1439   struct type *indextype;
1440   struct type *rangetype;
1441   unsigned long lowbound = 0;
1442   unsigned long highbound;
1443
1444   if (dip->has_at_byte_size)
1445     {
1446       /* A fixed bounds string */
1447       highbound = dip->at_byte_size - 1;
1448     }
1449   else
1450     {
1451       /* A varying length string.  Stub for now.  (FIXME) */
1452       highbound = 1;
1453     }
1454   indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1455   rangetype = create_range_type ((struct type *) NULL, indextype, lowbound,
1456                                  highbound);
1457
1458   utype = lookup_utype (dip->die_ref);
1459   if (utype == NULL)
1460     {
1461       /* No type defined, go ahead and create a blank one to use. */
1462       utype = alloc_utype (dip->die_ref, (struct type *) NULL);
1463     }
1464   else
1465     {
1466       /* Already a type in our slot due to a forward reference. Make sure it
1467          is a blank one.  If not, complain and leave it alone. */
1468       if (TYPE_CODE (utype) != TYPE_CODE_UNDEF)
1469         {
1470           dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1471           return;
1472         }
1473     }
1474
1475   /* Create the string type using the blank type we either found or created. */
1476   utype = create_string_type (utype, rangetype);
1477 }
1478
1479 /*
1480
1481    LOCAL FUNCTION
1482
1483    read_subroutine_type -- process TAG_subroutine_type dies
1484
1485    SYNOPSIS
1486
1487    static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1488    char *enddie)
1489
1490    DESCRIPTION
1491
1492    Handle DIES due to C code like:
1493
1494    struct foo {
1495    int (*funcp)(int a, long l);  (Generates TAG_subroutine_type DIE)
1496    int b;
1497    };
1498
1499    NOTES
1500
1501    The parameter DIES are currently ignored.  See if gdb has a way to
1502    include this info in it's type system, and decode them if so.  Is
1503    this what the type structure's "arg_types" field is for?  (FIXME)
1504  */
1505
1506 static void
1507 read_subroutine_type (struct dieinfo *dip, char *thisdie, char *enddie)
1508 {
1509   struct type *type;            /* Type that this function returns */
1510   struct type *ftype;           /* Function that returns above type */
1511
1512   /* Decode the type that this subroutine returns */
1513
1514   type = decode_die_type (dip);
1515
1516   /* Check to see if we already have a partially constructed user
1517      defined type for this DIE, from a forward reference. */
1518
1519   ftype = lookup_utype (dip->die_ref);
1520   if (ftype == NULL)
1521     {
1522       /* This is the first reference to one of these types.  Make
1523          a new one and place it in the user defined types. */
1524       ftype = lookup_function_type (type);
1525       alloc_utype (dip->die_ref, ftype);
1526     }
1527   else if (TYPE_CODE (ftype) == TYPE_CODE_UNDEF)
1528     {
1529       /* We have an existing partially constructed type, so bash it
1530          into the correct type. */
1531       TYPE_TARGET_TYPE (ftype) = type;
1532       TYPE_LENGTH (ftype) = 1;
1533       TYPE_CODE (ftype) = TYPE_CODE_FUNC;
1534     }
1535   else
1536     {
1537       dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1538     }
1539 }
1540
1541 /*
1542
1543    LOCAL FUNCTION
1544
1545    read_enumeration -- process dies which define an enumeration
1546
1547    SYNOPSIS
1548
1549    static void read_enumeration (struct dieinfo *dip, char *thisdie,
1550    char *enddie, struct objfile *objfile)
1551
1552    DESCRIPTION
1553
1554    Given a pointer to a die which begins an enumeration, process all
1555    the dies that define the members of the enumeration.
1556
1557    NOTES
1558
1559    Note that we need to call enum_type regardless of whether or not we
1560    have a symbol, since we might have an enum without a tag name (thus
1561    no symbol for the tagname).
1562  */
1563
1564 static void
1565 read_enumeration (struct dieinfo *dip, char *thisdie, char *enddie,
1566                   struct objfile *objfile)
1567 {
1568   struct type *type;
1569   struct symbol *sym;
1570
1571   type = enum_type (dip, objfile);
1572   sym = new_symbol (dip, objfile);
1573   if (sym != NULL)
1574     {
1575       SYMBOL_TYPE (sym) = type;
1576       if (cu_language == language_cplus)
1577         {
1578           synthesize_typedef (dip, objfile, type);
1579         }
1580     }
1581 }
1582
1583 /*
1584
1585    LOCAL FUNCTION
1586
1587    enum_type -- decode and return a type for an enumeration
1588
1589    SYNOPSIS
1590
1591    static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1592
1593    DESCRIPTION
1594
1595    Given a pointer to a die information structure for the die which
1596    starts an enumeration, process all the dies that define the members
1597    of the enumeration and return a type pointer for the enumeration.
1598
1599    At the same time, for each member of the enumeration, create a
1600    symbol for it with domain VAR_DOMAIN and class LOC_CONST,
1601    and give it the type of the enumeration itself.
1602
1603    NOTES
1604
1605    Note that the DWARF specification explicitly mandates that enum
1606    constants occur in reverse order from the source program order,
1607    for "consistency" and because this ordering is easier for many
1608    compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1609    Entries).  Because gdb wants to see the enum members in program
1610    source order, we have to ensure that the order gets reversed while
1611    we are processing them.
1612  */
1613
1614 static struct type *
1615 enum_type (struct dieinfo *dip, struct objfile *objfile)
1616 {
1617   struct type *type;
1618   struct nextfield
1619     {
1620       struct nextfield *next;
1621       struct field field;
1622     };
1623   struct nextfield *list = NULL;
1624   struct nextfield *new;
1625   int nfields = 0;
1626   int n;
1627   char *scan;
1628   char *listend;
1629   unsigned short blocksz;
1630   struct symbol *sym;
1631   int nbytes;
1632   int unsigned_enum = 1;
1633
1634   type = lookup_utype (dip->die_ref);
1635   if (type == NULL)
1636     {
1637       /* No forward references created an empty type, so install one now */
1638       type = alloc_utype (dip->die_ref, NULL);
1639     }
1640   TYPE_CODE (type) = TYPE_CODE_ENUM;
1641   /* Some compilers try to be helpful by inventing "fake" names for
1642      anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1643      Thanks, but no thanks... */
1644   if (dip->at_name != NULL
1645       && *dip->at_name != '~'
1646       && *dip->at_name != '.')
1647     {
1648       TYPE_TAG_NAME (type) = obconcat (&objfile->type_obstack,
1649                                        "", "", dip->at_name);
1650     }
1651   if (dip->at_byte_size != 0)
1652     {
1653       TYPE_LENGTH (type) = dip->at_byte_size;
1654     }
1655   scan = dip->at_element_list;
1656   if (scan != NULL)
1657     {
1658       if (dip->short_element_list)
1659         {
1660           nbytes = attribute_size (AT_short_element_list);
1661         }
1662       else
1663         {
1664           nbytes = attribute_size (AT_element_list);
1665         }
1666       blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
1667       listend = scan + nbytes + blocksz;
1668       scan += nbytes;
1669       while (scan < listend)
1670         {
1671           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1672           new->next = list;
1673           list = new;
1674           FIELD_TYPE (list->field) = NULL;
1675           FIELD_BITSIZE (list->field) = 0;
1676           FIELD_STATIC_KIND (list->field) = 0;
1677           FIELD_BITPOS (list->field) =
1678             target_to_host (scan, TARGET_FT_LONG_SIZE (objfile), GET_SIGNED,
1679                             objfile);
1680           scan += TARGET_FT_LONG_SIZE (objfile);
1681           list->field.name = obsavestring (scan, strlen (scan),
1682                                            &objfile->type_obstack);
1683           scan += strlen (scan) + 1;
1684           nfields++;
1685           /* Handcraft a new symbol for this enum member. */
1686           sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1687                                                  sizeof (struct symbol));
1688           memset (sym, 0, sizeof (struct symbol));
1689           DEPRECATED_SYMBOL_NAME (sym) = create_name (list->field.name,
1690                                            &objfile->symbol_obstack);
1691           SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
1692           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1693           SYMBOL_CLASS (sym) = LOC_CONST;
1694           SYMBOL_TYPE (sym) = type;
1695           SYMBOL_VALUE (sym) = FIELD_BITPOS (list->field);
1696           if (SYMBOL_VALUE (sym) < 0)
1697             unsigned_enum = 0;
1698           add_symbol_to_list (sym, list_in_scope);
1699         }
1700       /* Now create the vector of fields, and record how big it is. This is
1701          where we reverse the order, by pulling the members off the list in
1702          reverse order from how they were inserted.  If we have no fields
1703          (this is apparently possible in C++) then skip building a field
1704          vector. */
1705       if (nfields > 0)
1706         {
1707           if (unsigned_enum)
1708             TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
1709           TYPE_NFIELDS (type) = nfields;
1710           TYPE_FIELDS (type) = (struct field *)
1711             obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields);
1712           /* Copy the saved-up fields into the field vector.  */
1713           for (n = 0; (n < nfields) && (list != NULL); list = list->next)
1714             {
1715               TYPE_FIELD (type, n++) = list->field;
1716             }
1717         }
1718     }
1719   return (type);
1720 }
1721
1722 /*
1723
1724    LOCAL FUNCTION
1725
1726    read_func_scope -- process all dies within a function scope
1727
1728    DESCRIPTION
1729
1730    Process all dies within a given function scope.  We are passed
1731    a die information structure pointer DIP for the die which
1732    starts the function scope, and pointers into the raw die data
1733    that define the dies within the function scope.
1734
1735    For now, we ignore lexical block scopes within the function.
1736    The problem is that AT&T cc does not define a DWARF lexical
1737    block scope for the function itself, while gcc defines a
1738    lexical block scope for the function.  We need to think about
1739    how to handle this difference, or if it is even a problem.
1740    (FIXME)
1741  */
1742
1743 static void
1744 read_func_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1745                  struct objfile *objfile)
1746 {
1747   struct context_stack *new;
1748
1749   /* AT_name is absent if the function is described with an
1750      AT_abstract_origin tag.
1751      Ignore the function description for now to avoid GDB core dumps.
1752      FIXME: Add code to handle AT_abstract_origin tags properly.  */
1753   if (dip->at_name == NULL)
1754     {
1755       complaint (&symfile_complaints, "DIE @ 0x%x, AT_name tag missing",
1756                  DIE_ID);
1757       return;
1758     }
1759
1760   if (objfile->ei.entry_point >= dip->at_low_pc &&
1761       objfile->ei.entry_point < dip->at_high_pc)
1762     {
1763       objfile->ei.entry_func_lowpc = dip->at_low_pc;
1764       objfile->ei.entry_func_highpc = dip->at_high_pc;
1765     }
1766   new = push_context (0, dip->at_low_pc);
1767   new->name = new_symbol (dip, objfile);
1768   list_in_scope = &local_symbols;
1769   process_dies (thisdie + dip->die_length, enddie, objfile);
1770   new = pop_context ();
1771   /* Make a block for the local symbols within.  */
1772   finish_block (new->name, &local_symbols, new->old_blocks,
1773                 new->start_addr, dip->at_high_pc, objfile);
1774   list_in_scope = &file_symbols;
1775 }
1776
1777
1778 /*
1779
1780    LOCAL FUNCTION
1781
1782    handle_producer -- process the AT_producer attribute
1783
1784    DESCRIPTION
1785
1786    Perform any operations that depend on finding a particular
1787    AT_producer attribute.
1788
1789  */
1790
1791 static void
1792 handle_producer (char *producer)
1793 {
1794
1795   /* If this compilation unit was compiled with g++ or gcc, then set the
1796      processing_gcc_compilation flag. */
1797
1798   if (STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER)))
1799     {
1800       char version = producer[strlen (GCC_PRODUCER)];
1801       processing_gcc_compilation = (version == '2' ? 2 : 1);
1802     }
1803   else
1804     {
1805       processing_gcc_compilation =
1806         STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER));
1807     }
1808
1809   /* Select a demangling style if we can identify the producer and if
1810      the current style is auto.  We leave the current style alone if it
1811      is not auto.  We also leave the demangling style alone if we find a
1812      gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1813
1814   if (AUTO_DEMANGLING)
1815     {
1816       if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))
1817         {
1818 #if 0
1819           /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1820              know whether it will use the old style or v3 mangling.  */
1821           set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1822 #endif
1823         }
1824       else if (STREQN (producer, LCC_PRODUCER, strlen (LCC_PRODUCER)))
1825         {
1826           set_demangling_style (LUCID_DEMANGLING_STYLE_STRING);
1827         }
1828     }
1829 }
1830
1831
1832 /*
1833
1834    LOCAL FUNCTION
1835
1836    read_file_scope -- process all dies within a file scope
1837
1838    DESCRIPTION
1839
1840    Process all dies within a given file scope.  We are passed a
1841    pointer to the die information structure for the die which
1842    starts the file scope, and pointers into the raw die data which
1843    mark the range of dies within the file scope.
1844
1845    When the partial symbol table is built, the file offset for the line
1846    number table for each compilation unit is saved in the partial symbol
1847    table entry for that compilation unit.  As the symbols for each
1848    compilation unit are read, the line number table is read into memory
1849    and the variable lnbase is set to point to it.  Thus all we have to
1850    do is use lnbase to access the line number table for the current
1851    compilation unit.
1852  */
1853
1854 static void
1855 read_file_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1856                  struct objfile *objfile)
1857 {
1858   struct cleanup *back_to;
1859   struct symtab *symtab;
1860
1861   if (objfile->ei.entry_point >= dip->at_low_pc &&
1862       objfile->ei.entry_point < dip->at_high_pc)
1863     {
1864       objfile->ei.entry_file_lowpc = dip->at_low_pc;
1865       objfile->ei.entry_file_highpc = dip->at_high_pc;
1866     }
1867   set_cu_language (dip);
1868   if (dip->at_producer != NULL)
1869     {
1870       handle_producer (dip->at_producer);
1871     }
1872   numutypes = (enddie - thisdie) / 4;
1873   utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
1874   back_to = make_cleanup (free_utypes, NULL);
1875   memset (utypes, 0, numutypes * sizeof (struct type *));
1876   memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
1877   start_symtab (dip->at_name, dip->at_comp_dir, dip->at_low_pc);
1878   record_debugformat ("DWARF 1");
1879   decode_line_numbers (lnbase);
1880   process_dies (thisdie + dip->die_length, enddie, objfile);
1881
1882   symtab = end_symtab (dip->at_high_pc, objfile, 0);
1883   if (symtab != NULL)
1884     {
1885       symtab->language = cu_language;
1886     }
1887   do_cleanups (back_to);
1888 }
1889
1890 /*
1891
1892    LOCAL FUNCTION
1893
1894    process_dies -- process a range of DWARF Information Entries
1895
1896    SYNOPSIS
1897
1898    static void process_dies (char *thisdie, char *enddie,
1899    struct objfile *objfile)
1900
1901    DESCRIPTION
1902
1903    Process all DIE's in a specified range.  May be (and almost
1904    certainly will be) called recursively.
1905  */
1906
1907 static void
1908 process_dies (char *thisdie, char *enddie, struct objfile *objfile)
1909 {
1910   char *nextdie;
1911   struct dieinfo di;
1912
1913   while (thisdie < enddie)
1914     {
1915       basicdieinfo (&di, thisdie, objfile);
1916       if (di.die_length < SIZEOF_DIE_LENGTH)
1917         {
1918           break;
1919         }
1920       else if (di.die_tag == TAG_padding)
1921         {
1922           nextdie = thisdie + di.die_length;
1923         }
1924       else
1925         {
1926           completedieinfo (&di, objfile);
1927           if (di.at_sibling != 0)
1928             {
1929               nextdie = dbbase + di.at_sibling - dbroff;
1930             }
1931           else
1932             {
1933               nextdie = thisdie + di.die_length;
1934             }
1935           /* I think that these are always text, not data, addresses.  */
1936           di.at_low_pc = SMASH_TEXT_ADDRESS (di.at_low_pc);
1937           di.at_high_pc = SMASH_TEXT_ADDRESS (di.at_high_pc);
1938           switch (di.die_tag)
1939             {
1940             case TAG_compile_unit:
1941               /* Skip Tag_compile_unit if we are already inside a compilation
1942                  unit, we are unable to handle nested compilation units
1943                  properly (FIXME).  */
1944               if (current_subfile == NULL)
1945                 read_file_scope (&di, thisdie, nextdie, objfile);
1946               else
1947                 nextdie = thisdie + di.die_length;
1948               break;
1949             case TAG_global_subroutine:
1950             case TAG_subroutine:
1951               if (di.has_at_low_pc)
1952                 {
1953                   read_func_scope (&di, thisdie, nextdie, objfile);
1954                 }
1955               break;
1956             case TAG_lexical_block:
1957               read_lexical_block_scope (&di, thisdie, nextdie, objfile);
1958               break;
1959             case TAG_class_type:
1960             case TAG_structure_type:
1961             case TAG_union_type:
1962               read_structure_scope (&di, thisdie, nextdie, objfile);
1963               break;
1964             case TAG_enumeration_type:
1965               read_enumeration (&di, thisdie, nextdie, objfile);
1966               break;
1967             case TAG_subroutine_type:
1968               read_subroutine_type (&di, thisdie, nextdie);
1969               break;
1970             case TAG_array_type:
1971               dwarf_read_array_type (&di);
1972               break;
1973             case TAG_pointer_type:
1974               read_tag_pointer_type (&di);
1975               break;
1976             case TAG_string_type:
1977               read_tag_string_type (&di);
1978               break;
1979             default:
1980               new_symbol (&di, objfile);
1981               break;
1982             }
1983         }
1984       thisdie = nextdie;
1985     }
1986 }
1987
1988 /*
1989
1990    LOCAL FUNCTION
1991
1992    decode_line_numbers -- decode a line number table fragment
1993
1994    SYNOPSIS
1995
1996    static void decode_line_numbers (char *tblscan, char *tblend,
1997    long length, long base, long line, long pc)
1998
1999    DESCRIPTION
2000
2001    Translate the DWARF line number information to gdb form.
2002
2003    The ".line" section contains one or more line number tables, one for
2004    each ".line" section from the objects that were linked.
2005
2006    The AT_stmt_list attribute for each TAG_source_file entry in the
2007    ".debug" section contains the offset into the ".line" section for the
2008    start of the table for that file.
2009
2010    The table itself has the following structure:
2011
2012    <table length><base address><source statement entry>
2013    4 bytes       4 bytes       10 bytes
2014
2015    The table length is the total size of the table, including the 4 bytes
2016    for the length information.
2017
2018    The base address is the address of the first instruction generated
2019    for the source file.
2020
2021    Each source statement entry has the following structure:
2022
2023    <line number><statement position><address delta>
2024    4 bytes      2 bytes             4 bytes
2025
2026    The line number is relative to the start of the file, starting with
2027    line 1.
2028
2029    The statement position either -1 (0xFFFF) or the number of characters
2030    from the beginning of the line to the beginning of the statement.
2031
2032    The address delta is the difference between the base address and
2033    the address of the first instruction for the statement.
2034
2035    Note that we must copy the bytes from the packed table to our local
2036    variables before attempting to use them, to avoid alignment problems
2037    on some machines, particularly RISC processors.
2038
2039    BUGS
2040
2041    Does gdb expect the line numbers to be sorted?  They are now by
2042    chance/luck, but are not required to be.  (FIXME)
2043
2044    The line with number 0 is unused, gdb apparently can discover the
2045    span of the last line some other way. How?  (FIXME)
2046  */
2047
2048 static void
2049 decode_line_numbers (char *linetable)
2050 {
2051   char *tblscan;
2052   char *tblend;
2053   unsigned long length;
2054   unsigned long base;
2055   unsigned long line;
2056   unsigned long pc;
2057
2058   if (linetable != NULL)
2059     {
2060       tblscan = tblend = linetable;
2061       length = target_to_host (tblscan, SIZEOF_LINETBL_LENGTH, GET_UNSIGNED,
2062                                current_objfile);
2063       tblscan += SIZEOF_LINETBL_LENGTH;
2064       tblend += length;
2065       base = target_to_host (tblscan, TARGET_FT_POINTER_SIZE (objfile),
2066                              GET_UNSIGNED, current_objfile);
2067       tblscan += TARGET_FT_POINTER_SIZE (objfile);
2068       base += baseaddr;
2069       while (tblscan < tblend)
2070         {
2071           line = target_to_host (tblscan, SIZEOF_LINETBL_LINENO, GET_UNSIGNED,
2072                                  current_objfile);
2073           tblscan += SIZEOF_LINETBL_LINENO + SIZEOF_LINETBL_STMT;
2074           pc = target_to_host (tblscan, SIZEOF_LINETBL_DELTA, GET_UNSIGNED,
2075                                current_objfile);
2076           tblscan += SIZEOF_LINETBL_DELTA;
2077           pc += base;
2078           if (line != 0)
2079             {
2080               record_line (current_subfile, line, pc);
2081             }
2082         }
2083     }
2084 }
2085
2086 /*
2087
2088    LOCAL FUNCTION
2089
2090    locval -- compute the value of a location attribute
2091
2092    SYNOPSIS
2093
2094    static int locval (struct dieinfo *dip)
2095
2096    DESCRIPTION
2097
2098    Given pointer to a string of bytes that define a location, compute
2099    the location and return the value.
2100    A location description containing no atoms indicates that the
2101    object is optimized out. The optimized_out flag is set for those,
2102    the return value is meaningless.
2103
2104    When computing values involving the current value of the frame pointer,
2105    the value zero is used, which results in a value relative to the frame
2106    pointer, rather than the absolute value.  This is what GDB wants
2107    anyway.
2108
2109    When the result is a register number, the isreg flag is set, otherwise
2110    it is cleared.  This is a kludge until we figure out a better
2111    way to handle the problem.  Gdb's design does not mesh well with the
2112    DWARF notion of a location computing interpreter, which is a shame
2113    because the flexibility goes unused.
2114
2115    NOTES
2116
2117    Note that stack[0] is unused except as a default error return.
2118    Note that stack overflow is not yet handled.
2119  */
2120
2121 static int
2122 locval (struct dieinfo *dip)
2123 {
2124   unsigned short nbytes;
2125   unsigned short locsize;
2126   auto long stack[64];
2127   int stacki;
2128   char *loc;
2129   char *end;
2130   int loc_atom_code;
2131   int loc_value_size;
2132
2133   loc = dip->at_location;
2134   nbytes = attribute_size (AT_location);
2135   locsize = target_to_host (loc, nbytes, GET_UNSIGNED, current_objfile);
2136   loc += nbytes;
2137   end = loc + locsize;
2138   stacki = 0;
2139   stack[stacki] = 0;
2140   dip->isreg = 0;
2141   dip->offreg = 0;
2142   dip->optimized_out = 1;
2143   loc_value_size = TARGET_FT_LONG_SIZE (current_objfile);
2144   while (loc < end)
2145     {
2146       dip->optimized_out = 0;
2147       loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED,
2148                                       current_objfile);
2149       loc += SIZEOF_LOC_ATOM_CODE;
2150       switch (loc_atom_code)
2151         {
2152         case 0:
2153           /* error */
2154           loc = end;
2155           break;
2156         case OP_REG:
2157           /* push register (number) */
2158           stack[++stacki]
2159             = DWARF_REG_TO_REGNUM (target_to_host (loc, loc_value_size,
2160                                                    GET_UNSIGNED,
2161                                                    current_objfile));
2162           loc += loc_value_size;
2163           dip->isreg = 1;
2164           break;
2165         case OP_BASEREG:
2166           /* push value of register (number) */
2167           /* Actually, we compute the value as if register has 0, so the
2168              value ends up being the offset from that register.  */
2169           dip->offreg = 1;
2170           dip->basereg = target_to_host (loc, loc_value_size, GET_UNSIGNED,
2171                                          current_objfile);
2172           loc += loc_value_size;
2173           stack[++stacki] = 0;
2174           break;
2175         case OP_ADDR:
2176           /* push address (relocated address) */
2177           stack[++stacki] = target_to_host (loc, loc_value_size,
2178                                             GET_UNSIGNED, current_objfile);
2179           loc += loc_value_size;
2180           break;
2181         case OP_CONST:
2182           /* push constant (number)   FIXME: signed or unsigned! */
2183           stack[++stacki] = target_to_host (loc, loc_value_size,
2184                                             GET_SIGNED, current_objfile);
2185           loc += loc_value_size;
2186           break;
2187         case OP_DEREF2:
2188           /* pop, deref and push 2 bytes (as a long) */
2189           complaint (&symfile_complaints,
2190                      "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled",
2191                      DIE_ID, DIE_NAME, stack[stacki]);
2192           break;
2193         case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
2194           complaint (&symfile_complaints,
2195                      "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled",
2196                      DIE_ID, DIE_NAME, stack[stacki]);
2197           break;
2198         case OP_ADD:            /* pop top 2 items, add, push result */
2199           stack[stacki - 1] += stack[stacki];
2200           stacki--;
2201           break;
2202         }
2203     }
2204   return (stack[stacki]);
2205 }
2206
2207 /*
2208
2209    LOCAL FUNCTION
2210
2211    read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2212
2213    SYNOPSIS
2214
2215    static void read_ofile_symtab (struct partial_symtab *pst)
2216
2217    DESCRIPTION
2218
2219    When expanding a partial symbol table entry to a full symbol table
2220    entry, this is the function that gets called to read in the symbols
2221    for the compilation unit.  A pointer to the newly constructed symtab,
2222    which is now the new first one on the objfile's symtab list, is
2223    stashed in the partial symbol table entry.
2224  */
2225
2226 static void
2227 read_ofile_symtab (struct partial_symtab *pst)
2228 {
2229   struct cleanup *back_to;
2230   unsigned long lnsize;
2231   file_ptr foffset;
2232   bfd *abfd;
2233   char lnsizedata[SIZEOF_LINETBL_LENGTH];
2234
2235   abfd = pst->objfile->obfd;
2236   current_objfile = pst->objfile;
2237
2238   /* Allocate a buffer for the entire chunk of DIE's for this compilation
2239      unit, seek to the location in the file, and read in all the DIE's. */
2240
2241   diecount = 0;
2242   dbsize = DBLENGTH (pst);
2243   dbbase = xmalloc (dbsize);
2244   dbroff = DBROFF (pst);
2245   foffset = DBFOFF (pst) + dbroff;
2246   base_section_offsets = pst->section_offsets;
2247   baseaddr = ANOFFSET (pst->section_offsets, 0);
2248   if (bfd_seek (abfd, foffset, SEEK_SET) ||
2249       (bfd_bread (dbbase, dbsize, abfd) != dbsize))
2250     {
2251       xfree (dbbase);
2252       error ("can't read DWARF data");
2253     }
2254   back_to = make_cleanup (xfree, dbbase);
2255
2256   /* If there is a line number table associated with this compilation unit
2257      then read the size of this fragment in bytes, from the fragment itself.
2258      Allocate a buffer for the fragment and read it in for future 
2259      processing. */
2260
2261   lnbase = NULL;
2262   if (LNFOFF (pst))
2263     {
2264       if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
2265           (bfd_bread (lnsizedata, sizeof (lnsizedata), abfd)
2266            != sizeof (lnsizedata)))
2267         {
2268           error ("can't read DWARF line number table size");
2269         }
2270       lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH,
2271                                GET_UNSIGNED, pst->objfile);
2272       lnbase = xmalloc (lnsize);
2273       if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
2274           (bfd_bread (lnbase, lnsize, abfd) != lnsize))
2275         {
2276           xfree (lnbase);
2277           error ("can't read DWARF line numbers");
2278         }
2279       make_cleanup (xfree, lnbase);
2280     }
2281
2282   process_dies (dbbase, dbbase + dbsize, pst->objfile);
2283   do_cleanups (back_to);
2284   current_objfile = NULL;
2285   pst->symtab = pst->objfile->symtabs;
2286 }
2287
2288 /*
2289
2290    LOCAL FUNCTION
2291
2292    psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2293
2294    SYNOPSIS
2295
2296    static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2297
2298    DESCRIPTION
2299
2300    Called once for each partial symbol table entry that needs to be
2301    expanded into a full symbol table entry.
2302
2303  */
2304
2305 static void
2306 psymtab_to_symtab_1 (struct partial_symtab *pst)
2307 {
2308   int i;
2309   struct cleanup *old_chain;
2310
2311   if (pst != NULL)
2312     {
2313       if (pst->readin)
2314         {
2315           warning ("psymtab for %s already read in.  Shouldn't happen.",
2316                    pst->filename);
2317         }
2318       else
2319         {
2320           /* Read in all partial symtabs on which this one is dependent */
2321           for (i = 0; i < pst->number_of_dependencies; i++)
2322             {
2323               if (!pst->dependencies[i]->readin)
2324                 {
2325                   /* Inform about additional files that need to be read in. */
2326                   if (info_verbose)
2327                     {
2328                       fputs_filtered (" ", gdb_stdout);
2329                       wrap_here ("");
2330                       fputs_filtered ("and ", gdb_stdout);
2331                       wrap_here ("");
2332                       printf_filtered ("%s...",
2333                                        pst->dependencies[i]->filename);
2334                       wrap_here ("");
2335                       gdb_flush (gdb_stdout);   /* Flush output */
2336                     }
2337                   psymtab_to_symtab_1 (pst->dependencies[i]);
2338                 }
2339             }
2340           if (DBLENGTH (pst))   /* Otherwise it's a dummy */
2341             {
2342               buildsym_init ();
2343               old_chain = make_cleanup (really_free_pendings, 0);
2344               read_ofile_symtab (pst);
2345               if (info_verbose)
2346                 {
2347                   printf_filtered ("%d DIE's, sorting...", diecount);
2348                   wrap_here ("");
2349                   gdb_flush (gdb_stdout);
2350                 }
2351               sort_symtab_syms (pst->symtab);
2352               do_cleanups (old_chain);
2353             }
2354           pst->readin = 1;
2355         }
2356     }
2357 }
2358
2359 /*
2360
2361    LOCAL FUNCTION
2362
2363    dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2364
2365    SYNOPSIS
2366
2367    static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2368
2369    DESCRIPTION
2370
2371    This is the DWARF support entry point for building a full symbol
2372    table entry from a partial symbol table entry.  We are passed a
2373    pointer to the partial symbol table entry that needs to be expanded.
2374
2375  */
2376
2377 static void
2378 dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2379 {
2380
2381   if (pst != NULL)
2382     {
2383       if (pst->readin)
2384         {
2385           warning ("psymtab for %s already read in.  Shouldn't happen.",
2386                    pst->filename);
2387         }
2388       else
2389         {
2390           if (DBLENGTH (pst) || pst->number_of_dependencies)
2391             {
2392               /* Print the message now, before starting serious work, to avoid
2393                  disconcerting pauses.  */
2394               if (info_verbose)
2395                 {
2396                   printf_filtered ("Reading in symbols for %s...",
2397                                    pst->filename);
2398                   gdb_flush (gdb_stdout);
2399                 }
2400
2401               psymtab_to_symtab_1 (pst);
2402
2403 #if 0                           /* FIXME:  Check to see what dbxread is doing here and see if
2404                                    we need to do an equivalent or is this something peculiar to
2405                                    stabs/a.out format.
2406                                    Match with global symbols.  This only needs to be done once,
2407                                    after all of the symtabs and dependencies have been read in.
2408                                  */
2409               scan_file_globals (pst->objfile);
2410 #endif
2411
2412               /* Finish up the verbose info message.  */
2413               if (info_verbose)
2414                 {
2415                   printf_filtered ("done.\n");
2416                   gdb_flush (gdb_stdout);
2417                 }
2418             }
2419         }
2420     }
2421 }
2422
2423 /*
2424
2425    LOCAL FUNCTION
2426
2427    add_enum_psymbol -- add enumeration members to partial symbol table
2428
2429    DESCRIPTION
2430
2431    Given pointer to a DIE that is known to be for an enumeration,
2432    extract the symbolic names of the enumeration members and add
2433    partial symbols for them.
2434  */
2435
2436 static void
2437 add_enum_psymbol (struct dieinfo *dip, struct objfile *objfile)
2438 {
2439   char *scan;
2440   char *listend;
2441   unsigned short blocksz;
2442   int nbytes;
2443
2444   scan = dip->at_element_list;
2445   if (scan != NULL)
2446     {
2447       if (dip->short_element_list)
2448         {
2449           nbytes = attribute_size (AT_short_element_list);
2450         }
2451       else
2452         {
2453           nbytes = attribute_size (AT_element_list);
2454         }
2455       blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
2456       scan += nbytes;
2457       listend = scan + blocksz;
2458       while (scan < listend)
2459         {
2460           scan += TARGET_FT_LONG_SIZE (objfile);
2461           add_psymbol_to_list (scan, strlen (scan), VAR_DOMAIN, LOC_CONST,
2462                                &objfile->static_psymbols, 0, 0, cu_language,
2463                                objfile);
2464           scan += strlen (scan) + 1;
2465         }
2466     }
2467 }
2468
2469 /*
2470
2471    LOCAL FUNCTION
2472
2473    add_partial_symbol -- add symbol to partial symbol table
2474
2475    DESCRIPTION
2476
2477    Given a DIE, if it is one of the types that we want to
2478    add to a partial symbol table, finish filling in the die info
2479    and then add a partial symbol table entry for it.
2480
2481    NOTES
2482
2483    The caller must ensure that the DIE has a valid name attribute.
2484  */
2485
2486 static void
2487 add_partial_symbol (struct dieinfo *dip, struct objfile *objfile)
2488 {
2489   switch (dip->die_tag)
2490     {
2491     case TAG_global_subroutine:
2492       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2493                            VAR_DOMAIN, LOC_BLOCK,
2494                            &objfile->global_psymbols,
2495                            0, dip->at_low_pc, cu_language, objfile);
2496       break;
2497     case TAG_global_variable:
2498       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2499                            VAR_DOMAIN, LOC_STATIC,
2500                            &objfile->global_psymbols,
2501                            0, 0, cu_language, objfile);
2502       break;
2503     case TAG_subroutine:
2504       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2505                            VAR_DOMAIN, LOC_BLOCK,
2506                            &objfile->static_psymbols,
2507                            0, dip->at_low_pc, cu_language, objfile);
2508       break;
2509     case TAG_local_variable:
2510       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2511                            VAR_DOMAIN, LOC_STATIC,
2512                            &objfile->static_psymbols,
2513                            0, 0, cu_language, objfile);
2514       break;
2515     case TAG_typedef:
2516       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2517                            VAR_DOMAIN, LOC_TYPEDEF,
2518                            &objfile->static_psymbols,
2519                            0, 0, cu_language, objfile);
2520       break;
2521     case TAG_class_type:
2522     case TAG_structure_type:
2523     case TAG_union_type:
2524     case TAG_enumeration_type:
2525       /* Do not add opaque aggregate definitions to the psymtab.  */
2526       if (!dip->has_at_byte_size)
2527         break;
2528       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2529                            STRUCT_DOMAIN, LOC_TYPEDEF,
2530                            &objfile->static_psymbols,
2531                            0, 0, cu_language, objfile);
2532       if (cu_language == language_cplus)
2533         {
2534           /* For C++, these implicitly act as typedefs as well. */
2535           add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2536                                VAR_DOMAIN, LOC_TYPEDEF,
2537                                &objfile->static_psymbols,
2538                                0, 0, cu_language, objfile);
2539         }
2540       break;
2541     }
2542 }
2543 /* *INDENT-OFF* */
2544 /*
2545
2546 LOCAL FUNCTION
2547
2548         scan_partial_symbols -- scan DIE's within a single compilation unit
2549
2550 DESCRIPTION
2551
2552         Process the DIE's within a single compilation unit, looking for
2553         interesting DIE's that contribute to the partial symbol table entry
2554         for this compilation unit.
2555
2556 NOTES
2557
2558         There are some DIE's that may appear both at file scope and within
2559         the scope of a function.  We are only interested in the ones at file
2560         scope, and the only way to tell them apart is to keep track of the
2561         scope.  For example, consider the test case:
2562
2563                 static int i;
2564                 main () { int j; }
2565
2566         for which the relevant DWARF segment has the structure:
2567         
2568                 0x51:
2569                 0x23   global subrtn   sibling     0x9b
2570                                        name        main
2571                                        fund_type   FT_integer
2572                                        low_pc      0x800004cc
2573                                        high_pc     0x800004d4
2574                                             
2575                 0x74:
2576                 0x23   local var       sibling     0x97
2577                                        name        j
2578                                        fund_type   FT_integer
2579                                        location    OP_BASEREG 0xe
2580                                                    OP_CONST 0xfffffffc
2581                                                    OP_ADD
2582                 0x97:
2583                 0x4         
2584                 
2585                 0x9b:
2586                 0x1d   local var       sibling     0xb8
2587                                        name        i
2588                                        fund_type   FT_integer
2589                                        location    OP_ADDR 0x800025dc
2590                                             
2591                 0xb8:
2592                 0x4         
2593
2594         We want to include the symbol 'i' in the partial symbol table, but
2595         not the symbol 'j'.  In essence, we want to skip all the dies within
2596         the scope of a TAG_global_subroutine DIE.
2597
2598         Don't attempt to add anonymous structures or unions since they have
2599         no name.  Anonymous enumerations however are processed, because we
2600         want to extract their member names (the check for a tag name is
2601         done later).
2602
2603         Also, for variables and subroutines, check that this is the place
2604         where the actual definition occurs, rather than just a reference
2605         to an external.
2606  */
2607 /* *INDENT-ON* */
2608
2609
2610
2611 static void
2612 scan_partial_symbols (char *thisdie, char *enddie, struct objfile *objfile)
2613 {
2614   char *nextdie;
2615   char *temp;
2616   struct dieinfo di;
2617
2618   while (thisdie < enddie)
2619     {
2620       basicdieinfo (&di, thisdie, objfile);
2621       if (di.die_length < SIZEOF_DIE_LENGTH)
2622         {
2623           break;
2624         }
2625       else
2626         {
2627           nextdie = thisdie + di.die_length;
2628           /* To avoid getting complete die information for every die, we
2629              only do it (below) for the cases we are interested in. */
2630           switch (di.die_tag)
2631             {
2632             case TAG_global_subroutine:
2633             case TAG_subroutine:
2634               completedieinfo (&di, objfile);
2635               if (di.at_name && (di.has_at_low_pc || di.at_location))
2636                 {
2637                   add_partial_symbol (&di, objfile);
2638                   /* If there is a sibling attribute, adjust the nextdie
2639                      pointer to skip the entire scope of the subroutine.
2640                      Apply some sanity checking to make sure we don't 
2641                      overrun or underrun the range of remaining DIE's */
2642                   if (di.at_sibling != 0)
2643                     {
2644                       temp = dbbase + di.at_sibling - dbroff;
2645                       if ((temp < thisdie) || (temp >= enddie))
2646                         {
2647                           bad_die_ref_complaint (DIE_ID, DIE_NAME,
2648                                                  di.at_sibling);
2649                         }
2650                       else
2651                         {
2652                           nextdie = temp;
2653                         }
2654                     }
2655                 }
2656               break;
2657             case TAG_global_variable:
2658             case TAG_local_variable:
2659               completedieinfo (&di, objfile);
2660               if (di.at_name && (di.has_at_low_pc || di.at_location))
2661                 {
2662                   add_partial_symbol (&di, objfile);
2663                 }
2664               break;
2665             case TAG_typedef:
2666             case TAG_class_type:
2667             case TAG_structure_type:
2668             case TAG_union_type:
2669               completedieinfo (&di, objfile);
2670               if (di.at_name)
2671                 {
2672                   add_partial_symbol (&di, objfile);
2673                 }
2674               break;
2675             case TAG_enumeration_type:
2676               completedieinfo (&di, objfile);
2677               if (di.at_name)
2678                 {
2679                   add_partial_symbol (&di, objfile);
2680                 }
2681               add_enum_psymbol (&di, objfile);
2682               break;
2683             }
2684         }
2685       thisdie = nextdie;
2686     }
2687 }
2688
2689 /*
2690
2691    LOCAL FUNCTION
2692
2693    scan_compilation_units -- build a psymtab entry for each compilation
2694
2695    DESCRIPTION
2696
2697    This is the top level dwarf parsing routine for building partial
2698    symbol tables.
2699
2700    It scans from the beginning of the DWARF table looking for the first
2701    TAG_compile_unit DIE, and then follows the sibling chain to locate
2702    each additional TAG_compile_unit DIE.
2703
2704    For each TAG_compile_unit DIE it creates a partial symtab structure,
2705    calls a subordinate routine to collect all the compilation unit's
2706    global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2707    new partial symtab structure into the partial symbol table.  It also
2708    records the appropriate information in the partial symbol table entry
2709    to allow the chunk of DIE's and line number table for this compilation
2710    unit to be located and re-read later, to generate a complete symbol
2711    table entry for the compilation unit.
2712
2713    Thus it effectively partitions up a chunk of DIE's for multiple
2714    compilation units into smaller DIE chunks and line number tables,
2715    and associates them with a partial symbol table entry.
2716
2717    NOTES
2718
2719    If any compilation unit has no line number table associated with
2720    it for some reason (a missing at_stmt_list attribute, rather than
2721    just one with a value of zero, which is valid) then we ensure that
2722    the recorded file offset is zero so that the routine which later
2723    reads line number table fragments knows that there is no fragment
2724    to read.
2725
2726    RETURNS
2727
2728    Returns no value.
2729
2730  */
2731
2732 static void
2733 scan_compilation_units (char *thisdie, char *enddie, file_ptr dbfoff,
2734                         file_ptr lnoffset, struct objfile *objfile)
2735 {
2736   char *nextdie;
2737   struct dieinfo di;
2738   struct partial_symtab *pst;
2739   int culength;
2740   int curoff;
2741   file_ptr curlnoffset;
2742
2743   while (thisdie < enddie)
2744     {
2745       basicdieinfo (&di, thisdie, objfile);
2746       if (di.die_length < SIZEOF_DIE_LENGTH)
2747         {
2748           break;
2749         }
2750       else if (di.die_tag != TAG_compile_unit)
2751         {
2752           nextdie = thisdie + di.die_length;
2753         }
2754       else
2755         {
2756           completedieinfo (&di, objfile);
2757           set_cu_language (&di);
2758           if (di.at_sibling != 0)
2759             {
2760               nextdie = dbbase + di.at_sibling - dbroff;
2761             }
2762           else
2763             {
2764               nextdie = thisdie + di.die_length;
2765             }
2766           curoff = thisdie - dbbase;
2767           culength = nextdie - thisdie;
2768           curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0;
2769
2770           /* First allocate a new partial symbol table structure */
2771
2772           pst = start_psymtab_common (objfile, base_section_offsets,
2773                                       di.at_name, di.at_low_pc,
2774                                       objfile->global_psymbols.next,
2775                                       objfile->static_psymbols.next);
2776
2777           pst->texthigh = di.at_high_pc;
2778           pst->read_symtab_private = (char *)
2779             obstack_alloc (&objfile->psymbol_obstack,
2780                            sizeof (struct dwfinfo));
2781           DBFOFF (pst) = dbfoff;
2782           DBROFF (pst) = curoff;
2783           DBLENGTH (pst) = culength;
2784           LNFOFF (pst) = curlnoffset;
2785           pst->read_symtab = dwarf_psymtab_to_symtab;
2786
2787           /* Now look for partial symbols */
2788
2789           scan_partial_symbols (thisdie + di.die_length, nextdie, objfile);
2790
2791           pst->n_global_syms = objfile->global_psymbols.next -
2792             (objfile->global_psymbols.list + pst->globals_offset);
2793           pst->n_static_syms = objfile->static_psymbols.next -
2794             (objfile->static_psymbols.list + pst->statics_offset);
2795           sort_pst_symbols (pst);
2796           /* If there is already a psymtab or symtab for a file of this name,
2797              remove it. (If there is a symtab, more drastic things also
2798              happen.)  This happens in VxWorks.  */
2799           free_named_symtabs (pst->filename);
2800         }
2801       thisdie = nextdie;
2802     }
2803 }
2804
2805 /*
2806
2807    LOCAL FUNCTION
2808
2809    new_symbol -- make a symbol table entry for a new symbol
2810
2811    SYNOPSIS
2812
2813    static struct symbol *new_symbol (struct dieinfo *dip,
2814    struct objfile *objfile)
2815
2816    DESCRIPTION
2817
2818    Given a pointer to a DWARF information entry, figure out if we need
2819    to make a symbol table entry for it, and if so, create a new entry
2820    and return a pointer to it.
2821  */
2822
2823 static struct symbol *
2824 new_symbol (struct dieinfo *dip, struct objfile *objfile)
2825 {
2826   struct symbol *sym = NULL;
2827
2828   if (dip->at_name != NULL)
2829     {
2830       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
2831                                              sizeof (struct symbol));
2832       OBJSTAT (objfile, n_syms++);
2833       memset (sym, 0, sizeof (struct symbol));
2834       /* default assumptions */
2835       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2836       SYMBOL_CLASS (sym) = LOC_STATIC;
2837       SYMBOL_TYPE (sym) = decode_die_type (dip);
2838
2839       /* If this symbol is from a C++ compilation, then attempt to cache the
2840          demangled form for future reference.  This is a typical time versus
2841          space tradeoff, that was decided in favor of time because it sped up
2842          C++ symbol lookups by a factor of about 20. */
2843
2844       SYMBOL_LANGUAGE (sym) = cu_language;
2845       SYMBOL_SET_NAMES (sym, dip->at_name, strlen (dip->at_name), objfile);
2846       switch (dip->die_tag)
2847         {
2848         case TAG_label:
2849           SYMBOL_VALUE_ADDRESS (sym) = dip->at_low_pc;
2850           SYMBOL_CLASS (sym) = LOC_LABEL;
2851           break;
2852         case TAG_global_subroutine:
2853         case TAG_subroutine:
2854           SYMBOL_VALUE_ADDRESS (sym) = dip->at_low_pc;
2855           SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
2856           if (dip->at_prototyped)
2857             TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
2858           SYMBOL_CLASS (sym) = LOC_BLOCK;
2859           if (dip->die_tag == TAG_global_subroutine)
2860             {
2861               add_symbol_to_list (sym, &global_symbols);
2862             }
2863           else
2864             {
2865               add_symbol_to_list (sym, list_in_scope);
2866             }
2867           break;
2868         case TAG_global_variable:
2869           if (dip->at_location != NULL)
2870             {
2871               SYMBOL_VALUE_ADDRESS (sym) = locval (dip);
2872               add_symbol_to_list (sym, &global_symbols);
2873               SYMBOL_CLASS (sym) = LOC_STATIC;
2874               SYMBOL_VALUE (sym) += baseaddr;
2875             }
2876           break;
2877         case TAG_local_variable:
2878           if (dip->at_location != NULL)
2879             {
2880               int loc = locval (dip);
2881               if (dip->optimized_out)
2882                 {
2883                   SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
2884                 }
2885               else if (dip->isreg)
2886                 {
2887                   SYMBOL_CLASS (sym) = LOC_REGISTER;
2888                 }
2889               else if (dip->offreg)
2890                 {
2891                   SYMBOL_CLASS (sym) = LOC_BASEREG;
2892                   SYMBOL_BASEREG (sym) = dip->basereg;
2893                 }
2894               else
2895                 {
2896                   SYMBOL_CLASS (sym) = LOC_STATIC;
2897                   SYMBOL_VALUE (sym) += baseaddr;
2898                 }
2899               if (SYMBOL_CLASS (sym) == LOC_STATIC)
2900                 {
2901                   /* LOC_STATIC address class MUST use SYMBOL_VALUE_ADDRESS,
2902                      which may store to a bigger location than SYMBOL_VALUE. */
2903                   SYMBOL_VALUE_ADDRESS (sym) = loc;
2904                 }
2905               else
2906                 {
2907                   SYMBOL_VALUE (sym) = loc;
2908                 }
2909               add_symbol_to_list (sym, list_in_scope);
2910             }
2911           break;
2912         case TAG_formal_parameter:
2913           if (dip->at_location != NULL)
2914             {
2915               SYMBOL_VALUE (sym) = locval (dip);
2916             }
2917           add_symbol_to_list (sym, list_in_scope);
2918           if (dip->isreg)
2919             {
2920               SYMBOL_CLASS (sym) = LOC_REGPARM;
2921             }
2922           else if (dip->offreg)
2923             {
2924               SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
2925               SYMBOL_BASEREG (sym) = dip->basereg;
2926             }
2927           else
2928             {
2929               SYMBOL_CLASS (sym) = LOC_ARG;
2930             }
2931           break;
2932         case TAG_unspecified_parameters:
2933           /* From varargs functions; gdb doesn't seem to have any interest in
2934              this information, so just ignore it for now. (FIXME?) */
2935           break;
2936         case TAG_class_type:
2937         case TAG_structure_type:
2938         case TAG_union_type:
2939         case TAG_enumeration_type:
2940           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2941           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
2942           add_symbol_to_list (sym, list_in_scope);
2943           break;
2944         case TAG_typedef:
2945           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2946           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2947           add_symbol_to_list (sym, list_in_scope);
2948           break;
2949         default:
2950           /* Not a tag we recognize.  Hopefully we aren't processing trash
2951              data, but since we must specifically ignore things we don't
2952              recognize, there is nothing else we should do at this point. */
2953           break;
2954         }
2955     }
2956   return (sym);
2957 }
2958
2959 /*
2960
2961    LOCAL FUNCTION
2962
2963    synthesize_typedef -- make a symbol table entry for a "fake" typedef
2964
2965    SYNOPSIS
2966
2967    static void synthesize_typedef (struct dieinfo *dip,
2968    struct objfile *objfile,
2969    struct type *type);
2970
2971    DESCRIPTION
2972
2973    Given a pointer to a DWARF information entry, synthesize a typedef
2974    for the name in the DIE, using the specified type.
2975
2976    This is used for C++ class, structs, unions, and enumerations to
2977    set up the tag name as a type.
2978
2979  */
2980
2981 static void
2982 synthesize_typedef (struct dieinfo *dip, struct objfile *objfile,
2983                     struct type *type)
2984 {
2985   struct symbol *sym = NULL;
2986
2987   if (dip->at_name != NULL)
2988     {
2989       sym = (struct symbol *)
2990         obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
2991       OBJSTAT (objfile, n_syms++);
2992       memset (sym, 0, sizeof (struct symbol));
2993       DEPRECATED_SYMBOL_NAME (sym) = create_name (dip->at_name,
2994                                        &objfile->symbol_obstack);
2995       SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
2996       SYMBOL_TYPE (sym) = type;
2997       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2998       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2999       add_symbol_to_list (sym, list_in_scope);
3000     }
3001 }
3002
3003 /*
3004
3005    LOCAL FUNCTION
3006
3007    decode_mod_fund_type -- decode a modified fundamental type
3008
3009    SYNOPSIS
3010
3011    static struct type *decode_mod_fund_type (char *typedata)
3012
3013    DESCRIPTION
3014
3015    Decode a block of data containing a modified fundamental
3016    type specification.  TYPEDATA is a pointer to the block,
3017    which starts with a length containing the size of the rest
3018    of the block.  At the end of the block is a fundmental type
3019    code value that gives the fundamental type.  Everything
3020    in between are type modifiers.
3021
3022    We simply compute the number of modifiers and call the general
3023    function decode_modified_type to do the actual work.
3024  */
3025
3026 static struct type *
3027 decode_mod_fund_type (char *typedata)
3028 {
3029   struct type *typep = NULL;
3030   unsigned short modcount;
3031   int nbytes;
3032
3033   /* Get the total size of the block, exclusive of the size itself */
3034
3035   nbytes = attribute_size (AT_mod_fund_type);
3036   modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3037   typedata += nbytes;
3038
3039   /* Deduct the size of the fundamental type bytes at the end of the block. */
3040
3041   modcount -= attribute_size (AT_fund_type);
3042
3043   /* Now do the actual decoding */
3044
3045   typep = decode_modified_type (typedata, modcount, AT_mod_fund_type);
3046   return (typep);
3047 }
3048
3049 /*
3050
3051    LOCAL FUNCTION
3052
3053    decode_mod_u_d_type -- decode a modified user defined type
3054
3055    SYNOPSIS
3056
3057    static struct type *decode_mod_u_d_type (char *typedata)
3058
3059    DESCRIPTION
3060
3061    Decode a block of data containing a modified user defined
3062    type specification.  TYPEDATA is a pointer to the block,
3063    which consists of a two byte length, containing the size
3064    of the rest of the block.  At the end of the block is a
3065    four byte value that gives a reference to a user defined type.
3066    Everything in between are type modifiers.
3067
3068    We simply compute the number of modifiers and call the general
3069    function decode_modified_type to do the actual work.
3070  */
3071
3072 static struct type *
3073 decode_mod_u_d_type (char *typedata)
3074 {
3075   struct type *typep = NULL;
3076   unsigned short modcount;
3077   int nbytes;
3078
3079   /* Get the total size of the block, exclusive of the size itself */
3080
3081   nbytes = attribute_size (AT_mod_u_d_type);
3082   modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3083   typedata += nbytes;
3084
3085   /* Deduct the size of the reference type bytes at the end of the block. */
3086
3087   modcount -= attribute_size (AT_user_def_type);
3088
3089   /* Now do the actual decoding */
3090
3091   typep = decode_modified_type (typedata, modcount, AT_mod_u_d_type);
3092   return (typep);
3093 }
3094
3095 /*
3096
3097    LOCAL FUNCTION
3098
3099    decode_modified_type -- decode modified user or fundamental type
3100
3101    SYNOPSIS
3102
3103    static struct type *decode_modified_type (char *modifiers,
3104    unsigned short modcount, int mtype)
3105
3106    DESCRIPTION
3107
3108    Decode a modified type, either a modified fundamental type or
3109    a modified user defined type.  MODIFIERS is a pointer to the
3110    block of bytes that define MODCOUNT modifiers.  Immediately
3111    following the last modifier is a short containing the fundamental
3112    type or a long containing the reference to the user defined
3113    type.  Which one is determined by MTYPE, which is either
3114    AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3115    type we are generating.
3116
3117    We call ourself recursively to generate each modified type,`
3118    until MODCOUNT reaches zero, at which point we have consumed
3119    all the modifiers and generate either the fundamental type or
3120    user defined type.  When the recursion unwinds, each modifier
3121    is applied in turn to generate the full modified type.
3122
3123    NOTES
3124
3125    If we find a modifier that we don't recognize, and it is not one
3126    of those reserved for application specific use, then we issue a
3127    warning and simply ignore the modifier.
3128
3129    BUGS
3130
3131    We currently ignore MOD_const and MOD_volatile.  (FIXME)
3132
3133  */
3134
3135 static struct type *
3136 decode_modified_type (char *modifiers, unsigned int modcount, int mtype)
3137 {
3138   struct type *typep = NULL;
3139   unsigned short fundtype;
3140   DIE_REF die_ref;
3141   char modifier;
3142   int nbytes;
3143
3144   if (modcount == 0)
3145     {
3146       switch (mtype)
3147         {
3148         case AT_mod_fund_type:
3149           nbytes = attribute_size (AT_fund_type);
3150           fundtype = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3151                                      current_objfile);
3152           typep = decode_fund_type (fundtype);
3153           break;
3154         case AT_mod_u_d_type:
3155           nbytes = attribute_size (AT_user_def_type);
3156           die_ref = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3157                                     current_objfile);
3158           typep = lookup_utype (die_ref);
3159           if (typep == NULL)
3160             {
3161               typep = alloc_utype (die_ref, NULL);
3162             }
3163           break;
3164         default:
3165           complaint (&symfile_complaints,
3166                      "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)",
3167                      DIE_ID, DIE_NAME, mtype);
3168           typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3169           break;
3170         }
3171     }
3172   else
3173     {
3174       modifier = *modifiers++;
3175       typep = decode_modified_type (modifiers, --modcount, mtype);
3176       switch (modifier)
3177         {
3178         case MOD_pointer_to:
3179           typep = lookup_pointer_type (typep);
3180           break;
3181         case MOD_reference_to:
3182           typep = lookup_reference_type (typep);
3183           break;
3184         case MOD_const:
3185           complaint (&symfile_complaints,
3186                      "DIE @ 0x%x \"%s\", type modifier 'const' ignored", DIE_ID,
3187                      DIE_NAME); /* FIXME */
3188           break;
3189         case MOD_volatile:
3190           complaint (&symfile_complaints,
3191                      "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored",
3192                      DIE_ID, DIE_NAME); /* FIXME */
3193           break;
3194         default:
3195           if (!(MOD_lo_user <= (unsigned char) modifier
3196                 && (unsigned char) modifier <= MOD_hi_user))
3197             {
3198               complaint (&symfile_complaints,
3199                          "DIE @ 0x%x \"%s\", unknown type modifier %u", DIE_ID,
3200                          DIE_NAME, modifier);
3201             }
3202           break;
3203         }
3204     }
3205   return (typep);
3206 }
3207
3208 /*
3209
3210    LOCAL FUNCTION
3211
3212    decode_fund_type -- translate basic DWARF type to gdb base type
3213
3214    DESCRIPTION
3215
3216    Given an integer that is one of the fundamental DWARF types,
3217    translate it to one of the basic internal gdb types and return
3218    a pointer to the appropriate gdb type (a "struct type *").
3219
3220    NOTES
3221
3222    For robustness, if we are asked to translate a fundamental
3223    type that we are unprepared to deal with, we return int so
3224    callers can always depend upon a valid type being returned,
3225    and so gdb may at least do something reasonable by default.
3226    If the type is not in the range of those types defined as
3227    application specific types, we also issue a warning.
3228  */
3229
3230 static struct type *
3231 decode_fund_type (unsigned int fundtype)
3232 {
3233   struct type *typep = NULL;
3234
3235   switch (fundtype)
3236     {
3237
3238     case FT_void:
3239       typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3240       break;
3241
3242     case FT_boolean:            /* Was FT_set in AT&T version */
3243       typep = dwarf_fundamental_type (current_objfile, FT_BOOLEAN);
3244       break;
3245
3246     case FT_pointer:            /* (void *) */
3247       typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3248       typep = lookup_pointer_type (typep);
3249       break;
3250
3251     case FT_char:
3252       typep = dwarf_fundamental_type (current_objfile, FT_CHAR);
3253       break;
3254
3255     case FT_signed_char:
3256       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_CHAR);
3257       break;
3258
3259     case FT_unsigned_char:
3260       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
3261       break;
3262
3263     case FT_short:
3264       typep = dwarf_fundamental_type (current_objfile, FT_SHORT);
3265       break;
3266
3267     case FT_signed_short:
3268       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_SHORT);
3269       break;
3270
3271     case FT_unsigned_short:
3272       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
3273       break;
3274
3275     case FT_integer:
3276       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3277       break;
3278
3279     case FT_signed_integer:
3280       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
3281       break;
3282
3283     case FT_unsigned_integer:
3284       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
3285       break;
3286
3287     case FT_long:
3288       typep = dwarf_fundamental_type (current_objfile, FT_LONG);
3289       break;
3290
3291     case FT_signed_long:
3292       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG);
3293       break;
3294
3295     case FT_unsigned_long:
3296       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
3297       break;
3298
3299     case FT_long_long:
3300       typep = dwarf_fundamental_type (current_objfile, FT_LONG_LONG);
3301       break;
3302
3303     case FT_signed_long_long:
3304       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG_LONG);
3305       break;
3306
3307     case FT_unsigned_long_long:
3308       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
3309       break;
3310
3311     case FT_float:
3312       typep = dwarf_fundamental_type (current_objfile, FT_FLOAT);
3313       break;
3314
3315     case FT_dbl_prec_float:
3316       typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
3317       break;
3318
3319     case FT_ext_prec_float:
3320       typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
3321       break;
3322
3323     case FT_complex:
3324       typep = dwarf_fundamental_type (current_objfile, FT_COMPLEX);
3325       break;
3326
3327     case FT_dbl_prec_complex:
3328       typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX);
3329       break;
3330
3331     case FT_ext_prec_complex:
3332       typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_COMPLEX);
3333       break;
3334
3335     }
3336
3337   if (typep == NULL)
3338     {
3339       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3340       if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
3341         {
3342           complaint (&symfile_complaints,
3343                      "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x",
3344                      DIE_ID, DIE_NAME, fundtype);
3345         }
3346     }
3347
3348   return (typep);
3349 }
3350
3351 /*
3352
3353    LOCAL FUNCTION
3354
3355    create_name -- allocate a fresh copy of a string on an obstack
3356
3357    DESCRIPTION
3358
3359    Given a pointer to a string and a pointer to an obstack, allocates
3360    a fresh copy of the string on the specified obstack.
3361
3362  */
3363
3364 static char *
3365 create_name (char *name, struct obstack *obstackp)
3366 {
3367   int length;
3368   char *newname;
3369
3370   length = strlen (name) + 1;
3371   newname = (char *) obstack_alloc (obstackp, length);
3372   strcpy (newname, name);
3373   return (newname);
3374 }
3375
3376 /*
3377
3378    LOCAL FUNCTION
3379
3380    basicdieinfo -- extract the minimal die info from raw die data
3381
3382    SYNOPSIS
3383
3384    void basicdieinfo (char *diep, struct dieinfo *dip,
3385    struct objfile *objfile)
3386
3387    DESCRIPTION
3388
3389    Given a pointer to raw DIE data, and a pointer to an instance of a
3390    die info structure, this function extracts the basic information
3391    from the DIE data required to continue processing this DIE, along
3392    with some bookkeeping information about the DIE.
3393
3394    The information we absolutely must have includes the DIE tag,
3395    and the DIE length.  If we need the sibling reference, then we
3396    will have to call completedieinfo() to process all the remaining
3397    DIE information.
3398
3399    Note that since there is no guarantee that the data is properly
3400    aligned in memory for the type of access required (indirection
3401    through anything other than a char pointer), and there is no
3402    guarantee that it is in the same byte order as the gdb host,
3403    we call a function which deals with both alignment and byte
3404    swapping issues.  Possibly inefficient, but quite portable.
3405
3406    We also take care of some other basic things at this point, such
3407    as ensuring that the instance of the die info structure starts
3408    out completely zero'd and that curdie is initialized for use
3409    in error reporting if we have a problem with the current die.
3410
3411    NOTES
3412
3413    All DIE's must have at least a valid length, thus the minimum
3414    DIE size is SIZEOF_DIE_LENGTH.  In order to have a valid tag, the
3415    DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3416    are forced to be TAG_padding DIES.
3417
3418    Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3419    that if a padding DIE is used for alignment and the amount needed is
3420    less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3421    enough to align to the next alignment boundry.
3422
3423    We do some basic sanity checking here, such as verifying that the
3424    length of the die would not cause it to overrun the recorded end of
3425    the buffer holding the DIE info.  If we find a DIE that is either
3426    too small or too large, we force it's length to zero which should
3427    cause the caller to take appropriate action.
3428  */
3429
3430 static void
3431 basicdieinfo (struct dieinfo *dip, char *diep, struct objfile *objfile)
3432 {
3433   curdie = dip;
3434   memset (dip, 0, sizeof (struct dieinfo));
3435   dip->die = diep;
3436   dip->die_ref = dbroff + (diep - dbbase);
3437   dip->die_length = target_to_host (diep, SIZEOF_DIE_LENGTH, GET_UNSIGNED,
3438                                     objfile);
3439   if ((dip->die_length < SIZEOF_DIE_LENGTH) ||
3440       ((diep + dip->die_length) > (dbbase + dbsize)))
3441     {
3442       complaint (&symfile_complaints,
3443                  "DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)",
3444                  DIE_ID, DIE_NAME, dip->die_length);
3445       dip->die_length = 0;
3446     }
3447   else if (dip->die_length < (SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG))
3448     {
3449       dip->die_tag = TAG_padding;
3450     }
3451   else
3452     {
3453       diep += SIZEOF_DIE_LENGTH;
3454       dip->die_tag = target_to_host (diep, SIZEOF_DIE_TAG, GET_UNSIGNED,
3455                                      objfile);
3456     }
3457 }
3458
3459 /*
3460
3461    LOCAL FUNCTION
3462
3463    completedieinfo -- finish reading the information for a given DIE
3464
3465    SYNOPSIS
3466
3467    void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3468
3469    DESCRIPTION
3470
3471    Given a pointer to an already partially initialized die info structure,
3472    scan the raw DIE data and finish filling in the die info structure
3473    from the various attributes found.
3474
3475    Note that since there is no guarantee that the data is properly
3476    aligned in memory for the type of access required (indirection
3477    through anything other than a char pointer), and there is no
3478    guarantee that it is in the same byte order as the gdb host,
3479    we call a function which deals with both alignment and byte
3480    swapping issues.  Possibly inefficient, but quite portable.
3481
3482    NOTES
3483
3484    Each time we are called, we increment the diecount variable, which
3485    keeps an approximate count of the number of dies processed for
3486    each compilation unit.  This information is presented to the user
3487    if the info_verbose flag is set.
3488
3489  */
3490
3491 static void
3492 completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3493 {
3494   char *diep;                   /* Current pointer into raw DIE data */
3495   char *end;                    /* Terminate DIE scan here */
3496   unsigned short attr;          /* Current attribute being scanned */
3497   unsigned short form;          /* Form of the attribute */
3498   int nbytes;                   /* Size of next field to read */
3499
3500   diecount++;
3501   diep = dip->die;
3502   end = diep + dip->die_length;
3503   diep += SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG;
3504   while (diep < end)
3505     {
3506       attr = target_to_host (diep, SIZEOF_ATTRIBUTE, GET_UNSIGNED, objfile);
3507       diep += SIZEOF_ATTRIBUTE;
3508       nbytes = attribute_size (attr);
3509       if (nbytes == -1)
3510         {
3511           complaint (&symfile_complaints,
3512                      "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes",
3513                      DIE_ID, DIE_NAME);
3514           diep = end;
3515           continue;
3516         }
3517       switch (attr)
3518         {
3519         case AT_fund_type:
3520           dip->at_fund_type = target_to_host (diep, nbytes, GET_UNSIGNED,
3521                                               objfile);
3522           break;
3523         case AT_ordering:
3524           dip->at_ordering = target_to_host (diep, nbytes, GET_UNSIGNED,
3525                                              objfile);
3526           break;
3527         case AT_bit_offset:
3528           dip->at_bit_offset = target_to_host (diep, nbytes, GET_UNSIGNED,
3529                                                objfile);
3530           break;
3531         case AT_sibling:
3532           dip->at_sibling = target_to_host (diep, nbytes, GET_UNSIGNED,
3533                                             objfile);
3534           break;
3535         case AT_stmt_list:
3536           dip->at_stmt_list = target_to_host (diep, nbytes, GET_UNSIGNED,
3537                                               objfile);
3538           dip->has_at_stmt_list = 1;
3539           break;
3540         case AT_low_pc:
3541           dip->at_low_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3542                                            objfile);
3543           dip->at_low_pc += baseaddr;
3544           dip->has_at_low_pc = 1;
3545           break;
3546         case AT_high_pc:
3547           dip->at_high_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3548                                             objfile);
3549           dip->at_high_pc += baseaddr;
3550           break;
3551         case AT_language:
3552           dip->at_language = target_to_host (diep, nbytes, GET_UNSIGNED,
3553                                              objfile);
3554           break;
3555         case AT_user_def_type:
3556           dip->at_user_def_type = target_to_host (diep, nbytes,
3557                                                   GET_UNSIGNED, objfile);
3558           break;
3559         case AT_byte_size:
3560           dip->at_byte_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3561                                               objfile);
3562           dip->has_at_byte_size = 1;
3563           break;
3564         case AT_bit_size:
3565           dip->at_bit_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3566                                              objfile);
3567           break;
3568         case AT_member:
3569           dip->at_member = target_to_host (diep, nbytes, GET_UNSIGNED,
3570                                            objfile);
3571           break;
3572         case AT_discr:
3573           dip->at_discr = target_to_host (diep, nbytes, GET_UNSIGNED,
3574                                           objfile);
3575           break;
3576         case AT_location:
3577           dip->at_location = diep;
3578           break;
3579         case AT_mod_fund_type:
3580           dip->at_mod_fund_type = diep;
3581           break;
3582         case AT_subscr_data:
3583           dip->at_subscr_data = diep;
3584           break;
3585         case AT_mod_u_d_type:
3586           dip->at_mod_u_d_type = diep;
3587           break;
3588         case AT_element_list:
3589           dip->at_element_list = diep;
3590           dip->short_element_list = 0;
3591           break;
3592         case AT_short_element_list:
3593           dip->at_element_list = diep;
3594           dip->short_element_list = 1;
3595           break;
3596         case AT_discr_value:
3597           dip->at_discr_value = diep;
3598           break;
3599         case AT_string_length:
3600           dip->at_string_length = diep;
3601           break;
3602         case AT_name:
3603           dip->at_name = diep;
3604           break;
3605         case AT_comp_dir:
3606           /* For now, ignore any "hostname:" portion, since gdb doesn't
3607              know how to deal with it.  (FIXME). */
3608           dip->at_comp_dir = strrchr (diep, ':');
3609           if (dip->at_comp_dir != NULL)
3610             {
3611               dip->at_comp_dir++;
3612             }
3613           else
3614             {
3615               dip->at_comp_dir = diep;
3616             }
3617           break;
3618         case AT_producer:
3619           dip->at_producer = diep;
3620           break;
3621         case AT_start_scope:
3622           dip->at_start_scope = target_to_host (diep, nbytes, GET_UNSIGNED,
3623                                                 objfile);
3624           break;
3625         case AT_stride_size:
3626           dip->at_stride_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3627                                                 objfile);
3628           break;
3629         case AT_src_info:
3630           dip->at_src_info = target_to_host (diep, nbytes, GET_UNSIGNED,
3631                                              objfile);
3632           break;
3633         case AT_prototyped:
3634           dip->at_prototyped = diep;
3635           break;
3636         default:
3637           /* Found an attribute that we are unprepared to handle.  However
3638              it is specifically one of the design goals of DWARF that
3639              consumers should ignore unknown attributes.  As long as the
3640              form is one that we recognize (so we know how to skip it),
3641              we can just ignore the unknown attribute. */
3642           break;
3643         }
3644       form = FORM_FROM_ATTR (attr);
3645       switch (form)
3646         {
3647         case FORM_DATA2:
3648           diep += 2;
3649           break;
3650         case FORM_DATA4:
3651         case FORM_REF:
3652           diep += 4;
3653           break;
3654         case FORM_DATA8:
3655           diep += 8;
3656           break;
3657         case FORM_ADDR:
3658           diep += TARGET_FT_POINTER_SIZE (objfile);
3659           break;
3660         case FORM_BLOCK2:
3661           diep += 2 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3662           break;
3663         case FORM_BLOCK4:
3664           diep += 4 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3665           break;
3666         case FORM_STRING:
3667           diep += strlen (diep) + 1;
3668           break;
3669         default:
3670           unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
3671           diep = end;
3672           break;
3673         }
3674     }
3675 }
3676
3677 /*
3678
3679    LOCAL FUNCTION
3680
3681    target_to_host -- swap in target data to host
3682
3683    SYNOPSIS
3684
3685    target_to_host (char *from, int nbytes, int signextend,
3686    struct objfile *objfile)
3687
3688    DESCRIPTION
3689
3690    Given pointer to data in target format in FROM, a byte count for
3691    the size of the data in NBYTES, a flag indicating whether or not
3692    the data is signed in SIGNEXTEND, and a pointer to the current
3693    objfile in OBJFILE, convert the data to host format and return
3694    the converted value.
3695
3696    NOTES
3697
3698    FIXME:  If we read data that is known to be signed, and expect to
3699    use it as signed data, then we need to explicitly sign extend the
3700    result until the bfd library is able to do this for us.
3701
3702    FIXME: Would a 32 bit target ever need an 8 byte result?
3703
3704  */
3705
3706 static CORE_ADDR
3707 target_to_host (char *from, int nbytes, int signextend, /* FIXME:  Unused */
3708                 struct objfile *objfile)
3709 {
3710   CORE_ADDR rtnval;
3711
3712   switch (nbytes)
3713     {
3714     case 8:
3715       rtnval = bfd_get_64 (objfile->obfd, (bfd_byte *) from);
3716       break;
3717     case 4:
3718       rtnval = bfd_get_32 (objfile->obfd, (bfd_byte *) from);
3719       break;
3720     case 2:
3721       rtnval = bfd_get_16 (objfile->obfd, (bfd_byte *) from);
3722       break;
3723     case 1:
3724       rtnval = bfd_get_8 (objfile->obfd, (bfd_byte *) from);
3725       break;
3726     default:
3727       complaint (&symfile_complaints,
3728                  "DIE @ 0x%x \"%s\", no bfd support for %d byte data object",
3729                  DIE_ID, DIE_NAME, nbytes);
3730       rtnval = 0;
3731       break;
3732     }
3733   return (rtnval);
3734 }
3735
3736 /*
3737
3738    LOCAL FUNCTION
3739
3740    attribute_size -- compute size of data for a DWARF attribute
3741
3742    SYNOPSIS
3743
3744    static int attribute_size (unsigned int attr)
3745
3746    DESCRIPTION
3747
3748    Given a DWARF attribute in ATTR, compute the size of the first
3749    piece of data associated with this attribute and return that
3750    size.
3751
3752    Returns -1 for unrecognized attributes.
3753
3754  */
3755
3756 static int
3757 attribute_size (unsigned int attr)
3758 {
3759   int nbytes;                   /* Size of next data for this attribute */
3760   unsigned short form;          /* Form of the attribute */
3761
3762   form = FORM_FROM_ATTR (attr);
3763   switch (form)
3764     {
3765     case FORM_STRING:           /* A variable length field is next */
3766       nbytes = 0;
3767       break;
3768     case FORM_DATA2:            /* Next 2 byte field is the data itself */
3769     case FORM_BLOCK2:           /* Next 2 byte field is a block length */
3770       nbytes = 2;
3771       break;
3772     case FORM_DATA4:            /* Next 4 byte field is the data itself */
3773     case FORM_BLOCK4:           /* Next 4 byte field is a block length */
3774     case FORM_REF:              /* Next 4 byte field is a DIE offset */
3775       nbytes = 4;
3776       break;
3777     case FORM_DATA8:            /* Next 8 byte field is the data itself */
3778       nbytes = 8;
3779       break;
3780     case FORM_ADDR:             /* Next field size is target sizeof(void *) */
3781       nbytes = TARGET_FT_POINTER_SIZE (objfile);
3782       break;
3783     default:
3784       unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
3785       nbytes = -1;
3786       break;
3787     }
3788   return (nbytes);
3789 }