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