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             enum minimal_symbol_type ms_type;
 873             int sec;
 874
 875             if (cs->c_secnum == N_UNDEF)
 876               {
 877                 /* This is a common symbol.  See if the target
 878                    environment knows where it has been relocated to.  */
 879                 CORE_ADDR reladdr;
 880                 if (target_lookup_symbol (cs->c_name, &reladdr))
 881                   {
 882                     /* Error in lookup; ignore symbol.  */
 883                     break;
 884                   }
 885                 tmpaddr = reladdr;
 886                 /* The address has already been relocated; make sure that
 887                    objfile_relocate doesn't relocate it again.  */
 888                 sec = -2;
 889                 ms_type = cs->c_sclass == C_EXT
 890                   || cs->c_sclass == C_THUMBEXT ?
 891                   mst_bss : mst_file_bss;
 892               }
 893             else if (cs->c_secnum == N_ABS)
 894               {
 895                 /* Use the correct minimal symbol type (and don't
 896                    relocate) for absolute values. */
 897                 ms_type = mst_abs;
 898                 sec = cs_to_section (cs, objfile);
 899                 tmpaddr = cs->c_value;
 900               }
 901             else
 902               {
 903                 sec = cs_to_section (cs, objfile);
 904                 tmpaddr = cs->c_value;
 905                 /* Statics in a PE file also get relocated */
 906                 if (cs->c_sclass == C_EXT
 907                     || cs->c_sclass == C_THUMBEXTFUNC
 908                     || cs->c_sclass == C_THUMBEXT
 909                     || (pe_file && (cs->c_sclass == C_STAT)))
 910                   tmpaddr += ANOFFSET (objfile->section_offsets, sec);
 911
 912                 if (sec == SECT_OFF_TEXT (objfile))
 913                   {
 914                     ms_type =
 915                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
 916                       || cs->c_sclass == C_THUMBEXT ?
 917                       mst_text : mst_file_text;
 918                     tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr);
 919                   }
 920                 else if (sec == SECT_OFF_DATA (objfile))
 921                   {
 922                     ms_type =
 923                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
 924                       mst_data : mst_file_data;
 925                   }
 926                 else if (sec == SECT_OFF_BSS (objfile))
 927                   {
 928                     ms_type =
 929                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
 930                       mst_data : mst_file_data;
 931                   }
 932                 else
 933                   ms_type = mst_unknown;
 934               }
 935
 936             if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
 937               {
 938                 struct minimal_symbol *msym;
 939
 940                 /* FIXME: cagney/2001-02-01: The nasty (int) -> (long)
 941                    -> (void*) cast is to ensure that that the value of
 942                    cs->c_sclass can be correctly stored in a void
 943                    pointer in MSYMBOL_INFO.  Better solutions
 944                    welcome. */
 945                 gdb_assert (sizeof (void *) >= sizeof (cs->c_sclass));
 946                 msym = prim_record_minimal_symbol_and_info
 947                   (cs->c_name, tmpaddr, ms_type, (void *) (long) cs->c_sclass,
 948                    sec, NULL, objfile);
 949                 if (msym)
 950                   COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
 951               }
 952             if (SDB_TYPE (cs->c_type))
 953               {
 954                 struct symbol *sym;
 955                 sym = process_coff_symbol
 956                   (cs, &main_aux, objfile);
 957                 SYMBOL_VALUE (sym) = tmpaddr;
 958                 SYMBOL_SECTION (sym) = sec;
 959               }
 960           }
 961           break;
 962
 963         case C_FCN:
 964           if (STREQ (cs->c_name, ".bf"))
 965             {
 966               within_function = 1;
 967
 968               /* value contains address of first non-init type code */
 969               /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
 970                  contains line number of '{' } */
 971               if (cs->c_naux != 1)
 972                 complaint (&symfile_complaints,
 973                            "`.bf' symbol %d has no aux entry", cs->c_symnum);
 974               fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
 975               fcn_first_line_addr = cs->c_value;
 976
 977               /* Might want to check that locals are 0 and
 978                  context_stack_depth is zero, and complain if not.  */
 979
 980               depth = 0;
 981               new = push_context (depth, fcn_start_addr);
 982               fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
 983               new->name =
 984                 process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
 985             }
 986           else if (STREQ (cs->c_name, ".ef"))
 987             {
 988               if (!within_function)
 989                 error ("Bad coff function information\n");
 990               /* the value of .ef is the address of epilogue code;
 991                  not useful for gdb.  */
 992               /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
 993                  contains number of lines to '}' */
 994
 995               if (context_stack_depth <= 0)
 996                 {               /* We attempted to pop an empty context stack */
 997                   complaint (&symfile_complaints,
 998                              "`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d",
 999                              cs->c_symnum);
1000                   within_function = 0;
1001                   break;
1002                 }
1003
1004               new = pop_context ();
1005               /* Stack must be empty now.  */
1006               if (context_stack_depth > 0 || new == NULL)
1007                 {
1008                   complaint (&symfile_complaints,
1009                              "Unmatched .ef symbol(s) ignored starting at symnum %d",
1010                              cs->c_symnum);
1011                   within_function = 0;
1012                   break;
1013                 }
1014               if (cs->c_naux != 1)
1015                 {
1016                   complaint (&symfile_complaints,
1017                              "`.ef' symbol %d has no aux entry", cs->c_symnum);
1018                   fcn_last_line = 0x7FFFFFFF;
1019                 }
1020               else
1021                 {
1022                   fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1023                 }
1024               /* fcn_first_line is the line number of the opening '{'.
1025                  Do not record it - because it would affect gdb's idea
1026                  of the line number of the first statement of the function -
1027                  except for one-line functions, for which it is also the line
1028                  number of all the statements and of the closing '}', and
1029                  for which we do not have any other statement-line-number. */
1030               if (fcn_last_line == 1)
1031                 record_line (current_subfile, fcn_first_line,
1032                              fcn_first_line_addr);
1033               else
1034                 enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
1035                                objfile);
1036
1037               finish_block (new->name, &local_symbols, new->old_blocks,
1038                             new->start_addr,
1039 #if defined (FUNCTION_EPILOGUE_SIZE)
1040               /* This macro should be defined only on
1041                  machines where the
1042                  fcn_aux_saved.x_sym.x_misc.x_fsize
1043                  field is always zero.
1044                  So use the .bf record information that
1045                  points to the epilogue and add the size
1046                  of the epilogue.  */
1047                             cs->c_value
1048                             + FUNCTION_EPILOGUE_SIZE
1049                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1050 #else
1051                             fcn_cs_saved.c_value
1052                             + fcn_aux_saved.x_sym.x_misc.x_fsize
1053                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1054 #endif
1055                             objfile
1056                 );
1057               within_function = 0;
1058             }
1059           break;
1060
1061         case C_BLOCK:
1062           if (STREQ (cs->c_name, ".bb"))
1063             {
1064               tmpaddr = cs->c_value;
1065               tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1066               push_context (++depth, tmpaddr);
1067             }
1068           else if (STREQ (cs->c_name, ".eb"))
1069             {
1070               if (context_stack_depth <= 0)
1071                 {               /* We attempted to pop an empty context stack */
1072                   complaint (&symfile_complaints,
1073                              "`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d",
1074                              cs->c_symnum);
1075                   break;
1076                 }
1077
1078               new = pop_context ();
1079               if (depth-- != new->depth)
1080                 {
1081                   complaint (&symfile_complaints,
1082                              "Mismatched .eb symbol ignored starting at symnum %d",
1083                              symnum);
1084                   break;
1085                 }
1086               if (local_symbols && context_stack_depth > 0)
1087                 {
1088                   tmpaddr =
1089                     cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1090                   /* Make a block for the local symbols within.  */
1091                   finish_block (0, &local_symbols, new->old_blocks,
1092                                 new->start_addr, tmpaddr, objfile);
1093                 }
1094               /* Now pop locals of block just finished.  */
1095               local_symbols = new->locals;
1096             }
1097           break;
1098
1099         default:
1100           process_coff_symbol (cs, &main_aux, objfile);
1101           break;
1102         }
1103     }
1104
1105   if ((nsyms == 0) && (pe_file))
1106     {
1107       /* We've got no debugging symbols, but it's is a portable
1108          executable, so try to read the export table */
1109       read_pe_exported_syms (objfile);
1110     }
1111
1112   if (last_source_file)
1113     coff_end_symtab (objfile);
1114
1115   /* Patch up any opaque types (references to types that are not defined
1116      in the file where they are referenced, e.g. "struct foo *bar").  */
1117   ALL_OBJFILE_SYMTABS (objfile, s)
1118     patch_opaque_types (s);
1119
1120   current_objfile = NULL;
1121 }
1122 \f
1123 /* Routines for reading headers and symbols from executable.  */
1124
1125 /* Read the next symbol, swap it, and return it in both internal_syment
1126    form, and coff_symbol form.  Also return its first auxent, if any,
1127    in internal_auxent form, and skip any other auxents.  */
1128
1129 static void
1130 read_one_sym (register struct coff_symbol *cs,
1131               register struct internal_syment *sym,
1132               register union internal_auxent *aux)
1133 {
1134   int i;
1135
1136   cs->c_symnum = symnum;
1137   bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1138   bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1139   cs->c_naux = sym->n_numaux & 0xff;
1140   if (cs->c_naux >= 1)
1141     {
1142       bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1143       bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
1144                             0, cs->c_naux, (char *) aux);
1145       /* If more than one aux entry, read past it (only the first aux
1146          is important). */
1147       for (i = 1; i < cs->c_naux; i++)
1148         bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1149     }
1150   cs->c_name = getsymname (sym);
1151   cs->c_value = sym->n_value;
1152   cs->c_sclass = (sym->n_sclass & 0xff);
1153   cs->c_secnum = sym->n_scnum;
1154   cs->c_type = (unsigned) sym->n_type;
1155   if (!SDB_TYPE (cs->c_type))
1156     cs->c_type = 0;
1157
1158 #if 0
1159   if (cs->c_sclass & 128)
1160     printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
1161 #endif
1162
1163   symnum += 1 + cs->c_naux;
1164
1165   /* The PE file format stores symbol values as offsets within the
1166      section, rather than as absolute addresses.  We correct that
1167      here, if the symbol has an appropriate storage class.  FIXME: We
1168      should use BFD to read the symbols, rather than duplicating the
1169      work here.  */
1170   if (pe_file)
1171     {
1172       switch (cs->c_sclass)
1173         {
1174         case C_EXT:
1175         case C_THUMBEXT:
1176         case C_THUMBEXTFUNC:
1177         case C_SECTION:
1178         case C_NT_WEAK:
1179         case C_STAT:
1180         case C_THUMBSTAT:
1181         case C_THUMBSTATFUNC:
1182         case C_LABEL:
1183         case C_THUMBLABEL:
1184         case C_BLOCK:
1185         case C_FCN:
1186         case C_EFCN:
1187           if (cs->c_secnum != 0)
1188             cs->c_value += cs_section_address (cs, symfile_bfd);
1189           break;
1190         }
1191     }
1192 }
1193 \f
1194 /* Support for string table handling */
1195
1196 static char *stringtab = NULL;
1197
1198 static int
1199 init_stringtab (bfd *abfd, long offset)
1200 {
1201   long length;
1202   int val;
1203   unsigned char lengthbuf[4];
1204
1205   free_stringtab ();
1206
1207   /* If the file is stripped, the offset might be zero, indicating no
1208      string table.  Just return with `stringtab' set to null. */
1209   if (offset == 0)
1210     return 0;
1211
1212   if (bfd_seek (abfd, offset, 0) < 0)
1213     return -1;
1214
1215   val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1216   length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1217
1218   /* If no string table is needed, then the file may end immediately
1219      after the symbols.  Just return with `stringtab' set to null. */
1220   if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1221     return 0;
1222
1223   stringtab = (char *) xmalloc (length);
1224   /* This is in target format (probably not very useful, and not currently
1225      used), not host format.  */
1226   memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1227   if (length == sizeof length)  /* Empty table -- just the count */
1228     return 0;
1229
1230   val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf,
1231                    abfd);
1232   if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1233     return -1;
1234
1235   return 0;
1236 }
1237
1238 static void
1239 free_stringtab (void)
1240 {
1241   if (stringtab)
1242     xfree (stringtab);
1243   stringtab = NULL;
1244 }
1245
1246 static void
1247 free_stringtab_cleanup (void *ignore)
1248 {
1249   free_stringtab ();
1250 }
1251
1252 static char *
1253 getsymname (struct internal_syment *symbol_entry)
1254 {
1255   static char buffer[SYMNMLEN + 1];
1256   char *result;
1257
1258   if (symbol_entry->_n._n_n._n_zeroes == 0)
1259     {
1260       /* FIXME: Probably should be detecting corrupt symbol files by
1261          seeing whether offset points to within the stringtab.  */
1262       result = stringtab + symbol_entry->_n._n_n._n_offset;
1263     }
1264   else
1265     {
1266       strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1267       buffer[SYMNMLEN] = '\0';
1268       result = buffer;
1269     }
1270   return result;
1271 }
1272
1273 /* Extract the file name from the aux entry of a C_FILE symbol.  Return
1274    only the last component of the name.  Result is in static storage and
1275    is only good for temporary use.  */
1276
1277 static char *
1278 coff_getfilename (union internal_auxent *aux_entry)
1279 {
1280   static char buffer[BUFSIZ];
1281   register char *temp;
1282   char *result;
1283
1284   if (aux_entry->x_file.x_n.x_zeroes == 0)
1285     strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1286   else
1287     {
1288       strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1289       buffer[FILNMLEN] = '\0';
1290     }
1291   result = buffer;
1292
1293   /* FIXME: We should not be throwing away the information about what
1294      directory.  It should go into dirname of the symtab, or some such
1295      place.  */
1296   if ((temp = strrchr (result, '/')) != NULL)
1297     result = temp + 1;
1298   return (result);
1299 }
1300 \f
1301 /* Support for line number handling.  */
1302
1303 static char *linetab = NULL;
1304 static long linetab_offset;
1305 static unsigned long linetab_size;
1306
1307 /* Read in all the line numbers for fast lookups later.  Leave them in
1308    external (unswapped) format in memory; we'll swap them as we enter
1309    them into GDB's data structures.  */
1310
1311 static int
1312 init_lineno (bfd *abfd, long offset, int size)
1313 {
1314   int val;
1315
1316   linetab_offset = offset;
1317   linetab_size = size;
1318
1319   free_linetab ();
1320
1321   if (size == 0)
1322     return 0;
1323
1324   if (bfd_seek (abfd, offset, 0) < 0)
1325     return -1;
1326
1327   /* Allocate the desired table, plus a sentinel */
1328   linetab = (char *) xmalloc (size + local_linesz);
1329
1330   val = bfd_bread (linetab, size, abfd);
1331   if (val != size)
1332     return -1;
1333
1334   /* Terminate it with an all-zero sentinel record */
1335   memset (linetab + size, 0, local_linesz);
1336
1337   return 0;
1338 }
1339
1340 static void
1341 free_linetab (void)
1342 {
1343   if (linetab)
1344     xfree (linetab);
1345   linetab = NULL;
1346 }
1347
1348 static void
1349 free_linetab_cleanup (void *ignore)
1350 {
1351   free_linetab ();
1352 }
1353
1354 #if !defined (L_LNNO32)
1355 #define L_LNNO32(lp) ((lp)->l_lnno)
1356 #endif
1357
1358 static void
1359 enter_linenos (long file_offset, register int first_line,
1360                register int last_line, struct objfile *objfile)
1361 {
1362   register char *rawptr;
1363   struct internal_lineno lptr;
1364
1365   if (!linetab)
1366     return;
1367   if (file_offset < linetab_offset)
1368     {
1369       complaint (&symfile_complaints,
1370                  "Line number pointer %ld lower than start of line numbers",
1371                  file_offset);
1372       if (file_offset > linetab_size)   /* Too big to be an offset? */
1373         return;
1374       file_offset += linetab_offset;    /* Try reading at that linetab offset */
1375     }
1376
1377   rawptr = &linetab[file_offset - linetab_offset];
1378
1379   /* skip first line entry for each function */
1380   rawptr += local_linesz;
1381   /* line numbers start at one for the first line of the function */
1382   first_line--;
1383
1384   for (;;)
1385     {
1386       bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1387       rawptr += local_linesz;
1388       /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1389       if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1390         record_line (current_subfile, first_line + L_LNNO32 (&lptr),
1391                      lptr.l_addr.l_paddr
1392                      + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)));
1393       else
1394         break;
1395     }
1396 }
1397 \f
1398 static void
1399 patch_type (struct type *type, struct type *real_type)
1400 {
1401   register struct type *target = TYPE_TARGET_TYPE (type);
1402   register struct type *real_target = TYPE_TARGET_TYPE (real_type);
1403   int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1404
1405   TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1406   TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1407   TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target, field_size);
1408
1409   memcpy (TYPE_FIELDS (target), TYPE_FIELDS (real_target), field_size);
1410
1411   if (TYPE_NAME (real_target))
1412     {
1413       if (TYPE_NAME (target))
1414         xfree (TYPE_NAME (target));
1415       TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL);
1416     }
1417 }
1418
1419 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1420    so that they can be used to print out opaque data structures properly.  */
1421
1422 static void
1423 patch_opaque_types (struct symtab *s)
1424 {
1425   register struct block *b;
1426   register int i;
1427   register struct symbol *real_sym;
1428
1429   /* Go through the per-file symbols only */
1430   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1431   ALL_BLOCK_SYMBOLS (b, i, real_sym)
1432     {
1433       /* Find completed typedefs to use to fix opaque ones.
1434          Remove syms from the chain when their types are stored,
1435          but search the whole chain, as there may be several syms
1436          from different files with the same name.  */
1437       if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
1438           SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN &&
1439           TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
1440           TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1441         {
1442           register char *name = DEPRECATED_SYMBOL_NAME (real_sym);
1443           register int hash = hashname (name);
1444           register struct symbol *sym, *prev;
1445
1446           prev = 0;
1447           for (sym = opaque_type_chain[hash]; sym;)
1448             {
1449               if (name[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
1450                   STREQ (name + 1, DEPRECATED_SYMBOL_NAME (sym) + 1))
1451                 {
1452                   if (prev)
1453                     {
1454                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1455                     }
1456                   else
1457                     {
1458                       opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1459                     }
1460
1461                   patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1462
1463                   if (prev)
1464                     {
1465                       sym = SYMBOL_VALUE_CHAIN (prev);
1466                     }
1467                   else
1468                     {
1469                       sym = opaque_type_chain[hash];
1470                     }
1471                 }
1472               else
1473                 {
1474                   prev = sym;
1475                   sym = SYMBOL_VALUE_CHAIN (sym);
1476                 }
1477             }
1478         }
1479     }
1480 }
1481 \f
1482 static struct symbol *
1483 process_coff_symbol (register struct coff_symbol *cs,
1484                      register union internal_auxent *aux,
1485                      struct objfile *objfile)
1486 {
1487   register struct symbol *sym
1488   = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1489                                      sizeof (struct symbol));
1490   char *name;
1491
1492   memset (sym, 0, sizeof (struct symbol));
1493   name = cs->c_name;
1494   name = EXTERNAL_NAME (name, objfile->obfd);
1495   SYMBOL_LANGUAGE (sym) = language_auto;
1496   SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
1497
1498   /* default assumptions */
1499   SYMBOL_VALUE (sym) = cs->c_value;
1500   SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1501   SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1502
1503   if (ISFCN (cs->c_type))
1504     {
1505       SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1506       SYMBOL_TYPE (sym) =
1507         lookup_function_type (decode_function_type (cs, cs->c_type, aux));
1508
1509       SYMBOL_CLASS (sym) = LOC_BLOCK;
1510       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1511           || cs->c_sclass == C_THUMBSTATFUNC)
1512         add_symbol_to_list (sym, &file_symbols);
1513       else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1514                || cs->c_sclass == C_THUMBEXTFUNC)
1515         add_symbol_to_list (sym, &global_symbols);
1516     }
1517   else
1518     {
1519       SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
1520       switch (cs->c_sclass)
1521         {
1522         case C_NULL:
1523           break;
1524
1525         case C_AUTO:
1526           SYMBOL_CLASS (sym) = LOC_LOCAL;
1527           add_symbol_to_list (sym, &local_symbols);
1528           break;
1529
1530         case C_THUMBEXT:
1531         case C_THUMBEXTFUNC:
1532         case C_EXT:
1533           SYMBOL_CLASS (sym) = LOC_STATIC;
1534           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1535           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1536           add_symbol_to_list (sym, &global_symbols);
1537           break;
1538
1539         case C_THUMBSTAT:
1540         case C_THUMBSTATFUNC:
1541         case C_STAT:
1542           SYMBOL_CLASS (sym) = LOC_STATIC;
1543           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1544           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1545           if (within_function)
1546             {
1547               /* Static symbol of local scope */
1548               add_symbol_to_list (sym, &local_symbols);
1549             }
1550           else
1551             {
1552               /* Static symbol at top level of file */
1553               add_symbol_to_list (sym, &file_symbols);
1554             }
1555           break;
1556
1557 #ifdef C_GLBLREG                /* AMD coff */
1558         case C_GLBLREG:
1559 #endif
1560         case C_REG:
1561           SYMBOL_CLASS (sym) = LOC_REGISTER;
1562           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1563           add_symbol_to_list (sym, &local_symbols);
1564           break;
1565
1566         case C_THUMBLABEL:
1567         case C_LABEL:
1568           break;
1569
1570         case C_ARG:
1571           SYMBOL_CLASS (sym) = LOC_ARG;
1572           add_symbol_to_list (sym, &local_symbols);
1573 #if !defined (BELIEVE_PCC_PROMOTION)
1574           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1575             {
1576               /* If PCC says a parameter is a short or a char,
1577                  aligned on an int boundary, realign it to the
1578                  "little end" of the int.  */
1579               struct type *temptype;
1580               temptype = lookup_fundamental_type (current_objfile,
1581                                                   FT_INTEGER);
1582               if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1583                   && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
1584                   && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
1585                 {
1586                   SYMBOL_VALUE (sym) +=
1587                     TYPE_LENGTH (temptype)
1588                     - TYPE_LENGTH (SYMBOL_TYPE (sym));
1589                 }
1590             }
1591 #endif
1592           break;
1593
1594         case C_REGPARM:
1595           SYMBOL_CLASS (sym) = LOC_REGPARM;
1596           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1597           add_symbol_to_list (sym, &local_symbols);
1598 #if !defined (BELIEVE_PCC_PROMOTION)
1599           /* FIXME:  This should retain the current type, since it's just
1600              a register value.  gnu@adobe, 26Feb93 */
1601           {
1602             /* If PCC says a parameter is a short or a char,
1603                it is really an int.  */
1604             struct type *temptype;
1605             temptype =
1606               lookup_fundamental_type (current_objfile, FT_INTEGER);
1607             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1608                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1609               {
1610                 SYMBOL_TYPE (sym) =
1611                   (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1612                    ? lookup_fundamental_type (current_objfile,
1613                                               FT_UNSIGNED_INTEGER)
1614                    : temptype);
1615               }
1616           }
1617 #endif
1618           break;
1619
1620         case C_TPDEF:
1621           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1622           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1623
1624           /* If type has no name, give it one */
1625           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1626             {
1627               if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1628                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1629                 {
1630                   /* If we are giving a name to a type such as "pointer to
1631                      foo" or "function returning foo", we better not set
1632                      the TYPE_NAME.  If the program contains "typedef char
1633                      *caddr_t;", we don't want all variables of type char
1634                      * to print as caddr_t.  This is not just a
1635                      consequence of GDB's type management; CC and GCC (at
1636                      least through version 2.4) both output variables of
1637                      either type char * or caddr_t with the type
1638                      refering to the C_TPDEF symbol for caddr_t.  If a future
1639                      compiler cleans this up it GDB is not ready for it
1640                      yet, but if it becomes ready we somehow need to
1641                      disable this check (without breaking the PCC/GCC2.4
1642                      case).
1643
1644                      Sigh.
1645
1646                      Fortunately, this check seems not to be necessary
1647                      for anything except pointers or functions.  */
1648                   ;
1649                 }
1650               else
1651                 TYPE_NAME (SYMBOL_TYPE (sym)) =
1652                   concat (DEPRECATED_SYMBOL_NAME (sym), NULL);
1653             }
1654 #ifdef CXUX_TARGET
1655           /* Ignore vendor section for Harris CX/UX targets. */
1656           else if (cs->c_name[0] == '$')
1657             break;
1658 #endif /* CXUX_TARGET */
1659
1660           /* Keep track of any type which points to empty structured type,
1661              so it can be filled from a definition from another file.  A
1662              simple forward reference (TYPE_CODE_UNDEF) is not an
1663              empty structured type, though; the forward references
1664              work themselves out via the magic of coff_lookup_type.  */
1665           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
1666               TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
1667               TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
1668               TYPE_CODE_UNDEF)
1669             {
1670               register int i = hashname (DEPRECATED_SYMBOL_NAME (sym));
1671
1672               SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1673               opaque_type_chain[i] = sym;
1674             }
1675           add_symbol_to_list (sym, &file_symbols);
1676           break;
1677
1678         case C_STRTAG:
1679         case C_UNTAG:
1680         case C_ENTAG:
1681           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1682           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1683
1684           /* Some compilers try to be helpful by inventing "fake"
1685              names for anonymous enums, structures, and unions, like
1686              "~0fake" or ".0fake".  Thanks, but no thanks... */
1687           if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1688             if (DEPRECATED_SYMBOL_NAME (sym) != NULL
1689                 && *DEPRECATED_SYMBOL_NAME (sym) != '~'
1690                 && *DEPRECATED_SYMBOL_NAME (sym) != '.')
1691               TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1692                 concat (DEPRECATED_SYMBOL_NAME (sym), NULL);
1693
1694           add_symbol_to_list (sym, &file_symbols);
1695           break;
1696
1697         default:
1698           break;
1699         }
1700     }
1701   return sym;
1702 }
1703 \f
1704 /* Decode a coff type specifier;  return the type that is meant.  */
1705
1706 static struct type *
1707 decode_type (register struct coff_symbol *cs, unsigned int c_type,
1708              register union internal_auxent *aux)
1709 {
1710   register struct type *type = 0;
1711   unsigned int new_c_type;
1712
1713   if (c_type & ~N_BTMASK)
1714     {
1715       new_c_type = DECREF (c_type);
1716       if (ISPTR (c_type))
1717         {
1718           type = decode_type (cs, new_c_type, aux);
1719           type = lookup_pointer_type (type);
1720         }
1721       else if (ISFCN (c_type))
1722         {
1723           type = decode_type (cs, new_c_type, aux);
1724           type = lookup_function_type (type);
1725         }
1726       else if (ISARY (c_type))
1727         {
1728           int i, n;
1729           register unsigned short *dim;
1730           struct type *base_type, *index_type, *range_type;
1731
1732           /* Define an array type.  */
1733           /* auxent refers to array, not base type */
1734           if (aux->x_sym.x_tagndx.l == 0)
1735             cs->c_naux = 0;
1736
1737           /* shift the indices down */
1738           dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1739           i = 1;
1740           n = dim[0];
1741           for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1742             *dim = *(dim + 1);
1743           *dim = 0;
1744
1745           base_type = decode_type (cs, new_c_type, aux);
1746           index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
1747           range_type =
1748             create_range_type ((struct type *) NULL, index_type, 0, n - 1);
1749           type =
1750             create_array_type ((struct type *) NULL, base_type, range_type);
1751         }
1752       return type;
1753     }
1754
1755   /* Reference to existing type.  This only occurs with the
1756      struct, union, and enum types.  EPI a29k coff
1757      fakes us out by producing aux entries with a nonzero
1758      x_tagndx for definitions of structs, unions, and enums, so we
1759      have to check the c_sclass field.  SCO 3.2v4 cc gets confused
1760      with pointers to pointers to defined structs, and generates
1761      negative x_tagndx fields.  */
1762   if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1763     {
1764       if (cs->c_sclass != C_STRTAG
1765           && cs->c_sclass != C_UNTAG
1766           && cs->c_sclass != C_ENTAG
1767           && aux->x_sym.x_tagndx.l >= 0)
1768         {
1769           type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1770           return type;
1771         }
1772       else
1773         {
1774           complaint (&symfile_complaints,
1775                      "Symbol table entry for %s has bad tagndx value",
1776                      cs->c_name);
1777           /* And fall through to decode_base_type... */
1778         }
1779     }
1780
1781   return decode_base_type (cs, BTYPE (c_type), aux);
1782 }
1783
1784 /* Decode a coff type specifier for function definition;
1785    return the type that the function returns.  */
1786
1787 static struct type *
1788 decode_function_type (register struct coff_symbol *cs, unsigned int c_type,
1789                       register union internal_auxent *aux)
1790 {
1791   if (aux->x_sym.x_tagndx.l == 0)
1792     cs->c_naux = 0;             /* auxent refers to function, not base type */
1793
1794   return decode_type (cs, DECREF (c_type), aux);
1795 }
1796 \f
1797 /* basic C types */
1798
1799 static struct type *
1800 decode_base_type (register struct coff_symbol *cs, unsigned int c_type,
1801                   register union internal_auxent *aux)
1802 {
1803   struct type *type;
1804
1805   switch (c_type)
1806     {
1807     case T_NULL:
1808       /* shows up with "void (*foo)();" structure members */
1809       return lookup_fundamental_type (current_objfile, FT_VOID);
1810
1811 #if 0
1812 /* DGUX actually defines both T_ARG and T_VOID to the same value.  */
1813 #ifdef T_ARG
1814     case T_ARG:
1815       /* Shows up in DGUX, I think.  Not sure where.  */
1816       return lookup_fundamental_type (current_objfile, FT_VOID);        /* shouldn't show up here */
1817 #endif
1818 #endif /* 0 */
1819
1820 #ifdef T_VOID
1821     case T_VOID:
1822       /* Intel 960 COFF has this symbol and meaning.  */
1823       return lookup_fundamental_type (current_objfile, FT_VOID);
1824 #endif
1825
1826     case T_CHAR:
1827       return lookup_fundamental_type (current_objfile, FT_CHAR);
1828
1829     case T_SHORT:
1830       return lookup_fundamental_type (current_objfile, FT_SHORT);
1831
1832     case T_INT:
1833       return lookup_fundamental_type (current_objfile, FT_INTEGER);
1834
1835     case T_LONG:
1836       if (cs->c_sclass == C_FIELD
1837           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1838         return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
1839       else
1840         return lookup_fundamental_type (current_objfile, FT_LONG);
1841
1842     case T_FLOAT:
1843       return lookup_fundamental_type (current_objfile, FT_FLOAT);
1844
1845     case T_DOUBLE:
1846       return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
1847
1848     case T_LNGDBL:
1849       return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
1850
1851     case T_STRUCT:
1852       if (cs->c_naux != 1)
1853         {
1854           /* anonymous structure type */
1855           type = coff_alloc_type (cs->c_symnum);
1856           TYPE_CODE (type) = TYPE_CODE_STRUCT;
1857           TYPE_NAME (type) = NULL;
1858           /* This used to set the tag to "<opaque>".  But I think setting it
1859              to NULL is right, and the printing code can print it as
1860              "struct {...}".  */
1861           TYPE_TAG_NAME (type) = NULL;
1862           INIT_CPLUS_SPECIFIC (type);
1863           TYPE_LENGTH (type) = 0;
1864           TYPE_FIELDS (type) = 0;
1865           TYPE_NFIELDS (type) = 0;
1866         }
1867       else
1868         {
1869           type = coff_read_struct_type (cs->c_symnum,
1870                                         aux->x_sym.x_misc.x_lnsz.x_size,
1871                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1872         }
1873       return type;
1874
1875     case T_UNION:
1876       if (cs->c_naux != 1)
1877         {
1878           /* anonymous union type */
1879           type = coff_alloc_type (cs->c_symnum);
1880           TYPE_NAME (type) = NULL;
1881           /* This used to set the tag to "<opaque>".  But I think setting it
1882              to NULL is right, and the printing code can print it as
1883              "union {...}".  */
1884           TYPE_TAG_NAME (type) = NULL;
1885           INIT_CPLUS_SPECIFIC (type);
1886           TYPE_LENGTH (type) = 0;
1887           TYPE_FIELDS (type) = 0;
1888           TYPE_NFIELDS (type) = 0;
1889         }
1890       else
1891         {
1892           type = coff_read_struct_type (cs->c_symnum,
1893                                         aux->x_sym.x_misc.x_lnsz.x_size,
1894                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1895         }
1896       TYPE_CODE (type) = TYPE_CODE_UNION;
1897       return type;
1898
1899     case T_ENUM:
1900       if (cs->c_naux != 1)
1901         {
1902           /* anonymous enum type */
1903           type = coff_alloc_type (cs->c_symnum);
1904           TYPE_CODE (type) = TYPE_CODE_ENUM;
1905           TYPE_NAME (type) = NULL;
1906           /* This used to set the tag to "<opaque>".  But I think setting it
1907              to NULL is right, and the printing code can print it as
1908              "enum {...}".  */
1909           TYPE_TAG_NAME (type) = NULL;
1910           TYPE_LENGTH (type) = 0;
1911           TYPE_FIELDS (type) = 0;
1912           TYPE_NFIELDS (type) = 0;
1913         }
1914       else
1915         {
1916           type = coff_read_enum_type (cs->c_symnum,
1917                                       aux->x_sym.x_misc.x_lnsz.x_size,
1918                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1919         }
1920       return type;
1921
1922     case T_MOE:
1923       /* shouldn't show up here */
1924       break;
1925
1926     case T_UCHAR:
1927       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
1928
1929     case T_USHORT:
1930       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
1931
1932     case T_UINT:
1933       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
1934
1935     case T_ULONG:
1936       if (cs->c_sclass == C_FIELD
1937           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1938         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
1939       else
1940         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
1941     }
1942   complaint (&symfile_complaints, "Unexpected type for symbol %s", cs->c_name);
1943   return lookup_fundamental_type (current_objfile, FT_VOID);
1944 }
1945 \f
1946 /* This page contains subroutines of read_type.  */
1947
1948 /* Read the description of a structure (or union type) and return an
1949    object describing the type.  */
1950
1951 static struct type *
1952 coff_read_struct_type (int index, int length, int lastsym)
1953 {
1954   struct nextfield
1955     {
1956       struct nextfield *next;
1957       struct field field;
1958     };
1959
1960   register struct type *type;
1961   register struct nextfield *list = 0;
1962   struct nextfield *new;
1963   int nfields = 0;
1964   register int n;
1965   char *name;
1966   struct coff_symbol member_sym;
1967   register struct coff_symbol *ms = &member_sym;
1968   struct internal_syment sub_sym;
1969   union internal_auxent sub_aux;
1970   int done = 0;
1971
1972   type = coff_alloc_type (index);
1973   TYPE_CODE (type) = TYPE_CODE_STRUCT;
1974   INIT_CPLUS_SPECIFIC (type);
1975   TYPE_LENGTH (type) = length;
1976
1977   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
1978     {
1979       read_one_sym (ms, &sub_sym, &sub_aux);
1980       name = ms->c_name;
1981       name = EXTERNAL_NAME (name, current_objfile->obfd);
1982
1983       switch (ms->c_sclass)
1984         {
1985         case C_MOS:
1986         case C_MOU:
1987
1988           /* Get space to record the next field's data.  */
1989           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1990           new->next = list;
1991           list = new;
1992
1993           /* Save the data.  */
1994           list->field.name =
1995             obsavestring (name,
1996                           strlen (name),
1997                           &current_objfile->symbol_obstack);
1998           FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1999           FIELD_BITPOS (list->field) = 8 * ms->c_value;
2000           FIELD_BITSIZE (list->field) = 0;
2001           FIELD_STATIC_KIND (list->field) = 0;
2002           nfields++;
2003           break;
2004
2005         case C_FIELD:
2006
2007           /* Get space to record the next field's data.  */
2008           new = (struct nextfield *) alloca (sizeof (struct nextfield));
2009           new->next = list;
2010           list = new;
2011
2012           /* Save the data.  */
2013           list->field.name =
2014             obsavestring (name,
2015                           strlen (name),
2016                           &current_objfile->symbol_obstack);
2017           FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
2018           FIELD_BITPOS (list->field) = ms->c_value;
2019           FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
2020           FIELD_STATIC_KIND (list->field) = 0;
2021           nfields++;
2022           break;
2023
2024         case C_EOS:
2025           done = 1;
2026           break;
2027         }
2028     }
2029   /* Now create the vector of fields, and record how big it is.  */
2030
2031   TYPE_NFIELDS (type) = nfields;
2032   TYPE_FIELDS (type) = (struct field *)
2033     TYPE_ALLOC (type, sizeof (struct field) * nfields);
2034
2035   /* Copy the saved-up fields into the field vector.  */
2036
2037   for (n = nfields; list; list = list->next)
2038     TYPE_FIELD (type, --n) = list->field;
2039
2040   return type;
2041 }
2042 \f
2043 /* Read a definition of an enumeration type,
2044    and create and return a suitable type object.
2045    Also defines the symbols that represent the values of the type.  */
2046
2047 /* ARGSUSED */
2048 static struct type *
2049 coff_read_enum_type (int index, int length, int lastsym)
2050 {
2051   register struct symbol *sym;
2052   register struct type *type;
2053   int nsyms = 0;
2054   int done = 0;
2055   struct pending **symlist;
2056   struct coff_symbol member_sym;
2057   register struct coff_symbol *ms = &member_sym;
2058   struct internal_syment sub_sym;
2059   union internal_auxent sub_aux;
2060   struct pending *osyms, *syms;
2061   int o_nsyms;
2062   register int n;
2063   char *name;
2064   int unsigned_enum = 1;
2065
2066   type = coff_alloc_type (index);
2067   if (within_function)
2068     symlist = &local_symbols;
2069   else
2070     symlist = &file_symbols;
2071   osyms = *symlist;
2072   o_nsyms = osyms ? osyms->nsyms : 0;
2073
2074   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2075     {
2076       read_one_sym (ms, &sub_sym, &sub_aux);
2077       name = ms->c_name;
2078       name = EXTERNAL_NAME (name, current_objfile->obfd);
2079
2080       switch (ms->c_sclass)
2081         {
2082         case C_MOE:
2083           sym = (struct symbol *) obstack_alloc
2084             (&current_objfile->symbol_obstack,
2085              sizeof (struct symbol));
2086           memset (sym, 0, sizeof (struct symbol));
2087
2088           DEPRECATED_SYMBOL_NAME (sym) =
2089             obsavestring (name, strlen (name),
2090                           &current_objfile->symbol_obstack);
2091           SYMBOL_CLASS (sym) = LOC_CONST;
2092           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2093           SYMBOL_VALUE (sym) = ms->c_value;
2094           add_symbol_to_list (sym, symlist);
2095           nsyms++;
2096           break;
2097
2098         case C_EOS:
2099           /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2100              up the count of how many symbols to read.  So stop
2101              on .eos.  */
2102           done = 1;
2103           break;
2104         }
2105     }
2106
2107   /* Now fill in the fields of the type-structure.  */
2108
2109   if (length > 0)
2110     TYPE_LENGTH (type) = length;
2111   else
2112     TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;      /* Assume ints */
2113   TYPE_CODE (type) = TYPE_CODE_ENUM;
2114   TYPE_NFIELDS (type) = nsyms;
2115   TYPE_FIELDS (type) = (struct field *)
2116     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2117
2118   /* Find the symbols for the values and put them into the type.
2119      The symbols can be found in the symlist that we put them on
2120      to cause them to be defined.  osyms contains the old value
2121      of that symlist; everything up to there was defined by us.  */
2122   /* Note that we preserve the order of the enum constants, so
2123      that in something like "enum {FOO, LAST_THING=FOO}" we print
2124      FOO, not LAST_THING.  */
2125
2126   for (syms = *symlist, n = 0; syms; syms = syms->next)
2127     {
2128       int j = 0;
2129
2130       if (syms == osyms)
2131         j = o_nsyms;
2132       for (; j < syms->nsyms; j++, n++)
2133         {
2134           struct symbol *xsym = syms->symbol[j];
2135           SYMBOL_TYPE (xsym) = type;
2136           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
2137           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
2138           if (SYMBOL_VALUE (xsym) < 0)
2139             unsigned_enum = 0;
2140           TYPE_FIELD_BITSIZE (type, n) = 0;
2141           TYPE_FIELD_STATIC_KIND (type, n) = 0;
2142         }
2143       if (syms == osyms)
2144         break;
2145     }
2146
2147   if (unsigned_enum)
2148     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
2149
2150   return type;
2151 }
2152
2153 /* Register our ability to parse symbols for coff BFD files. */
2154
2155 static struct sym_fns coff_sym_fns =
2156 {
2157   bfd_target_coff_flavour,
2158   coff_new_init,                /* sym_new_init: init anything gbl to entire symtab */
2159   coff_symfile_init,            /* sym_init: read initial info, setup for sym_read() */
2160   coff_symfile_read,            /* sym_read: read a symbol file into symtab */
2161   coff_symfile_finish,          /* sym_finish: finished with file, cleanup */
2162   default_symfile_offsets,      /* sym_offsets:  xlate external to internal form */
2163   NULL                          /* next: pointer to next struct sym_fns */
2164 };
2165
2166 void
2167 _initialize_coffread (void)
2168 {
2169   add_symtab_fns (&coff_sym_fns);
2170 }