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