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