gdb/coffread.c

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