gdb/coffread.c

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