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