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