2003-02-19 David Carlton <carlton@math.stanford.edu>
[external/binutils.git] / gdb / coffread.c
1 /* Read coff symbol tables and convert to internal format, for GDB.
2    Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3    1997, 1998, 1999, 2000, 2001, 2002, 2003
4    Free Software Foundation, Inc.
5    Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 59 Temple Place - Suite 330,
22    Boston, MA 02111-1307, USA.  */
23
24 #include "defs.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "demangle.h"
28 #include "breakpoint.h"
29
30 #include "bfd.h"
31 #include "gdb_obstack.h"
32
33 #include "gdb_string.h"
34 #include <ctype.h>
35
36 #include "coff/internal.h"      /* Internal format of COFF symbols in BFD */
37 #include "libcoff.h"            /* FIXME secret internal data from BFD */
38
39 #include "symfile.h"
40 #include "objfiles.h"
41 #include "buildsym.h"
42 #include "gdb-stabs.h"
43 #include "stabsread.h"
44 #include "complaints.h"
45 #include "target.h"
46 #include "gdb_assert.h"
47 #include "block.h"
48
49 extern void _initialize_coffread (void);
50
51 struct coff_symfile_info
52   {
53     file_ptr min_lineno_offset; /* Where in file lowest line#s are */
54     file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
55
56     CORE_ADDR textaddr;         /* Addr of .text section. */
57     unsigned int textsize;      /* Size of .text section. */
58     struct stab_section_list *stabsects;        /* .stab sections.  */
59     asection *stabstrsect;      /* Section pointer for .stab section */
60     char *stabstrdata;
61   };
62
63 /* Translate an external name string into a user-visible name.  */
64 #define EXTERNAL_NAME(string, abfd) \
65         (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
66
67 /* To be an sdb debug type, type must have at least a basic or primary
68    derived type.  Using this rather than checking against T_NULL is
69    said to prevent core dumps if we try to operate on Michael Bloom
70    dbx-in-coff file.  */
71
72 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
73
74 /* Core address of start and end of text of current source file.
75    This comes from a ".text" symbol where x_nlinno > 0.  */
76
77 static CORE_ADDR current_source_start_addr;
78 static CORE_ADDR current_source_end_addr;
79
80 /* The addresses of the symbol table stream and number of symbols
81    of the object file we are reading (as copied into core).  */
82
83 static bfd *nlist_bfd_global;
84 static int nlist_nsyms_global;
85
86
87 /* Pointers to scratch storage, used for reading raw symbols and auxents.  */
88
89 static char *temp_sym;
90 static char *temp_aux;
91
92 /* Local variables that hold the shift and mask values for the
93    COFF file that we are currently reading.  These come back to us
94    from BFD, and are referenced by their macro names, as well as
95    internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
96    macros from include/coff/internal.h .  */
97
98 static unsigned local_n_btmask;
99 static unsigned local_n_btshft;
100 static unsigned local_n_tmask;
101 static unsigned local_n_tshift;
102
103 #define N_BTMASK        local_n_btmask
104 #define N_BTSHFT        local_n_btshft
105 #define N_TMASK         local_n_tmask
106 #define N_TSHIFT        local_n_tshift
107
108 /* Local variables that hold the sizes in the file of various COFF structures.
109    (We only need to know this to read them from the file -- BFD will then
110    translate the data in them, into `internal_xxx' structs in the right
111    byte order, alignment, etc.)  */
112
113 static unsigned local_linesz;
114 static unsigned local_symesz;
115 static unsigned local_auxesz;
116
117 /* This is set if this is a PE format file.  */
118
119 static int pe_file;
120
121 /* Chain of typedefs of pointers to empty struct/union types.
122    They are chained thru the SYMBOL_VALUE_CHAIN.  */
123
124 static struct symbol *opaque_type_chain[HASHSIZE];
125
126 /* Simplified internal version of coff symbol table information */
127
128 struct coff_symbol
129   {
130     char *c_name;
131     int c_symnum;               /* symbol number of this entry */
132     int c_naux;                 /* 0 if syment only, 1 if syment + auxent, etc */
133     long c_value;
134     int c_sclass;
135     int c_secnum;
136     unsigned int c_type;
137   };
138
139 extern void stabsread_clear_cache (void);
140
141 static struct type *coff_read_struct_type (int, int, int);
142
143 static struct type *decode_base_type (struct coff_symbol *,
144                                       unsigned int, union internal_auxent *);
145
146 static struct type *decode_type (struct coff_symbol *, unsigned int,
147                                  union internal_auxent *);
148
149 static struct type *decode_function_type (struct coff_symbol *,
150                                           unsigned int,
151                                           union internal_auxent *);
152
153 static struct type *coff_read_enum_type (int, int, int);
154
155 static struct symbol *process_coff_symbol (struct coff_symbol *,
156                                            union internal_auxent *,
157                                            struct objfile *);
158
159 static void patch_opaque_types (struct symtab *);
160
161 static void enter_linenos (long, int, int, struct objfile *);
162
163 static void free_linetab (void);
164
165 static void free_linetab_cleanup (void *ignore);
166
167 static int init_lineno (bfd *, long, int);
168
169 static char *getsymname (struct internal_syment *);
170
171 static char *coff_getfilename (union internal_auxent *);
172
173 static void free_stringtab (void);
174
175 static void free_stringtab_cleanup (void *ignore);
176
177 static int init_stringtab (bfd *, long);
178
179 static void read_one_sym (struct coff_symbol *,
180                           struct internal_syment *, union internal_auxent *);
181
182 static void coff_symtab_read (long, unsigned int, struct objfile *);
183 \f
184 /* We are called once per section from coff_symfile_read.  We
185    need to examine each section we are passed, check to see
186    if it is something we are interested in processing, and
187    if so, stash away some access information for the section.
188
189    FIXME: The section names should not be hardwired strings (what
190    should they be?  I don't think most object file formats have enough
191    section flags to specify what kind of debug section it is
192    -kingdon).  */
193
194 static void
195 coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
196 {
197   register struct coff_symfile_info *csi;
198   const char *name;
199
200   csi = (struct coff_symfile_info *) csip;
201   name = bfd_get_section_name (abfd, sectp);
202   if (STREQ (name, ".text"))
203     {
204       csi->textaddr = bfd_section_vma (abfd, sectp);
205       csi->textsize += bfd_section_size (abfd, sectp);
206     }
207   else if (strncmp (name, ".text", sizeof ".text" - 1) == 0)
208     {
209       csi->textsize += bfd_section_size (abfd, sectp);
210     }
211   else if (STREQ (name, ".stabstr"))
212     {
213       csi->stabstrsect = sectp;
214     }
215   else if (strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
216     {
217       const char *s;
218
219       /* We can have multiple .stab sections if linked with
220          --split-by-reloc.  */
221       for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
222         if (!isdigit (*s))
223           break;
224       if (*s == '\0')
225         {
226           struct stab_section_list *n, **pn;
227
228           n = ((struct stab_section_list *)
229                xmalloc (sizeof (struct stab_section_list)));
230           n->section = sectp;
231           n->next = NULL;
232           for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)
233             ;
234           *pn = n;
235
236           /* This will be run after coffstab_build_psymtabs is called
237              in coff_symfile_read, at which point we no longer need
238              the information.  */
239           make_cleanup (xfree, n);
240         }
241     }
242 }
243
244 /* Return the section_offsets* that CS points to.  */
245 static int cs_to_section (struct coff_symbol *, struct objfile *);
246
247 struct find_targ_sec_arg
248   {
249     int targ_index;
250     asection **resultp;
251   };
252
253 static void
254 find_targ_sec (bfd *abfd, asection *sect, void *obj)
255 {
256   struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
257   if (sect->target_index == args->targ_index)
258     *args->resultp = sect;
259 }
260
261 /* Return the section number (SECT_OFF_*) that CS points to.  */
262 static int
263 cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
264 {
265   asection *sect = NULL;
266   struct find_targ_sec_arg args;
267   int off = SECT_OFF_TEXT (objfile);
268
269   args.targ_index = cs->c_secnum;
270   args.resultp = &sect;
271   bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
272   if (sect != NULL)
273     {
274       /* This is the section.  Figure out what SECT_OFF_* code it is.  */
275       if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
276         off = SECT_OFF_TEXT (objfile);
277       else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
278         off = SECT_OFF_DATA (objfile);
279       else
280         /* Just return the bfd section index. */
281         off = sect->index;
282     }
283   return off;
284 }
285
286 /* Return the address of the section of a COFF symbol.  */
287
288 static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);
289
290 static CORE_ADDR
291 cs_section_address (struct coff_symbol *cs, bfd *abfd)
292 {
293   asection *sect = NULL;
294   struct find_targ_sec_arg args;
295   CORE_ADDR addr = 0;
296
297   args.targ_index = cs->c_secnum;
298   args.resultp = &sect;
299   bfd_map_over_sections (abfd, find_targ_sec, &args);
300   if (sect != NULL)
301     addr = bfd_get_section_vma (objfile->obfd, sect);
302   return addr;
303 }
304
305 /* Look up a coff type-number index.  Return the address of the slot
306    where the type for that index is stored.
307    The type-number is in INDEX. 
308
309    This can be used for finding the type associated with that index
310    or for associating a new type with the index.  */
311
312 static struct type **
313 coff_lookup_type (register int index)
314 {
315   if (index >= type_vector_length)
316     {
317       int old_vector_length = type_vector_length;
318
319       type_vector_length *= 2;
320       if (index /* is still */  >= type_vector_length)
321         type_vector_length = index * 2;
322
323       type_vector = (struct type **)
324         xrealloc ((char *) type_vector,
325                   type_vector_length * sizeof (struct type *));
326       memset (&type_vector[old_vector_length], 0,
327          (type_vector_length - old_vector_length) * sizeof (struct type *));
328     }
329   return &type_vector[index];
330 }
331
332 /* Make sure there is a type allocated for type number index
333    and return the type object.
334    This can create an empty (zeroed) type object.  */
335
336 static struct type *
337 coff_alloc_type (int index)
338 {
339   register struct type **type_addr = coff_lookup_type (index);
340   register struct type *type = *type_addr;
341
342   /* If we are referring to a type not known at all yet,
343      allocate an empty type for it.
344      We will fill it in later if we find out how.  */
345   if (type == NULL)
346     {
347       type = alloc_type (current_objfile);
348       *type_addr = type;
349     }
350   return type;
351 }
352 \f
353 /* Start a new symtab for a new source file.
354    This is called when a COFF ".file" symbol is seen;
355    it indicates the start of data for one original source file.  */
356
357 static void
358 coff_start_symtab (char *name)
359 {
360   start_symtab (
361   /* We fill in the filename later.  start_symtab puts
362      this pointer into last_source_file and we put it in
363      subfiles->name, which end_symtab frees; that's why
364      it must be malloc'd.  */
365                  savestring (name, strlen (name)),
366   /* We never know the directory name for COFF.  */
367                  NULL,
368   /* The start address is irrelevant, since we set
369      last_source_start_addr in coff_end_symtab.  */
370                  0);
371   record_debugformat ("COFF");
372 }
373
374 /* Save the vital information from when starting to read a file,
375    for use when closing off the current file.
376    NAME is the file name the symbols came from, START_ADDR is the first
377    text address for the file, and SIZE is the number of bytes of text.  */
378
379 static void
380 complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size)
381 {
382   if (last_source_file != NULL)
383     xfree (last_source_file);
384   last_source_file = savestring (name, strlen (name));
385   current_source_start_addr = start_addr;
386   current_source_end_addr = start_addr + size;
387
388   if (current_objfile->ei.entry_point >= current_source_start_addr &&
389       current_objfile->ei.entry_point < current_source_end_addr)
390     {
391       current_objfile->ei.entry_file_lowpc = current_source_start_addr;
392       current_objfile->ei.entry_file_highpc = current_source_end_addr;
393     }
394 }
395
396 /* Finish the symbol definitions for one main source file,
397    close off all the lexical contexts for that file
398    (creating struct block's for them), then make the
399    struct symtab for that file and put it in the list of all such. */
400
401 static void
402 coff_end_symtab (struct objfile *objfile)
403 {
404   struct symtab *symtab;
405
406   last_source_start_addr = current_source_start_addr;
407
408   symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile));
409
410   if (symtab != NULL)
411     free_named_symtabs (symtab->filename);
412
413   /* Reinitialize for beginning of new file. */
414   last_source_file = NULL;
415 }
416 \f
417 static void
418 record_minimal_symbol (char *name, CORE_ADDR address,
419                        enum minimal_symbol_type type, struct objfile *objfile)
420 {
421   /* We don't want TDESC entry points in the minimal symbol table */
422   if (name[0] == '@')
423     return;
424
425   prim_record_minimal_symbol (name, address, type, objfile);
426 }
427 \f
428 /* coff_symfile_init ()
429    is the coff-specific initialization routine for reading symbols.
430    It is passed a struct objfile which contains, among other things,
431    the BFD for the file whose symbols are being read, and a slot for
432    a pointer to "private data" which we fill with cookies and other
433    treats for coff_symfile_read ().
434
435    We will only be called if this is a COFF or COFF-like file.
436    BFD handles figuring out the format of the file, and code in symtab.c
437    uses BFD's determination to vector to us.
438
439    The ultimate result is a new symtab (or, FIXME, eventually a psymtab).  */
440
441 static void
442 coff_symfile_init (struct objfile *objfile)
443 {
444   /* Allocate struct to keep track of stab reading. */
445   objfile->sym_stab_info = (struct dbx_symfile_info *)
446     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
447
448   memset (objfile->sym_stab_info, 0,
449           sizeof (struct dbx_symfile_info));
450
451   /* Allocate struct to keep track of the symfile */
452   objfile->sym_private = xmmalloc (objfile->md,
453                                    sizeof (struct coff_symfile_info));
454
455   memset (objfile->sym_private, 0, sizeof (struct coff_symfile_info));
456
457   /* COFF objects may be reordered, so set OBJF_REORDERED.  If we
458      find this causes a significant slowdown in gdb then we could
459      set it in the debug symbol readers only when necessary.  */
460   objfile->flags |= OBJF_REORDERED;
461
462   init_entry_point_info (objfile);
463 }
464
465 /* This function is called for every section; it finds the outer limits
466    of the line table (minimum and maximum file offset) so that the
467    mainline code can read the whole thing for efficiency.  */
468
469 /* ARGSUSED */
470 static void
471 find_linenos (bfd *abfd, sec_ptr asect, void *vpinfo)
472 {
473   struct coff_symfile_info *info;
474   int size, count;
475   file_ptr offset, maxoff;
476
477 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
478   count = asect->lineno_count;
479 /* End of warning */
480
481   if (count == 0)
482     return;
483   size = count * local_linesz;
484
485   info = (struct coff_symfile_info *) vpinfo;
486 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
487   offset = asect->line_filepos;
488 /* End of warning */
489
490   if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
491     info->min_lineno_offset = offset;
492
493   maxoff = offset + size;
494   if (maxoff > info->max_lineno_offset)
495     info->max_lineno_offset = maxoff;
496 }
497
498
499 /* The BFD for this file -- only good while we're actively reading
500    symbols into a psymtab or a symtab.  */
501
502 static bfd *symfile_bfd;
503
504 /* Read a symbol file, after initialization by coff_symfile_init.  */
505
506 /* ARGSUSED */
507 static void
508 coff_symfile_read (struct objfile *objfile, int mainline)
509 {
510   struct coff_symfile_info *info;
511   struct dbx_symfile_info *dbxinfo;
512   bfd *abfd = objfile->obfd;
513   coff_data_type *cdata = coff_data (abfd);
514   char *name = bfd_get_filename (abfd);
515   register int val;
516   unsigned int num_symbols;
517   int symtab_offset;
518   int stringtab_offset;
519   struct cleanup *back_to;
520   int stabstrsize;
521   int len;
522   char * target;
523   
524   info = (struct coff_symfile_info *) objfile->sym_private;
525   dbxinfo = objfile->sym_stab_info;
526   symfile_bfd = abfd;           /* Kludge for swap routines */
527
528 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
529   num_symbols = bfd_get_symcount (abfd);        /* How many syms */
530   symtab_offset = cdata->sym_filepos;   /* Symbol table file offset */
531   stringtab_offset = symtab_offset +    /* String table file offset */
532     num_symbols * cdata->local_symesz;
533
534   /* Set a few file-statics that give us specific information about
535      the particular COFF file format we're reading.  */
536   local_n_btmask = cdata->local_n_btmask;
537   local_n_btshft = cdata->local_n_btshft;
538   local_n_tmask = cdata->local_n_tmask;
539   local_n_tshift = cdata->local_n_tshift;
540   local_linesz = cdata->local_linesz;
541   local_symesz = cdata->local_symesz;
542   local_auxesz = cdata->local_auxesz;
543
544   /* Allocate space for raw symbol and aux entries, based on their
545      space requirements as reported by BFD.  */
546   temp_sym = (char *) xmalloc
547     (cdata->local_symesz + cdata->local_auxesz);
548   temp_aux = temp_sym + cdata->local_symesz;
549   back_to = make_cleanup (free_current_contents, &temp_sym);
550
551   /* We need to know whether this is a PE file, because in PE files,
552      unlike standard COFF files, symbol values are stored as offsets
553      from the section address, rather than as absolute addresses.
554      FIXME: We should use BFD to read the symbol table, and thus avoid
555      this problem.  */
556   pe_file =
557     strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0
558     || strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0;
559
560 /* End of warning */
561
562   info->min_lineno_offset = 0;
563   info->max_lineno_offset = 0;
564
565   /* Only read line number information if we have symbols.
566
567      On Windows NT, some of the system's DLL's have sections with
568      PointerToLinenumbers fields that are non-zero, but point at
569      random places within the image file.  (In the case I found,
570      KERNEL32.DLL's .text section has a line number info pointer that
571      points into the middle of the string `lib\\i386\kernel32.dll'.)
572
573      However, these DLL's also have no symbols.  The line number
574      tables are meaningless without symbols.  And in fact, GDB never
575      uses the line number information unless there are symbols.  So we
576      can avoid spurious error messages (and maybe run a little
577      faster!) by not even reading the line number table unless we have
578      symbols.  */
579   if (num_symbols > 0)
580     {
581       /* Read the line number table, all at once.  */
582       bfd_map_over_sections (abfd, find_linenos, (void *) info);
583
584       make_cleanup (free_linetab_cleanup, 0 /*ignore*/);
585       val = init_lineno (abfd, info->min_lineno_offset,
586                          info->max_lineno_offset - info->min_lineno_offset);
587       if (val < 0)
588         error ("\"%s\": error reading line numbers\n", name);
589     }
590
591   /* Now read the string table, all at once.  */
592
593   make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
594   val = init_stringtab (abfd, stringtab_offset);
595   if (val < 0)
596     error ("\"%s\": can't get string table", name);
597
598   init_minimal_symbol_collection ();
599   make_cleanup_discard_minimal_symbols ();
600
601   /* Now that the executable file is positioned at symbol table,
602      process it and define symbols accordingly.  */
603
604   coff_symtab_read ((long) symtab_offset, num_symbols, objfile);
605
606   /* Sort symbols alphabetically within each block.  */
607
608   {
609     struct symtab *s;
610
611     for (s = objfile->symtabs; s != NULL; s = s->next)
612       sort_symtab_syms (s);
613   }
614
615   /* Install any minimal symbols that have been collected as the current
616      minimal symbols for this objfile.  */
617
618   install_minimal_symbols (objfile);
619
620   bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
621
622   if (info->stabsects)
623     {
624       if (!info->stabstrsect)
625         {
626           error (("The debugging information in `%s' is corrupted.\n"
627                   "The file has a `.stabs' section, but no `.stabstr' "
628                   "section."),
629                  name);
630         }
631
632       /* FIXME: dubious.  Why can't we use something normal like
633          bfd_get_section_contents?  */
634       bfd_seek (abfd, abfd->where, 0);
635
636       stabstrsize = bfd_section_size (abfd, info->stabstrsect);
637
638       coffstab_build_psymtabs (objfile,
639                                mainline,
640                                info->textaddr, info->textsize,
641                                info->stabsects,
642                                info->stabstrsect->filepos, stabstrsize);
643     }
644   if (dwarf2_has_info (abfd))
645     {
646       /* DWARF2 sections.  */
647       dwarf2_build_psymtabs (objfile, mainline);
648     }
649
650   do_cleanups (back_to);
651 }
652
653 static void
654 coff_new_init (struct objfile *ignore)
655 {
656 }
657
658 /* Perform any local cleanups required when we are done with a particular
659    objfile.  I.E, we are in the process of discarding all symbol information
660    for an objfile, freeing up all memory held for it, and unlinking the
661    objfile struct from the global list of known objfiles. */
662
663 static void
664 coff_symfile_finish (struct objfile *objfile)
665 {
666   if (objfile->sym_private != NULL)
667     {
668       xmfree (objfile->md, objfile->sym_private);
669     }
670
671   /* Let stabs reader clean up */
672   stabsread_clear_cache ();
673 }
674 \f
675
676 /* Given pointers to a symbol table in coff style exec file,
677    analyze them and create struct symtab's describing the symbols.
678    NSYMS is the number of symbols in the symbol table.
679    We read them one at a time using read_one_sym ().  */
680
681 static void
682 coff_symtab_read (long symtab_offset, unsigned int nsyms,
683                   struct objfile *objfile)
684 {
685   register struct context_stack *new;
686   struct coff_symbol coff_symbol;
687   register struct coff_symbol *cs = &coff_symbol;
688   static struct internal_syment main_sym;
689   static union internal_auxent main_aux;
690   struct coff_symbol fcn_cs_saved;
691   static struct internal_syment fcn_sym_saved;
692   static union internal_auxent fcn_aux_saved;
693   struct symtab *s;
694   /* A .file is open.  */
695   int in_source_file = 0;
696   int next_file_symnum = -1;
697   /* Name of the current file.  */
698   char *filestring = "";
699   int depth = 0;
700   int fcn_first_line = 0;
701   CORE_ADDR fcn_first_line_addr = 0;
702   int fcn_last_line = 0;
703   int fcn_start_addr = 0;
704   long fcn_line_ptr = 0;
705   int val;
706   CORE_ADDR tmpaddr;
707
708   /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
709      it's hard to know I've really worked around it.  The fix should be
710      harmless, anyway).  The symptom of the bug is that the first
711      fread (in read_one_sym), will (in my example) actually get data
712      from file offset 268, when the fseek was to 264 (and ftell shows
713      264).  This causes all hell to break loose.  I was unable to
714      reproduce this on a short test program which operated on the same
715      file, performing (I think) the same sequence of operations.
716
717      It stopped happening when I put in this (former) rewind().
718
719      FIXME: Find out if this has been reported to Sun, whether it has
720      been fixed in a later release, etc.  */
721
722   bfd_seek (objfile->obfd, 0, 0);
723
724   /* Position to read the symbol table. */
725   val = bfd_seek (objfile->obfd, (long) symtab_offset, 0);
726   if (val < 0)
727     perror_with_name (objfile->name);
728
729   current_objfile = objfile;
730   nlist_bfd_global = objfile->obfd;
731   nlist_nsyms_global = nsyms;
732   last_source_file = NULL;
733   memset (opaque_type_chain, 0, sizeof opaque_type_chain);
734
735   if (type_vector)              /* Get rid of previous one */
736     xfree (type_vector);
737   type_vector_length = 160;
738   type_vector = (struct type **)
739     xmalloc (type_vector_length * sizeof (struct type *));
740   memset (type_vector, 0, type_vector_length * sizeof (struct type *));
741
742   coff_start_symtab ("");
743
744   symnum = 0;
745   while (symnum < nsyms)
746     {
747       QUIT;                     /* Make this command interruptable.  */
748
749       read_one_sym (cs, &main_sym, &main_aux);
750
751       if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
752         {
753           if (last_source_file)
754             coff_end_symtab (objfile);
755
756           coff_start_symtab ("_globals_");
757           complete_symtab ("_globals_", 0, 0);
758           /* done with all files, everything from here on out is globals */
759         }
760
761       /* Special case for file with type declarations only, no text.  */
762       if (!last_source_file && SDB_TYPE (cs->c_type)
763           && cs->c_secnum == N_DEBUG)
764         complete_symtab (filestring, 0, 0);
765
766       /* Typedefs should not be treated as symbol definitions.  */
767       if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
768         {
769           /* Record all functions -- external and static -- in minsyms. */
770           tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
771           record_minimal_symbol (cs->c_name, tmpaddr, mst_text, objfile);
772
773           fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
774           fcn_start_addr = tmpaddr;
775           fcn_cs_saved = *cs;
776           fcn_sym_saved = main_sym;
777           fcn_aux_saved = main_aux;
778           continue;
779         }
780
781       switch (cs->c_sclass)
782         {
783         case C_EFCN:
784         case C_EXTDEF:
785         case C_ULABEL:
786         case C_USTATIC:
787         case C_LINE:
788         case C_ALIAS:
789         case C_HIDDEN:
790           complaint (&symfile_complaints, "Bad n_sclass for symbol %s",
791                      cs->c_name);
792           break;
793
794         case C_FILE:
795           /* c_value field contains symnum of next .file entry in table
796              or symnum of first global after last .file.  */
797           next_file_symnum = cs->c_value;
798           if (cs->c_naux > 0)
799             filestring = coff_getfilename (&main_aux);
800           else
801             filestring = "";
802
803           /* Complete symbol table for last object file
804              containing debugging information.  */
805           if (last_source_file)
806             {
807               coff_end_symtab (objfile);
808               coff_start_symtab (filestring);
809             }
810           in_source_file = 1;
811           break;
812
813           /* C_LABEL is used for labels and static functions.  Including
814              it here allows gdb to see static functions when no debug
815              info is available.  */
816         case C_LABEL:
817           /* However, labels within a function can make weird backtraces,
818              so filter them out (from phdm@macqel.be). */
819           if (within_function)
820             break;
821         case C_STAT:
822         case C_THUMBLABEL:
823         case C_THUMBSTAT:
824         case C_THUMBSTATFUNC:
825           if (cs->c_name[0] == '.')
826             {
827               if (STREQ (cs->c_name, ".text"))
828                 {
829                   /* FIXME:  don't wire in ".text" as section name
830                      or symbol name! */
831                   /* Check for in_source_file deals with case of
832                      a file with debugging symbols
833                      followed by a later file with no symbols.  */
834                   if (in_source_file)
835                     complete_symtab (filestring,
836                     cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
837                                      main_aux.x_scn.x_scnlen);
838                   in_source_file = 0;
839                 }
840               /* flush rest of '.' symbols */
841               break;
842             }
843           else if (!SDB_TYPE (cs->c_type)
844                    && cs->c_name[0] == 'L'
845                    && (strncmp (cs->c_name, "LI%", 3) == 0
846                        || strncmp (cs->c_name, "LF%", 3) == 0
847                        || strncmp (cs->c_name, "LC%", 3) == 0
848                        || strncmp (cs->c_name, "LP%", 3) == 0
849                        || strncmp (cs->c_name, "LPB%", 4) == 0
850                        || strncmp (cs->c_name, "LBB%", 4) == 0
851                        || strncmp (cs->c_name, "LBE%", 4) == 0
852                        || strncmp (cs->c_name, "LPBX%", 5) == 0))
853             /* At least on a 3b1, gcc generates swbeg and string labels
854                that look like this.  Ignore them.  */
855             break;
856           /* fall in for static symbols that don't start with '.' */
857         case C_THUMBEXT:
858         case C_THUMBEXTFUNC:
859         case C_EXT:
860           {
861             /* Record it in the minimal symbols regardless of
862                SDB_TYPE.  This parallels what we do for other debug
863                formats, and probably is needed to make
864                print_address_symbolic work right without the (now
865                gone) "set fast-symbolic-addr off" kludge.  */
866
867             /* FIXME: should use mst_abs, and not relocate, if absolute.  */
868             enum minimal_symbol_type ms_type;
869             int sec;
870
871             if (cs->c_secnum == N_UNDEF)
872               {
873                 /* This is a common symbol.  See if the target
874                    environment knows where it has been relocated to.  */
875                 CORE_ADDR reladdr;
876                 if (target_lookup_symbol (cs->c_name, &reladdr))
877                   {
878                     /* Error in lookup; ignore symbol.  */
879                     break;
880                   }
881                 tmpaddr = reladdr;
882                 /* The address has already been relocated; make sure that
883                    objfile_relocate doesn't relocate it again.  */
884                 sec = -2;
885                 ms_type = cs->c_sclass == C_EXT
886                   || cs->c_sclass == C_THUMBEXT ?
887                   mst_bss : mst_file_bss;
888               }
889             else
890               {
891                 sec = cs_to_section (cs, objfile);
892                 tmpaddr = cs->c_value;
893                 if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
894                     || cs->c_sclass == C_THUMBEXT)
895                   tmpaddr += ANOFFSET (objfile->section_offsets, sec);
896
897                 if (sec == SECT_OFF_TEXT (objfile))
898                   {
899                     ms_type =
900                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
901                       || cs->c_sclass == C_THUMBEXT ?
902                       mst_text : mst_file_text;
903                     tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr);
904                   }
905                 else if (sec == SECT_OFF_DATA (objfile))
906                   {
907                     ms_type =
908                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
909                       mst_data : mst_file_data;
910                   }
911                 else if (sec == SECT_OFF_BSS (objfile))
912                   {
913                     ms_type =
914                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
915                       mst_data : mst_file_data;
916                   }
917                 else
918                   ms_type = mst_unknown;
919               }
920
921             if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
922               {
923                 struct minimal_symbol *msym;
924
925                 /* FIXME: cagney/2001-02-01: The nasty (int) -> (long)
926                    -> (void*) cast is to ensure that that the value of
927                    cs->c_sclass can be correctly stored in a void
928                    pointer in MSYMBOL_INFO.  Better solutions
929                    welcome. */
930                 gdb_assert (sizeof (void *) >= sizeof (cs->c_sclass));
931                 msym = prim_record_minimal_symbol_and_info
932                   (cs->c_name, tmpaddr, ms_type, (void *) (long) cs->c_sclass,
933                    sec, NULL, objfile);
934                 if (msym)
935                   COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
936               }
937             if (SDB_TYPE (cs->c_type))
938               {
939                 struct symbol *sym;
940                 sym = process_coff_symbol
941                   (cs, &main_aux, objfile);
942                 SYMBOL_VALUE (sym) = tmpaddr;
943                 SYMBOL_SECTION (sym) = sec;
944               }
945           }
946           break;
947
948         case C_FCN:
949           if (STREQ (cs->c_name, ".bf"))
950             {
951               within_function = 1;
952
953               /* value contains address of first non-init type code */
954               /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
955                  contains line number of '{' } */
956               if (cs->c_naux != 1)
957                 complaint (&symfile_complaints,
958                            "`.bf' symbol %d has no aux entry", cs->c_symnum);
959               fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
960               fcn_first_line_addr = cs->c_value;
961
962               /* Might want to check that locals are 0 and
963                  context_stack_depth is zero, and complain if not.  */
964
965               depth = 0;
966               new = push_context (depth, fcn_start_addr);
967               fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
968               new->name =
969                 process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
970             }
971           else if (STREQ (cs->c_name, ".ef"))
972             {
973               if (!within_function)
974                 error ("Bad coff function information\n");
975               /* the value of .ef is the address of epilogue code;
976                  not useful for gdb.  */
977               /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
978                  contains number of lines to '}' */
979
980               if (context_stack_depth <= 0)
981                 {               /* We attempted to pop an empty context stack */
982                   complaint (&symfile_complaints,
983                              "`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d",
984                              cs->c_symnum);
985                   within_function = 0;
986                   break;
987                 }
988
989               new = pop_context ();
990               /* Stack must be empty now.  */
991               if (context_stack_depth > 0 || new == NULL)
992                 {
993                   complaint (&symfile_complaints,
994                              "Unmatched .ef symbol(s) ignored starting at symnum %d",
995                              cs->c_symnum);
996                   within_function = 0;
997                   break;
998                 }
999               if (cs->c_naux != 1)
1000                 {
1001                   complaint (&symfile_complaints,
1002                              "`.ef' symbol %d has no aux entry", cs->c_symnum);
1003                   fcn_last_line = 0x7FFFFFFF;
1004                 }
1005               else
1006                 {
1007                   fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1008                 }
1009               /* fcn_first_line is the line number of the opening '{'.
1010                  Do not record it - because it would affect gdb's idea
1011                  of the line number of the first statement of the function -
1012                  except for one-line functions, for which it is also the line
1013                  number of all the statements and of the closing '}', and
1014                  for which we do not have any other statement-line-number. */
1015               if (fcn_last_line == 1)
1016                 record_line (current_subfile, fcn_first_line,
1017                              fcn_first_line_addr);
1018               else
1019                 enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
1020                                objfile);
1021
1022               finish_block (new->name, &local_symbols, new->old_blocks,
1023                             new->start_addr,
1024 #if defined (FUNCTION_EPILOGUE_SIZE)
1025               /* This macro should be defined only on
1026                  machines where the
1027                  fcn_aux_saved.x_sym.x_misc.x_fsize
1028                  field is always zero.
1029                  So use the .bf record information that
1030                  points to the epilogue and add the size
1031                  of the epilogue.  */
1032                             cs->c_value
1033                             + FUNCTION_EPILOGUE_SIZE
1034                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1035 #else
1036                             fcn_cs_saved.c_value
1037                             + fcn_aux_saved.x_sym.x_misc.x_fsize
1038                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1039 #endif
1040                             objfile
1041                 );
1042               within_function = 0;
1043             }
1044           break;
1045
1046         case C_BLOCK:
1047           if (STREQ (cs->c_name, ".bb"))
1048             {
1049               tmpaddr = cs->c_value;
1050               tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1051               push_context (++depth, tmpaddr);
1052             }
1053           else if (STREQ (cs->c_name, ".eb"))
1054             {
1055               if (context_stack_depth <= 0)
1056                 {               /* We attempted to pop an empty context stack */
1057                   complaint (&symfile_complaints,
1058                              "`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d",
1059                              cs->c_symnum);
1060                   break;
1061                 }
1062
1063               new = pop_context ();
1064               if (depth-- != new->depth)
1065                 {
1066                   complaint (&symfile_complaints,
1067                              "Mismatched .eb symbol ignored starting at symnum %d",
1068                              symnum);
1069                   break;
1070                 }
1071               if (local_symbols && context_stack_depth > 0)
1072                 {
1073                   tmpaddr =
1074                     cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1075                   /* Make a block for the local symbols within.  */
1076                   finish_block (0, &local_symbols, new->old_blocks,
1077                                 new->start_addr, tmpaddr, objfile);
1078                 }
1079               /* Now pop locals of block just finished.  */
1080               local_symbols = new->locals;
1081             }
1082           break;
1083
1084         default:
1085           process_coff_symbol (cs, &main_aux, objfile);
1086           break;
1087         }
1088     }
1089
1090   if (last_source_file)
1091     coff_end_symtab (objfile);
1092
1093   /* Patch up any opaque types (references to types that are not defined
1094      in the file where they are referenced, e.g. "struct foo *bar").  */
1095   ALL_OBJFILE_SYMTABS (objfile, s)
1096     patch_opaque_types (s);
1097
1098   current_objfile = NULL;
1099 }
1100 \f
1101 /* Routines for reading headers and symbols from executable.  */
1102
1103 /* Read the next symbol, swap it, and return it in both internal_syment
1104    form, and coff_symbol form.  Also return its first auxent, if any,
1105    in internal_auxent form, and skip any other auxents.  */
1106
1107 static void
1108 read_one_sym (register struct coff_symbol *cs,
1109               register struct internal_syment *sym,
1110               register union internal_auxent *aux)
1111 {
1112   int i;
1113
1114   cs->c_symnum = symnum;
1115   bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1116   bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1117   cs->c_naux = sym->n_numaux & 0xff;
1118   if (cs->c_naux >= 1)
1119     {
1120       bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1121       bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
1122                             0, cs->c_naux, (char *) aux);
1123       /* If more than one aux entry, read past it (only the first aux
1124          is important). */
1125       for (i = 1; i < cs->c_naux; i++)
1126         bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1127     }
1128   cs->c_name = getsymname (sym);
1129   cs->c_value = sym->n_value;
1130   cs->c_sclass = (sym->n_sclass & 0xff);
1131   cs->c_secnum = sym->n_scnum;
1132   cs->c_type = (unsigned) sym->n_type;
1133   if (!SDB_TYPE (cs->c_type))
1134     cs->c_type = 0;
1135
1136 #if 0
1137   if (cs->c_sclass & 128)
1138     printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
1139 #endif
1140
1141   symnum += 1 + cs->c_naux;
1142
1143   /* The PE file format stores symbol values as offsets within the
1144      section, rather than as absolute addresses.  We correct that
1145      here, if the symbol has an appropriate storage class.  FIXME: We
1146      should use BFD to read the symbols, rather than duplicating the
1147      work here.  */
1148   if (pe_file)
1149     {
1150       switch (cs->c_sclass)
1151         {
1152         case C_EXT:
1153         case C_THUMBEXT:
1154         case C_THUMBEXTFUNC:
1155         case C_SECTION:
1156         case C_NT_WEAK:
1157         case C_STAT:
1158         case C_THUMBSTAT:
1159         case C_THUMBSTATFUNC:
1160         case C_LABEL:
1161         case C_THUMBLABEL:
1162         case C_BLOCK:
1163         case C_FCN:
1164         case C_EFCN:
1165           if (cs->c_secnum != 0)
1166             cs->c_value += cs_section_address (cs, symfile_bfd);
1167           break;
1168         }
1169     }
1170 }
1171 \f
1172 /* Support for string table handling */
1173
1174 static char *stringtab = NULL;
1175
1176 static int
1177 init_stringtab (bfd *abfd, long offset)
1178 {
1179   long length;
1180   int val;
1181   unsigned char lengthbuf[4];
1182
1183   free_stringtab ();
1184
1185   /* If the file is stripped, the offset might be zero, indicating no
1186      string table.  Just return with `stringtab' set to null. */
1187   if (offset == 0)
1188     return 0;
1189
1190   if (bfd_seek (abfd, offset, 0) < 0)
1191     return -1;
1192
1193   val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1194   length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1195
1196   /* If no string table is needed, then the file may end immediately
1197      after the symbols.  Just return with `stringtab' set to null. */
1198   if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1199     return 0;
1200
1201   stringtab = (char *) xmalloc (length);
1202   /* This is in target format (probably not very useful, and not currently
1203      used), not host format.  */
1204   memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1205   if (length == sizeof length)  /* Empty table -- just the count */
1206     return 0;
1207
1208   val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf,
1209                    abfd);
1210   if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1211     return -1;
1212
1213   return 0;
1214 }
1215
1216 static void
1217 free_stringtab (void)
1218 {
1219   if (stringtab)
1220     xfree (stringtab);
1221   stringtab = NULL;
1222 }
1223
1224 static void
1225 free_stringtab_cleanup (void *ignore)
1226 {
1227   free_stringtab ();
1228 }
1229
1230 static char *
1231 getsymname (struct internal_syment *symbol_entry)
1232 {
1233   static char buffer[SYMNMLEN + 1];
1234   char *result;
1235
1236   if (symbol_entry->_n._n_n._n_zeroes == 0)
1237     {
1238       /* FIXME: Probably should be detecting corrupt symbol files by
1239          seeing whether offset points to within the stringtab.  */
1240       result = stringtab + symbol_entry->_n._n_n._n_offset;
1241     }
1242   else
1243     {
1244       strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1245       buffer[SYMNMLEN] = '\0';
1246       result = buffer;
1247     }
1248   return result;
1249 }
1250
1251 /* Extract the file name from the aux entry of a C_FILE symbol.  Return
1252    only the last component of the name.  Result is in static storage and
1253    is only good for temporary use.  */
1254
1255 static char *
1256 coff_getfilename (union internal_auxent *aux_entry)
1257 {
1258   static char buffer[BUFSIZ];
1259   register char *temp;
1260   char *result;
1261
1262   if (aux_entry->x_file.x_n.x_zeroes == 0)
1263     strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1264   else
1265     {
1266       strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1267       buffer[FILNMLEN] = '\0';
1268     }
1269   result = buffer;
1270
1271   /* FIXME: We should not be throwing away the information about what
1272      directory.  It should go into dirname of the symtab, or some such
1273      place.  */
1274   if ((temp = strrchr (result, '/')) != NULL)
1275     result = temp + 1;
1276   return (result);
1277 }
1278 \f
1279 /* Support for line number handling.  */
1280
1281 static char *linetab = NULL;
1282 static long linetab_offset;
1283 static unsigned long linetab_size;
1284
1285 /* Read in all the line numbers for fast lookups later.  Leave them in
1286    external (unswapped) format in memory; we'll swap them as we enter
1287    them into GDB's data structures.  */
1288
1289 static int
1290 init_lineno (bfd *abfd, long offset, int size)
1291 {
1292   int val;
1293
1294   linetab_offset = offset;
1295   linetab_size = size;
1296
1297   free_linetab ();
1298
1299   if (size == 0)
1300     return 0;
1301
1302   if (bfd_seek (abfd, offset, 0) < 0)
1303     return -1;
1304
1305   /* Allocate the desired table, plus a sentinel */
1306   linetab = (char *) xmalloc (size + local_linesz);
1307
1308   val = bfd_bread (linetab, size, abfd);
1309   if (val != size)
1310     return -1;
1311
1312   /* Terminate it with an all-zero sentinel record */
1313   memset (linetab + size, 0, local_linesz);
1314
1315   return 0;
1316 }
1317
1318 static void
1319 free_linetab (void)
1320 {
1321   if (linetab)
1322     xfree (linetab);
1323   linetab = NULL;
1324 }
1325
1326 static void
1327 free_linetab_cleanup (void *ignore)
1328 {
1329   free_linetab ();
1330 }
1331
1332 #if !defined (L_LNNO32)
1333 #define L_LNNO32(lp) ((lp)->l_lnno)
1334 #endif
1335
1336 static void
1337 enter_linenos (long file_offset, register int first_line,
1338                register int last_line, struct objfile *objfile)
1339 {
1340   register char *rawptr;
1341   struct internal_lineno lptr;
1342
1343   if (!linetab)
1344     return;
1345   if (file_offset < linetab_offset)
1346     {
1347       complaint (&symfile_complaints,
1348                  "Line number pointer %ld lower than start of line numbers",
1349                  file_offset);
1350       if (file_offset > linetab_size)   /* Too big to be an offset? */
1351         return;
1352       file_offset += linetab_offset;    /* Try reading at that linetab offset */
1353     }
1354
1355   rawptr = &linetab[file_offset - linetab_offset];
1356
1357   /* skip first line entry for each function */
1358   rawptr += local_linesz;
1359   /* line numbers start at one for the first line of the function */
1360   first_line--;
1361
1362   for (;;)
1363     {
1364       bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1365       rawptr += local_linesz;
1366       /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1367       if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1368         record_line (current_subfile, first_line + L_LNNO32 (&lptr),
1369                      lptr.l_addr.l_paddr
1370                      + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)));
1371       else
1372         break;
1373     }
1374 }
1375 \f
1376 static void
1377 patch_type (struct type *type, struct type *real_type)
1378 {
1379   register struct type *target = TYPE_TARGET_TYPE (type);
1380   register struct type *real_target = TYPE_TARGET_TYPE (real_type);
1381   int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1382
1383   TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1384   TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1385   TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target, field_size);
1386
1387   memcpy (TYPE_FIELDS (target), TYPE_FIELDS (real_target), field_size);
1388
1389   if (TYPE_NAME (real_target))
1390     {
1391       if (TYPE_NAME (target))
1392         xfree (TYPE_NAME (target));
1393       TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL);
1394     }
1395 }
1396
1397 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1398    so that they can be used to print out opaque data structures properly.  */
1399
1400 static void
1401 patch_opaque_types (struct symtab *s)
1402 {
1403   register struct block *b;
1404   register int i;
1405   register struct symbol *real_sym;
1406
1407   /* Go through the per-file symbols only */
1408   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1409   ALL_BLOCK_SYMBOLS (b, i, real_sym)
1410     {
1411       /* Find completed typedefs to use to fix opaque ones.
1412          Remove syms from the chain when their types are stored,
1413          but search the whole chain, as there may be several syms
1414          from different files with the same name.  */
1415       if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
1416           SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE &&
1417           TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
1418           TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1419         {
1420           register char *name = SYMBOL_NAME (real_sym);
1421           register int hash = hashname (name);
1422           register struct symbol *sym, *prev;
1423
1424           prev = 0;
1425           for (sym = opaque_type_chain[hash]; sym;)
1426             {
1427               if (name[0] == SYMBOL_NAME (sym)[0] &&
1428                   STREQ (name + 1, SYMBOL_NAME (sym) + 1))
1429                 {
1430                   if (prev)
1431                     {
1432                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1433                     }
1434                   else
1435                     {
1436                       opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1437                     }
1438
1439                   patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1440
1441                   if (prev)
1442                     {
1443                       sym = SYMBOL_VALUE_CHAIN (prev);
1444                     }
1445                   else
1446                     {
1447                       sym = opaque_type_chain[hash];
1448                     }
1449                 }
1450               else
1451                 {
1452                   prev = sym;
1453                   sym = SYMBOL_VALUE_CHAIN (sym);
1454                 }
1455             }
1456         }
1457     }
1458 }
1459 \f
1460 static struct symbol *
1461 process_coff_symbol (register struct coff_symbol *cs,
1462                      register union internal_auxent *aux,
1463                      struct objfile *objfile)
1464 {
1465   register struct symbol *sym
1466   = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1467                                      sizeof (struct symbol));
1468   char *name;
1469
1470   memset (sym, 0, sizeof (struct symbol));
1471   name = cs->c_name;
1472   name = EXTERNAL_NAME (name, objfile->obfd);
1473   SYMBOL_LANGUAGE (sym) = language_auto;
1474   SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
1475
1476   /* default assumptions */
1477   SYMBOL_VALUE (sym) = cs->c_value;
1478   SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1479   SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1480
1481   if (ISFCN (cs->c_type))
1482     {
1483       SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1484       SYMBOL_TYPE (sym) =
1485         lookup_function_type (decode_function_type (cs, cs->c_type, aux));
1486
1487       SYMBOL_CLASS (sym) = LOC_BLOCK;
1488       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1489           || cs->c_sclass == C_THUMBSTATFUNC)
1490         add_symbol_to_list (sym, &file_symbols);
1491       else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1492                || cs->c_sclass == C_THUMBEXTFUNC)
1493         add_symbol_to_list (sym, &global_symbols);
1494     }
1495   else
1496     {
1497       SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
1498       switch (cs->c_sclass)
1499         {
1500         case C_NULL:
1501           break;
1502
1503         case C_AUTO:
1504           SYMBOL_CLASS (sym) = LOC_LOCAL;
1505           add_symbol_to_list (sym, &local_symbols);
1506           break;
1507
1508         case C_THUMBEXT:
1509         case C_THUMBEXTFUNC:
1510         case C_EXT:
1511           SYMBOL_CLASS (sym) = LOC_STATIC;
1512           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1513           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1514           add_symbol_to_list (sym, &global_symbols);
1515           break;
1516
1517         case C_THUMBSTAT:
1518         case C_THUMBSTATFUNC:
1519         case C_STAT:
1520           SYMBOL_CLASS (sym) = LOC_STATIC;
1521           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1522           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1523           if (within_function)
1524             {
1525               /* Static symbol of local scope */
1526               add_symbol_to_list (sym, &local_symbols);
1527             }
1528           else
1529             {
1530               /* Static symbol at top level of file */
1531               add_symbol_to_list (sym, &file_symbols);
1532             }
1533           break;
1534
1535 #ifdef C_GLBLREG                /* AMD coff */
1536         case C_GLBLREG:
1537 #endif
1538         case C_REG:
1539           SYMBOL_CLASS (sym) = LOC_REGISTER;
1540           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1541           add_symbol_to_list (sym, &local_symbols);
1542           break;
1543
1544         case C_THUMBLABEL:
1545         case C_LABEL:
1546           break;
1547
1548         case C_ARG:
1549           SYMBOL_CLASS (sym) = LOC_ARG;
1550           add_symbol_to_list (sym, &local_symbols);
1551 #if !defined (BELIEVE_PCC_PROMOTION)
1552           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1553             {
1554               /* If PCC says a parameter is a short or a char,
1555                  aligned on an int boundary, realign it to the
1556                  "little end" of the int.  */
1557               struct type *temptype;
1558               temptype = lookup_fundamental_type (current_objfile,
1559                                                   FT_INTEGER);
1560               if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1561                   && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
1562                   && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
1563                 {
1564                   SYMBOL_VALUE (sym) +=
1565                     TYPE_LENGTH (temptype)
1566                     - TYPE_LENGTH (SYMBOL_TYPE (sym));
1567                 }
1568             }
1569 #endif
1570           break;
1571
1572         case C_REGPARM:
1573           SYMBOL_CLASS (sym) = LOC_REGPARM;
1574           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1575           add_symbol_to_list (sym, &local_symbols);
1576 #if !defined (BELIEVE_PCC_PROMOTION)
1577           /* FIXME:  This should retain the current type, since it's just
1578              a register value.  gnu@adobe, 26Feb93 */
1579           {
1580             /* If PCC says a parameter is a short or a char,
1581                it is really an int.  */
1582             struct type *temptype;
1583             temptype =
1584               lookup_fundamental_type (current_objfile, FT_INTEGER);
1585             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1586                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1587               {
1588                 SYMBOL_TYPE (sym) =
1589                   (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1590                    ? lookup_fundamental_type (current_objfile,
1591                                               FT_UNSIGNED_INTEGER)
1592                    : temptype);
1593               }
1594           }
1595 #endif
1596           break;
1597
1598         case C_TPDEF:
1599           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1600           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1601
1602           /* If type has no name, give it one */
1603           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1604             {
1605               if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1606                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1607                 {
1608                   /* If we are giving a name to a type such as "pointer to
1609                      foo" or "function returning foo", we better not set
1610                      the TYPE_NAME.  If the program contains "typedef char
1611                      *caddr_t;", we don't want all variables of type char
1612                      * to print as caddr_t.  This is not just a
1613                      consequence of GDB's type management; CC and GCC (at
1614                      least through version 2.4) both output variables of
1615                      either type char * or caddr_t with the type
1616                      refering to the C_TPDEF symbol for caddr_t.  If a future
1617                      compiler cleans this up it GDB is not ready for it
1618                      yet, but if it becomes ready we somehow need to
1619                      disable this check (without breaking the PCC/GCC2.4
1620                      case).
1621
1622                      Sigh.
1623
1624                      Fortunately, this check seems not to be necessary
1625                      for anything except pointers or functions.  */
1626                   ;
1627                 }
1628               else
1629                 TYPE_NAME (SYMBOL_TYPE (sym)) =
1630                   concat (SYMBOL_NAME (sym), NULL);
1631             }
1632 #ifdef CXUX_TARGET
1633           /* Ignore vendor section for Harris CX/UX targets. */
1634           else if (cs->c_name[0] == '$')
1635             break;
1636 #endif /* CXUX_TARGET */
1637
1638           /* Keep track of any type which points to empty structured type,
1639              so it can be filled from a definition from another file.  A
1640              simple forward reference (TYPE_CODE_UNDEF) is not an
1641              empty structured type, though; the forward references
1642              work themselves out via the magic of coff_lookup_type.  */
1643           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
1644               TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
1645               TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
1646               TYPE_CODE_UNDEF)
1647             {
1648               register int i = hashname (SYMBOL_NAME (sym));
1649
1650               SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1651               opaque_type_chain[i] = sym;
1652             }
1653           add_symbol_to_list (sym, &file_symbols);
1654           break;
1655
1656         case C_STRTAG:
1657         case C_UNTAG:
1658         case C_ENTAG:
1659           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1660           SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
1661
1662           /* Some compilers try to be helpful by inventing "fake"
1663              names for anonymous enums, structures, and unions, like
1664              "~0fake" or ".0fake".  Thanks, but no thanks... */
1665           if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1666             if (SYMBOL_NAME (sym) != NULL
1667                 && *SYMBOL_NAME (sym) != '~'
1668                 && *SYMBOL_NAME (sym) != '.')
1669               TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1670                 concat (SYMBOL_NAME (sym), NULL);
1671
1672           add_symbol_to_list (sym, &file_symbols);
1673           break;
1674
1675         default:
1676           break;
1677         }
1678     }
1679   return sym;
1680 }
1681 \f
1682 /* Decode a coff type specifier;  return the type that is meant.  */
1683
1684 static struct type *
1685 decode_type (register struct coff_symbol *cs, unsigned int c_type,
1686              register union internal_auxent *aux)
1687 {
1688   register struct type *type = 0;
1689   unsigned int new_c_type;
1690
1691   if (c_type & ~N_BTMASK)
1692     {
1693       new_c_type = DECREF (c_type);
1694       if (ISPTR (c_type))
1695         {
1696           type = decode_type (cs, new_c_type, aux);
1697           type = lookup_pointer_type (type);
1698         }
1699       else if (ISFCN (c_type))
1700         {
1701           type = decode_type (cs, new_c_type, aux);
1702           type = lookup_function_type (type);
1703         }
1704       else if (ISARY (c_type))
1705         {
1706           int i, n;
1707           register unsigned short *dim;
1708           struct type *base_type, *index_type, *range_type;
1709
1710           /* Define an array type.  */
1711           /* auxent refers to array, not base type */
1712           if (aux->x_sym.x_tagndx.l == 0)
1713             cs->c_naux = 0;
1714
1715           /* shift the indices down */
1716           dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1717           i = 1;
1718           n = dim[0];
1719           for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1720             *dim = *(dim + 1);
1721           *dim = 0;
1722
1723           base_type = decode_type (cs, new_c_type, aux);
1724           index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
1725           range_type =
1726             create_range_type ((struct type *) NULL, index_type, 0, n - 1);
1727           type =
1728             create_array_type ((struct type *) NULL, base_type, range_type);
1729         }
1730       return type;
1731     }
1732
1733   /* Reference to existing type.  This only occurs with the
1734      struct, union, and enum types.  EPI a29k coff
1735      fakes us out by producing aux entries with a nonzero
1736      x_tagndx for definitions of structs, unions, and enums, so we
1737      have to check the c_sclass field.  SCO 3.2v4 cc gets confused
1738      with pointers to pointers to defined structs, and generates
1739      negative x_tagndx fields.  */
1740   if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1741     {
1742       if (cs->c_sclass != C_STRTAG
1743           && cs->c_sclass != C_UNTAG
1744           && cs->c_sclass != C_ENTAG
1745           && aux->x_sym.x_tagndx.l >= 0)
1746         {
1747           type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1748           return type;
1749         }
1750       else
1751         {
1752           complaint (&symfile_complaints,
1753                      "Symbol table entry for %s has bad tagndx value",
1754                      cs->c_name);
1755           /* And fall through to decode_base_type... */
1756         }
1757     }
1758
1759   return decode_base_type (cs, BTYPE (c_type), aux);
1760 }
1761
1762 /* Decode a coff type specifier for function definition;
1763    return the type that the function returns.  */
1764
1765 static struct type *
1766 decode_function_type (register struct coff_symbol *cs, unsigned int c_type,
1767                       register union internal_auxent *aux)
1768 {
1769   if (aux->x_sym.x_tagndx.l == 0)
1770     cs->c_naux = 0;             /* auxent refers to function, not base type */
1771
1772   return decode_type (cs, DECREF (c_type), aux);
1773 }
1774 \f
1775 /* basic C types */
1776
1777 static struct type *
1778 decode_base_type (register struct coff_symbol *cs, unsigned int c_type,
1779                   register union internal_auxent *aux)
1780 {
1781   struct type *type;
1782
1783   switch (c_type)
1784     {
1785     case T_NULL:
1786       /* shows up with "void (*foo)();" structure members */
1787       return lookup_fundamental_type (current_objfile, FT_VOID);
1788
1789 #if 0
1790 /* DGUX actually defines both T_ARG and T_VOID to the same value.  */
1791 #ifdef T_ARG
1792     case T_ARG:
1793       /* Shows up in DGUX, I think.  Not sure where.  */
1794       return lookup_fundamental_type (current_objfile, FT_VOID);        /* shouldn't show up here */
1795 #endif
1796 #endif /* 0 */
1797
1798 #ifdef T_VOID
1799     case T_VOID:
1800       /* Intel 960 COFF has this symbol and meaning.  */
1801       return lookup_fundamental_type (current_objfile, FT_VOID);
1802 #endif
1803
1804     case T_CHAR:
1805       return lookup_fundamental_type (current_objfile, FT_CHAR);
1806
1807     case T_SHORT:
1808       return lookup_fundamental_type (current_objfile, FT_SHORT);
1809
1810     case T_INT:
1811       return lookup_fundamental_type (current_objfile, FT_INTEGER);
1812
1813     case T_LONG:
1814       if (cs->c_sclass == C_FIELD
1815           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1816         return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
1817       else
1818         return lookup_fundamental_type (current_objfile, FT_LONG);
1819
1820     case T_FLOAT:
1821       return lookup_fundamental_type (current_objfile, FT_FLOAT);
1822
1823     case T_DOUBLE:
1824       return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
1825
1826     case T_LNGDBL:
1827       return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
1828
1829     case T_STRUCT:
1830       if (cs->c_naux != 1)
1831         {
1832           /* anonymous structure type */
1833           type = coff_alloc_type (cs->c_symnum);
1834           TYPE_CODE (type) = TYPE_CODE_STRUCT;
1835           TYPE_NAME (type) = NULL;
1836           /* This used to set the tag to "<opaque>".  But I think setting it
1837              to NULL is right, and the printing code can print it as
1838              "struct {...}".  */
1839           TYPE_TAG_NAME (type) = NULL;
1840           INIT_CPLUS_SPECIFIC (type);
1841           TYPE_LENGTH (type) = 0;
1842           TYPE_FIELDS (type) = 0;
1843           TYPE_NFIELDS (type) = 0;
1844         }
1845       else
1846         {
1847           type = coff_read_struct_type (cs->c_symnum,
1848                                         aux->x_sym.x_misc.x_lnsz.x_size,
1849                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1850         }
1851       return type;
1852
1853     case T_UNION:
1854       if (cs->c_naux != 1)
1855         {
1856           /* anonymous union type */
1857           type = coff_alloc_type (cs->c_symnum);
1858           TYPE_NAME (type) = NULL;
1859           /* This used to set the tag to "<opaque>".  But I think setting it
1860              to NULL is right, and the printing code can print it as
1861              "union {...}".  */
1862           TYPE_TAG_NAME (type) = NULL;
1863           INIT_CPLUS_SPECIFIC (type);
1864           TYPE_LENGTH (type) = 0;
1865           TYPE_FIELDS (type) = 0;
1866           TYPE_NFIELDS (type) = 0;
1867         }
1868       else
1869         {
1870           type = coff_read_struct_type (cs->c_symnum,
1871                                         aux->x_sym.x_misc.x_lnsz.x_size,
1872                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1873         }
1874       TYPE_CODE (type) = TYPE_CODE_UNION;
1875       return type;
1876
1877     case T_ENUM:
1878       if (cs->c_naux != 1)
1879         {
1880           /* anonymous enum type */
1881           type = coff_alloc_type (cs->c_symnum);
1882           TYPE_CODE (type) = TYPE_CODE_ENUM;
1883           TYPE_NAME (type) = NULL;
1884           /* This used to set the tag to "<opaque>".  But I think setting it
1885              to NULL is right, and the printing code can print it as
1886              "enum {...}".  */
1887           TYPE_TAG_NAME (type) = NULL;
1888           TYPE_LENGTH (type) = 0;
1889           TYPE_FIELDS (type) = 0;
1890           TYPE_NFIELDS (type) = 0;
1891         }
1892       else
1893         {
1894           type = coff_read_enum_type (cs->c_symnum,
1895                                       aux->x_sym.x_misc.x_lnsz.x_size,
1896                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1897         }
1898       return type;
1899
1900     case T_MOE:
1901       /* shouldn't show up here */
1902       break;
1903
1904     case T_UCHAR:
1905       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
1906
1907     case T_USHORT:
1908       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
1909
1910     case T_UINT:
1911       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
1912
1913     case T_ULONG:
1914       if (cs->c_sclass == C_FIELD
1915           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1916         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
1917       else
1918         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
1919     }
1920   complaint (&symfile_complaints, "Unexpected type for symbol %s", cs->c_name);
1921   return lookup_fundamental_type (current_objfile, FT_VOID);
1922 }
1923 \f
1924 /* This page contains subroutines of read_type.  */
1925
1926 /* Read the description of a structure (or union type) and return an
1927    object describing the type.  */
1928
1929 static struct type *
1930 coff_read_struct_type (int index, int length, int lastsym)
1931 {
1932   struct nextfield
1933     {
1934       struct nextfield *next;
1935       struct field field;
1936     };
1937
1938   register struct type *type;
1939   register struct nextfield *list = 0;
1940   struct nextfield *new;
1941   int nfields = 0;
1942   register int n;
1943   char *name;
1944   struct coff_symbol member_sym;
1945   register struct coff_symbol *ms = &member_sym;
1946   struct internal_syment sub_sym;
1947   union internal_auxent sub_aux;
1948   int done = 0;
1949
1950   type = coff_alloc_type (index);
1951   TYPE_CODE (type) = TYPE_CODE_STRUCT;
1952   INIT_CPLUS_SPECIFIC (type);
1953   TYPE_LENGTH (type) = length;
1954
1955   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
1956     {
1957       read_one_sym (ms, &sub_sym, &sub_aux);
1958       name = ms->c_name;
1959       name = EXTERNAL_NAME (name, current_objfile->obfd);
1960
1961       switch (ms->c_sclass)
1962         {
1963         case C_MOS:
1964         case C_MOU:
1965
1966           /* Get space to record the next field's data.  */
1967           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1968           new->next = list;
1969           list = new;
1970
1971           /* Save the data.  */
1972           list->field.name =
1973             obsavestring (name,
1974                           strlen (name),
1975                           &current_objfile->symbol_obstack);
1976           FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1977           FIELD_BITPOS (list->field) = 8 * ms->c_value;
1978           FIELD_BITSIZE (list->field) = 0;
1979           FIELD_STATIC_KIND (list->field) = 0;
1980           nfields++;
1981           break;
1982
1983         case C_FIELD:
1984
1985           /* Get space to record the next field's data.  */
1986           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1987           new->next = list;
1988           list = new;
1989
1990           /* Save the data.  */
1991           list->field.name =
1992             obsavestring (name,
1993                           strlen (name),
1994                           &current_objfile->symbol_obstack);
1995           FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1996           FIELD_BITPOS (list->field) = ms->c_value;
1997           FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
1998           FIELD_STATIC_KIND (list->field) = 0;
1999           nfields++;
2000           break;
2001
2002         case C_EOS:
2003           done = 1;
2004           break;
2005         }
2006     }
2007   /* Now create the vector of fields, and record how big it is.  */
2008
2009   TYPE_NFIELDS (type) = nfields;
2010   TYPE_FIELDS (type) = (struct field *)
2011     TYPE_ALLOC (type, sizeof (struct field) * nfields);
2012
2013   /* Copy the saved-up fields into the field vector.  */
2014
2015   for (n = nfields; list; list = list->next)
2016     TYPE_FIELD (type, --n) = list->field;
2017
2018   return type;
2019 }
2020 \f
2021 /* Read a definition of an enumeration type,
2022    and create and return a suitable type object.
2023    Also defines the symbols that represent the values of the type.  */
2024
2025 /* ARGSUSED */
2026 static struct type *
2027 coff_read_enum_type (int index, int length, int lastsym)
2028 {
2029   register struct symbol *sym;
2030   register struct type *type;
2031   int nsyms = 0;
2032   int done = 0;
2033   struct pending **symlist;
2034   struct coff_symbol member_sym;
2035   register struct coff_symbol *ms = &member_sym;
2036   struct internal_syment sub_sym;
2037   union internal_auxent sub_aux;
2038   struct pending *osyms, *syms;
2039   int o_nsyms;
2040   register int n;
2041   char *name;
2042   int unsigned_enum = 1;
2043
2044   type = coff_alloc_type (index);
2045   if (within_function)
2046     symlist = &local_symbols;
2047   else
2048     symlist = &file_symbols;
2049   osyms = *symlist;
2050   o_nsyms = osyms ? osyms->nsyms : 0;
2051
2052   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2053     {
2054       read_one_sym (ms, &sub_sym, &sub_aux);
2055       name = ms->c_name;
2056       name = EXTERNAL_NAME (name, current_objfile->obfd);
2057
2058       switch (ms->c_sclass)
2059         {
2060         case C_MOE:
2061           sym = (struct symbol *) obstack_alloc
2062             (&current_objfile->symbol_obstack,
2063              sizeof (struct symbol));
2064           memset (sym, 0, sizeof (struct symbol));
2065
2066           SYMBOL_NAME (sym) =
2067             obsavestring (name, strlen (name),
2068                           &current_objfile->symbol_obstack);
2069           SYMBOL_CLASS (sym) = LOC_CONST;
2070           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2071           SYMBOL_VALUE (sym) = ms->c_value;
2072           add_symbol_to_list (sym, symlist);
2073           nsyms++;
2074           break;
2075
2076         case C_EOS:
2077           /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2078              up the count of how many symbols to read.  So stop
2079              on .eos.  */
2080           done = 1;
2081           break;
2082         }
2083     }
2084
2085   /* Now fill in the fields of the type-structure.  */
2086
2087   if (length > 0)
2088     TYPE_LENGTH (type) = length;
2089   else
2090     TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;      /* Assume ints */
2091   TYPE_CODE (type) = TYPE_CODE_ENUM;
2092   TYPE_NFIELDS (type) = nsyms;
2093   TYPE_FIELDS (type) = (struct field *)
2094     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2095
2096   /* Find the symbols for the values and put them into the type.
2097      The symbols can be found in the symlist that we put them on
2098      to cause them to be defined.  osyms contains the old value
2099      of that symlist; everything up to there was defined by us.  */
2100   /* Note that we preserve the order of the enum constants, so
2101      that in something like "enum {FOO, LAST_THING=FOO}" we print
2102      FOO, not LAST_THING.  */
2103
2104   for (syms = *symlist, n = 0; syms; syms = syms->next)
2105     {
2106       int j = 0;
2107
2108       if (syms == osyms)
2109         j = o_nsyms;
2110       for (; j < syms->nsyms; j++, n++)
2111         {
2112           struct symbol *xsym = syms->symbol[j];
2113           SYMBOL_TYPE (xsym) = type;
2114           TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
2115           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
2116           if (SYMBOL_VALUE (xsym) < 0)
2117             unsigned_enum = 0;
2118           TYPE_FIELD_BITSIZE (type, n) = 0;
2119           TYPE_FIELD_STATIC_KIND (type, n) = 0;
2120         }
2121       if (syms == osyms)
2122         break;
2123     }
2124
2125   if (unsigned_enum)
2126     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
2127
2128   return type;
2129 }
2130
2131 /* Register our ability to parse symbols for coff BFD files. */
2132
2133 static struct sym_fns coff_sym_fns =
2134 {
2135   bfd_target_coff_flavour,
2136   coff_new_init,                /* sym_new_init: init anything gbl to entire symtab */
2137   coff_symfile_init,            /* sym_init: read initial info, setup for sym_read() */
2138   coff_symfile_read,            /* sym_read: read a symbol file into symtab */
2139   coff_symfile_finish,          /* sym_finish: finished with file, cleanup */
2140   default_symfile_offsets,      /* sym_offsets:  xlate external to internal form */
2141   NULL                          /* next: pointer to next struct sym_fns */
2142 };
2143
2144 void
2145 _initialize_coffread (void)
2146 {
2147   add_symtab_fns (&coff_sym_fns);
2148 }