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   /* Read the line number table, all at once.  */
 597   info->min_lineno_offset = 0;
 598   info->max_lineno_offset = 0;
 599   bfd_map_over_sections (abfd, find_linenos, (void *) info);
 600
 601   make_cleanup (free_linetab_cleanup, 0 /*ignore*/);
 602   val = init_lineno (abfd, info->min_lineno_offset,
 603                      info->max_lineno_offset - info->min_lineno_offset);
 604   if (val < 0)
 605     error ("\"%s\": error reading line numbers\n", name);
 606
 607   /* Now read the string table, all at once.  */
 608
 609   make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
 610   val = init_stringtab (abfd, stringtab_offset);
 611   if (val < 0)
 612     error ("\"%s\": can't get string table", name);
 613
 614   init_minimal_symbol_collection ();
 615   make_cleanup_discard_minimal_symbols ();
 616
 617   /* Now that the executable file is positioned at symbol table,
 618      process it and define symbols accordingly.  */
 619
 620   coff_symtab_read ((long) symtab_offset, num_symbols, objfile);
 621
 622   /* Sort symbols alphabetically within each block.  */
 623
 624   {
 625     struct symtab *s;
 626
 627     for (s = objfile->symtabs; s != NULL; s = s->next)
 628       sort_symtab_syms (s);
 629   }
 630
 631   /* Install any minimal symbols that have been collected as the current
 632      minimal symbols for this objfile.  */
 633
 634   install_minimal_symbols (objfile);
 635
 636   bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
 637
 638   if (info->stabsects)
 639     {
 640       if (!info->stabstrsect)
 641         {
 642           error (("The debugging information in `%s' is corrupted.\n"
 643                   "The file has a `.stabs' section, but no `.stabstr' "
 644                   "section."),
 645                  name);
 646         }
 647
 648       /* FIXME: dubious.  Why can't we use something normal like
 649          bfd_get_section_contents?  */
 650       bfd_seek (abfd, abfd->where, 0);
 651
 652       stabstrsize = bfd_section_size (abfd, info->stabstrsect);
 653
 654       coffstab_build_psymtabs (objfile,
 655                                mainline,
 656                                info->textaddr, info->textsize,
 657                                info->stabsects,
 658                                info->stabstrsect->filepos, stabstrsize);
 659     }
 660   if (dwarf2_has_info (abfd))
 661     {
 662       /* DWARF2 sections.  */
 663       dwarf2_build_psymtabs (objfile, mainline);
 664     }
 665
 666   do_cleanups (back_to);
 667 }
 668
 669 static void
 670 coff_new_init (struct objfile *ignore)
 671 {
 672 }
 673
 674 /* Perform any local cleanups required when we are done with a particular
 675    objfile.  I.E, we are in the process of discarding all symbol information
 676    for an objfile, freeing up all memory held for it, and unlinking the
 677    objfile struct from the global list of known objfiles. */
 678
 679 static void
 680 coff_symfile_finish (struct objfile *objfile)
 681 {
 682   if (objfile->sym_private != NULL)
 683     {
 684       xmfree (objfile->md, objfile->sym_private);
 685     }
 686
 687   /* Let stabs reader clean up */
 688   stabsread_clear_cache ();
 689 }
 690 \f
 691
 692 /* Given pointers to a symbol table in coff style exec file,
 693    analyze them and create struct symtab's describing the symbols.
 694    NSYMS is the number of symbols in the symbol table.
 695    We read them one at a time using read_one_sym ().  */
 696
 697 static void
 698 coff_symtab_read (long symtab_offset, unsigned int nsyms,
 699                   struct objfile *objfile)
 700 {
 701   register struct context_stack *new;
 702   struct coff_symbol coff_symbol;
 703   register struct coff_symbol *cs = &coff_symbol;
 704   static struct internal_syment main_sym;
 705   static union internal_auxent main_aux;
 706   struct coff_symbol fcn_cs_saved;
 707   static struct internal_syment fcn_sym_saved;
 708   static union internal_auxent fcn_aux_saved;
 709   struct symtab *s;
 710   /* A .file is open.  */
 711   int in_source_file = 0;
 712   int next_file_symnum = -1;
 713   /* Name of the current file.  */
 714   char *filestring = "";
 715   int depth = 0;
 716   int fcn_first_line = 0;
 717   CORE_ADDR fcn_first_line_addr = 0;
 718   int fcn_last_line = 0;
 719   int fcn_start_addr = 0;
 720   long fcn_line_ptr = 0;
 721   int val;
 722   CORE_ADDR tmpaddr;
 723
 724   /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
 725      it's hard to know I've really worked around it.  The fix should be
 726      harmless, anyway).  The symptom of the bug is that the first
 727      fread (in read_one_sym), will (in my example) actually get data
 728      from file offset 268, when the fseek was to 264 (and ftell shows
 729      264).  This causes all hell to break loose.  I was unable to
 730      reproduce this on a short test program which operated on the same
 731      file, performing (I think) the same sequence of operations.
 732
 733      It stopped happening when I put in this (former) rewind().
 734
 735      FIXME: Find out if this has been reported to Sun, whether it has
 736      been fixed in a later release, etc.  */
 737
 738   bfd_seek (objfile->obfd, 0, 0);
 739
 740   /* Position to read the symbol table. */
 741   val = bfd_seek (objfile->obfd, (long) symtab_offset, 0);
 742   if (val < 0)
 743     perror_with_name (objfile->name);
 744
 745   current_objfile = objfile;
 746   nlist_bfd_global = objfile->obfd;
 747   nlist_nsyms_global = nsyms;
 748   last_source_file = NULL;
 749   memset (opaque_type_chain, 0, sizeof opaque_type_chain);
 750
 751   if (type_vector)              /* Get rid of previous one */
 752     xfree (type_vector);
 753   type_vector_length = 160;
 754   type_vector = (struct type **)
 755     xmalloc (type_vector_length * sizeof (struct type *));
 756   memset (type_vector, 0, type_vector_length * sizeof (struct type *));
 757
 758   coff_start_symtab ("");
 759
 760   symnum = 0;
 761   while (symnum < nsyms)
 762     {
 763       QUIT;                     /* Make this command interruptable.  */
 764
 765       read_one_sym (cs, &main_sym, &main_aux);
 766
 767       if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
 768         {
 769           if (last_source_file)
 770             coff_end_symtab (objfile);
 771
 772           coff_start_symtab ("_globals_");
 773           complete_symtab ("_globals_", 0, 0);
 774           /* done with all files, everything from here on out is globals */
 775         }
 776
 777       /* Special case for file with type declarations only, no text.  */
 778       if (!last_source_file && SDB_TYPE (cs->c_type)
 779           && cs->c_secnum == N_DEBUG)
 780         complete_symtab (filestring, 0, 0);
 781
 782       /* Typedefs should not be treated as symbol definitions.  */
 783       if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
 784         {
 785           /* Record all functions -- external and static -- in minsyms. */
 786           tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 787           record_minimal_symbol (cs->c_name, tmpaddr, mst_text, objfile);
 788
 789           fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
 790           fcn_start_addr = tmpaddr;
 791           fcn_cs_saved = *cs;
 792           fcn_sym_saved = main_sym;
 793           fcn_aux_saved = main_aux;
 794           continue;
 795         }
 796
 797       switch (cs->c_sclass)
 798         {
 799         case C_EFCN:
 800         case C_EXTDEF:
 801         case C_ULABEL:
 802         case C_USTATIC:
 803         case C_LINE:
 804         case C_ALIAS:
 805         case C_HIDDEN:
 806           complain (&bad_sclass_complaint, cs->c_name);
 807           break;
 808
 809         case C_FILE:
 810           /* c_value field contains symnum of next .file entry in table
 811              or symnum of first global after last .file.  */
 812           next_file_symnum = cs->c_value;
 813           if (cs->c_naux > 0)
 814             filestring = coff_getfilename (&main_aux);
 815           else
 816             filestring = "";
 817
 818           /* Complete symbol table for last object file
 819              containing debugging information.  */
 820           if (last_source_file)
 821             {
 822               coff_end_symtab (objfile);
 823               coff_start_symtab (filestring);
 824             }
 825           in_source_file = 1;
 826           break;
 827
 828           /* C_LABEL is used for labels and static functions.  Including
 829              it here allows gdb to see static functions when no debug
 830              info is available.  */
 831         case C_LABEL:
 832           /* However, labels within a function can make weird backtraces,
 833              so filter them out (from phdm@macqel.be). */
 834           if (within_function)
 835             break;
 836         case C_STAT:
 837         case C_THUMBLABEL:
 838         case C_THUMBSTAT:
 839         case C_THUMBSTATFUNC:
 840           if (cs->c_name[0] == '.')
 841             {
 842               if (STREQ (cs->c_name, ".text"))
 843                 {
 844                   /* FIXME:  don't wire in ".text" as section name
 845                      or symbol name! */
 846                   /* Check for in_source_file deals with case of
 847                      a file with debugging symbols
 848                      followed by a later file with no symbols.  */
 849                   if (in_source_file)
 850                     complete_symtab (filestring,
 851                     cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
 852                                      main_aux.x_scn.x_scnlen);
 853                   in_source_file = 0;
 854                 }
 855               /* flush rest of '.' symbols */
 856               break;
 857             }
 858           else if (!SDB_TYPE (cs->c_type)
 859                    && cs->c_name[0] == 'L'
 860                    && (strncmp (cs->c_name, "LI%", 3) == 0
 861                        || strncmp (cs->c_name, "LF%", 3) == 0
 862                        || strncmp (cs->c_name, "LC%", 3) == 0
 863                        || strncmp (cs->c_name, "LP%", 3) == 0
 864                        || strncmp (cs->c_name, "LPB%", 4) == 0
 865                        || strncmp (cs->c_name, "LBB%", 4) == 0
 866                        || strncmp (cs->c_name, "LBE%", 4) == 0
 867                        || strncmp (cs->c_name, "LPBX%", 5) == 0))
 868             /* At least on a 3b1, gcc generates swbeg and string labels
 869                that look like this.  Ignore them.  */
 870             break;
 871           /* fall in for static symbols that don't start with '.' */
 872         case C_THUMBEXT:
 873         case C_THUMBEXTFUNC:
 874         case C_EXT:
 875           {
 876             /* Record it in the minimal symbols regardless of
 877                SDB_TYPE.  This parallels what we do for other debug
 878                formats, and probably is needed to make
 879                print_address_symbolic work right without the (now
 880                gone) "set fast-symbolic-addr off" kludge.  */
 881
 882             /* FIXME: should use mst_abs, and not relocate, if absolute.  */
 883             enum minimal_symbol_type ms_type;
 884             int sec;
 885
 886             if (cs->c_secnum == N_UNDEF)
 887               {
 888                 /* This is a common symbol.  See if the target
 889                    environment knows where it has been relocated to.  */
 890                 CORE_ADDR reladdr;
 891                 if (target_lookup_symbol (cs->c_name, &reladdr))
 892                   {
 893                     /* Error in lookup; ignore symbol.  */
 894                     break;
 895                   }
 896                 tmpaddr = reladdr;
 897                 /* The address has already been relocated; make sure that
 898                    objfile_relocate doesn't relocate it again.  */
 899                 sec = -2;
 900                 ms_type = cs->c_sclass == C_EXT
 901                   || cs->c_sclass == C_THUMBEXT ?
 902                   mst_bss : mst_file_bss;
 903               }
 904             else
 905               {
 906                 sec = cs_to_section (cs, objfile);
 907                 tmpaddr = cs->c_value;
 908                 if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
 909                     || cs->c_sclass == C_THUMBEXT)
 910                   tmpaddr += ANOFFSET (objfile->section_offsets, sec);
 911
 912                 if (sec == SECT_OFF_TEXT (objfile))
 913                   {
 914                     ms_type =
 915                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
 916                       || cs->c_sclass == C_THUMBEXT ?
 917                       mst_text : mst_file_text;
 918                     tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr);
 919                   }
 920                 else if (sec == SECT_OFF_DATA (objfile))
 921                   {
 922                     ms_type =
 923                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
 924                       mst_data : mst_file_data;
 925                   }
 926                 else if (sec == SECT_OFF_BSS (objfile))
 927                   {
 928                     ms_type =
 929                       cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
 930                       mst_data : mst_file_data;
 931                   }
 932                 else
 933                   ms_type = mst_unknown;
 934               }
 935
 936             if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
 937               {
 938                 struct minimal_symbol *msym;
 939
 940                 /* FIXME: cagney/2001-02-01: The nasty (int) -> (long)
 941                    -> (void*) cast is to ensure that that the value of
 942                    cs->c_sclass can be correctly stored in a void
 943                    pointer in MSYMBOL_INFO.  Better solutions
 944                    welcome. */
 945                 gdb_assert (sizeof (void *) >= sizeof (cs->c_sclass));
 946                 msym = prim_record_minimal_symbol_and_info
 947                   (cs->c_name, tmpaddr, ms_type, (void *) (long) cs->c_sclass,
 948                    sec, NULL, objfile);
 949                 if (msym)
 950                   COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
 951               }
 952             if (SDB_TYPE (cs->c_type))
 953               {
 954                 struct symbol *sym;
 955                 sym = process_coff_symbol
 956                   (cs, &main_aux, objfile);
 957                 SYMBOL_VALUE (sym) = tmpaddr;
 958                 SYMBOL_SECTION (sym) = sec;
 959               }
 960           }
 961           break;
 962
 963         case C_FCN:
 964           if (STREQ (cs->c_name, ".bf"))
 965             {
 966               within_function = 1;
 967
 968               /* value contains address of first non-init type code */
 969               /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
 970                  contains line number of '{' } */
 971               if (cs->c_naux != 1)
 972                 complain (&bf_no_aux_complaint, cs->c_symnum);
 973               fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
 974               fcn_first_line_addr = cs->c_value;
 975
 976               /* Might want to check that locals are 0 and
 977                  context_stack_depth is zero, and complain if not.  */
 978
 979               depth = 0;
 980               new = push_context (depth, fcn_start_addr);
 981               fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
 982               new->name =
 983                 process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
 984             }
 985           else if (STREQ (cs->c_name, ".ef"))
 986             {
 987               if (!within_function)
 988                 error ("Bad coff function information\n");
 989               /* the value of .ef is the address of epilogue code;
 990                  not useful for gdb.  */
 991               /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
 992                  contains number of lines to '}' */
 993
 994               if (context_stack_depth <= 0)
 995                 {               /* We attempted to pop an empty context stack */
 996                   complain (&ef_stack_complaint, cs->c_symnum);
 997                   within_function = 0;
 998                   break;
 999                 }
1000
1001               new = pop_context ();
1002               /* Stack must be empty now.  */
1003               if (context_stack_depth > 0 || new == NULL)
1004                 {
1005                   complain (&ef_complaint, cs->c_symnum);
1006                   within_function = 0;
1007                   break;
1008                 }
1009               if (cs->c_naux != 1)
1010                 {
1011                   complain (&ef_no_aux_complaint, cs->c_symnum);
1012                   fcn_last_line = 0x7FFFFFFF;
1013                 }
1014               else
1015                 {
1016                   fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1017                 }
1018               /* fcn_first_line is the line number of the opening '{'.
1019                  Do not record it - because it would affect gdb's idea
1020                  of the line number of the first statement of the function -
1021                  except for one-line functions, for which it is also the line
1022                  number of all the statements and of the closing '}', and
1023                  for which we do not have any other statement-line-number. */
1024               if (fcn_last_line == 1)
1025                 record_line (current_subfile, fcn_first_line,
1026                              fcn_first_line_addr);
1027               else
1028                 enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
1029                                objfile);
1030
1031               finish_block (new->name, &local_symbols, new->old_blocks,
1032                             new->start_addr,
1033 #if defined (FUNCTION_EPILOGUE_SIZE)
1034               /* This macro should be defined only on
1035                  machines where the
1036                  fcn_aux_saved.x_sym.x_misc.x_fsize
1037                  field is always zero.
1038                  So use the .bf record information that
1039                  points to the epilogue and add the size
1040                  of the epilogue.  */
1041                             cs->c_value
1042                             + FUNCTION_EPILOGUE_SIZE
1043                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1044 #else
1045                             fcn_cs_saved.c_value
1046                             + fcn_aux_saved.x_sym.x_misc.x_fsize
1047                             + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1048 #endif
1049                             objfile
1050                 );
1051               within_function = 0;
1052             }
1053           break;
1054
1055         case C_BLOCK:
1056           if (STREQ (cs->c_name, ".bb"))
1057             {
1058               tmpaddr = cs->c_value;
1059               tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1060               push_context (++depth, tmpaddr);
1061             }
1062           else if (STREQ (cs->c_name, ".eb"))
1063             {
1064               if (context_stack_depth <= 0)
1065                 {               /* We attempted to pop an empty context stack */
1066                   complain (&eb_stack_complaint, cs->c_symnum);
1067                   break;
1068                 }
1069
1070               new = pop_context ();
1071               if (depth-- != new->depth)
1072                 {
1073                   complain (&eb_complaint, symnum);
1074                   break;
1075                 }
1076               if (local_symbols && context_stack_depth > 0)
1077                 {
1078                   tmpaddr =
1079                     cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1080                   /* Make a block for the local symbols within.  */
1081                   finish_block (0, &local_symbols, new->old_blocks,
1082                                 new->start_addr, tmpaddr, objfile);
1083                 }
1084               /* Now pop locals of block just finished.  */
1085               local_symbols = new->locals;
1086             }
1087           break;
1088
1089         default:
1090           process_coff_symbol (cs, &main_aux, objfile);
1091           break;
1092         }
1093     }
1094
1095   if (last_source_file)
1096     coff_end_symtab (objfile);
1097
1098   /* Patch up any opaque types (references to types that are not defined
1099      in the file where they are referenced, e.g. "struct foo *bar").  */
1100   ALL_OBJFILE_SYMTABS (objfile, s)
1101     patch_opaque_types (s);
1102
1103   current_objfile = NULL;
1104 }
1105 \f
1106 /* Routines for reading headers and symbols from executable.  */
1107
1108 /* Read the next symbol, swap it, and return it in both internal_syment
1109    form, and coff_symbol form.  Also return its first auxent, if any,
1110    in internal_auxent form, and skip any other auxents.  */
1111
1112 static void
1113 read_one_sym (register struct coff_symbol *cs,
1114               register struct internal_syment *sym,
1115               register union internal_auxent *aux)
1116 {
1117   int i;
1118
1119   cs->c_symnum = symnum;
1120   bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1121   bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1122   cs->c_naux = sym->n_numaux & 0xff;
1123   if (cs->c_naux >= 1)
1124     {
1125       bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1126       bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
1127                             0, cs->c_naux, (char *) aux);
1128       /* If more than one aux entry, read past it (only the first aux
1129          is important). */
1130       for (i = 1; i < cs->c_naux; i++)
1131         bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1132     }
1133   cs->c_name = getsymname (sym);
1134   cs->c_value = sym->n_value;
1135   cs->c_sclass = (sym->n_sclass & 0xff);
1136   cs->c_secnum = sym->n_scnum;
1137   cs->c_type = (unsigned) sym->n_type;
1138   if (!SDB_TYPE (cs->c_type))
1139     cs->c_type = 0;
1140
1141 #if 0
1142   if (cs->c_sclass & 128)
1143     printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
1144 #endif
1145
1146   symnum += 1 + cs->c_naux;
1147
1148   /* The PE file format stores symbol values as offsets within the
1149      section, rather than as absolute addresses.  We correct that
1150      here, if the symbol has an appropriate storage class.  FIXME: We
1151      should use BFD to read the symbols, rather than duplicating the
1152      work here.  */
1153   if (pe_file)
1154     {
1155       switch (cs->c_sclass)
1156         {
1157         case C_EXT:
1158         case C_THUMBEXT:
1159         case C_THUMBEXTFUNC:
1160         case C_SECTION:
1161         case C_NT_WEAK:
1162         case C_STAT:
1163         case C_THUMBSTAT:
1164         case C_THUMBSTATFUNC:
1165         case C_LABEL:
1166         case C_THUMBLABEL:
1167         case C_BLOCK:
1168         case C_FCN:
1169         case C_EFCN:
1170           if (cs->c_secnum != 0)
1171             cs->c_value += cs_section_address (cs, symfile_bfd);
1172           break;
1173         }
1174     }
1175 }
1176 \f
1177 /* Support for string table handling */
1178
1179 static char *stringtab = NULL;
1180
1181 static int
1182 init_stringtab (bfd *abfd, long offset)
1183 {
1184   long length;
1185   int val;
1186   unsigned char lengthbuf[4];
1187
1188   free_stringtab ();
1189
1190   /* If the file is stripped, the offset might be zero, indicating no
1191      string table.  Just return with `stringtab' set to null. */
1192   if (offset == 0)
1193     return 0;
1194
1195   if (bfd_seek (abfd, offset, 0) < 0)
1196     return -1;
1197
1198   val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1199   length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1200
1201   /* If no string table is needed, then the file may end immediately
1202      after the symbols.  Just return with `stringtab' set to null. */
1203   if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1204     return 0;
1205
1206   stringtab = (char *) xmalloc (length);
1207   /* This is in target format (probably not very useful, and not currently
1208      used), not host format.  */
1209   memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1210   if (length == sizeof length)  /* Empty table -- just the count */
1211     return 0;
1212
1213   val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf,
1214                    abfd);
1215   if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1216     return -1;
1217
1218   return 0;
1219 }
1220
1221 static void
1222 free_stringtab (void)
1223 {
1224   if (stringtab)
1225     xfree (stringtab);
1226   stringtab = NULL;
1227 }
1228
1229 static void
1230 free_stringtab_cleanup (void *ignore)
1231 {
1232   free_stringtab ();
1233 }
1234
1235 static char *
1236 getsymname (struct internal_syment *symbol_entry)
1237 {
1238   static char buffer[SYMNMLEN + 1];
1239   char *result;
1240
1241   if (symbol_entry->_n._n_n._n_zeroes == 0)
1242     {
1243       /* FIXME: Probably should be detecting corrupt symbol files by
1244          seeing whether offset points to within the stringtab.  */
1245       result = stringtab + symbol_entry->_n._n_n._n_offset;
1246     }
1247   else
1248     {
1249       strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1250       buffer[SYMNMLEN] = '\0';
1251       result = buffer;
1252     }
1253   return result;
1254 }
1255
1256 /* Extract the file name from the aux entry of a C_FILE symbol.  Return
1257    only the last component of the name.  Result is in static storage and
1258    is only good for temporary use.  */
1259
1260 static char *
1261 coff_getfilename (union internal_auxent *aux_entry)
1262 {
1263   static char buffer[BUFSIZ];
1264   register char *temp;
1265   char *result;
1266
1267   if (aux_entry->x_file.x_n.x_zeroes == 0)
1268     strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1269   else
1270     {
1271       strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1272       buffer[FILNMLEN] = '\0';
1273     }
1274   result = buffer;
1275
1276   /* FIXME: We should not be throwing away the information about what
1277      directory.  It should go into dirname of the symtab, or some such
1278      place.  */
1279   if ((temp = strrchr (result, '/')) != NULL)
1280     result = temp + 1;
1281   return (result);
1282 }
1283 \f
1284 /* Support for line number handling.  */
1285
1286 static char *linetab = NULL;
1287 static long linetab_offset;
1288 static unsigned long linetab_size;
1289
1290 /* Read in all the line numbers for fast lookups later.  Leave them in
1291    external (unswapped) format in memory; we'll swap them as we enter
1292    them into GDB's data structures.  */
1293
1294 static int
1295 init_lineno (bfd *abfd, long offset, int size)
1296 {
1297   int val;
1298
1299   linetab_offset = offset;
1300   linetab_size = size;
1301
1302   free_linetab ();
1303
1304   if (size == 0)
1305     return 0;
1306
1307   if (bfd_seek (abfd, offset, 0) < 0)
1308     return -1;
1309
1310   /* Allocate the desired table, plus a sentinel */
1311   linetab = (char *) xmalloc (size + local_linesz);
1312
1313   val = bfd_bread (linetab, size, abfd);
1314   if (val != size)
1315     return -1;
1316
1317   /* Terminate it with an all-zero sentinel record */
1318   memset (linetab + size, 0, local_linesz);
1319
1320   return 0;
1321 }
1322
1323 static void
1324 free_linetab (void)
1325 {
1326   if (linetab)
1327     xfree (linetab);
1328   linetab = NULL;
1329 }
1330
1331 static void
1332 free_linetab_cleanup (void *ignore)
1333 {
1334   free_linetab ();
1335 }
1336
1337 #if !defined (L_LNNO32)
1338 #define L_LNNO32(lp) ((lp)->l_lnno)
1339 #endif
1340
1341 static void
1342 enter_linenos (long file_offset, register int first_line,
1343                register int last_line, struct objfile *objfile)
1344 {
1345   register char *rawptr;
1346   struct internal_lineno lptr;
1347
1348   if (!linetab)
1349     return;
1350   if (file_offset < linetab_offset)
1351     {
1352       complain (&lineno_complaint, file_offset);
1353       if (file_offset > linetab_size)   /* Too big to be an offset? */
1354         return;
1355       file_offset += linetab_offset;    /* Try reading at that linetab offset */
1356     }
1357
1358   rawptr = &linetab[file_offset - linetab_offset];
1359
1360   /* skip first line entry for each function */
1361   rawptr += local_linesz;
1362   /* line numbers start at one for the first line of the function */
1363   first_line--;
1364
1365   for (;;)
1366     {
1367       bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1368       rawptr += local_linesz;
1369       /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1370       if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1371         record_line (current_subfile, first_line + L_LNNO32 (&lptr),
1372                      lptr.l_addr.l_paddr
1373                      + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)));
1374       else
1375         break;
1376     }
1377 }
1378 \f
1379 static void
1380 patch_type (struct type *type, struct type *real_type)
1381 {
1382   register struct type *target = TYPE_TARGET_TYPE (type);
1383   register struct type *real_target = TYPE_TARGET_TYPE (real_type);
1384   int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1385
1386   TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1387   TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1388   TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target, field_size);
1389
1390   memcpy (TYPE_FIELDS (target), TYPE_FIELDS (real_target), field_size);
1391
1392   if (TYPE_NAME (real_target))
1393     {
1394       if (TYPE_NAME (target))
1395         xfree (TYPE_NAME (target));
1396       TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL);
1397     }
1398 }
1399
1400 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1401    so that they can be used to print out opaque data structures properly.  */
1402
1403 static void
1404 patch_opaque_types (struct symtab *s)
1405 {
1406   register struct block *b;
1407   register int i;
1408   register struct symbol *real_sym;
1409
1410   /* Go through the per-file symbols only */
1411   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1412   ALL_BLOCK_SYMBOLS (b, i, real_sym)
1413     {
1414       /* Find completed typedefs to use to fix opaque ones.
1415          Remove syms from the chain when their types are stored,
1416          but search the whole chain, as there may be several syms
1417          from different files with the same name.  */
1418       if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
1419           SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE &&
1420           TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
1421           TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1422         {
1423           register char *name = SYMBOL_NAME (real_sym);
1424           register int hash = hashname (name);
1425           register struct symbol *sym, *prev;
1426
1427           prev = 0;
1428           for (sym = opaque_type_chain[hash]; sym;)
1429             {
1430               if (name[0] == SYMBOL_NAME (sym)[0] &&
1431                   STREQ (name + 1, SYMBOL_NAME (sym) + 1))
1432                 {
1433                   if (prev)
1434                     {
1435                       SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1436                     }
1437                   else
1438                     {
1439                       opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1440                     }
1441
1442                   patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1443
1444                   if (prev)
1445                     {
1446                       sym = SYMBOL_VALUE_CHAIN (prev);
1447                     }
1448                   else
1449                     {
1450                       sym = opaque_type_chain[hash];
1451                     }
1452                 }
1453               else
1454                 {
1455                   prev = sym;
1456                   sym = SYMBOL_VALUE_CHAIN (sym);
1457                 }
1458             }
1459         }
1460     }
1461 }
1462 \f
1463 static struct symbol *
1464 process_coff_symbol (register struct coff_symbol *cs,
1465                      register union internal_auxent *aux,
1466                      struct objfile *objfile)
1467 {
1468   register struct symbol *sym
1469   = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1470                                      sizeof (struct symbol));
1471   char *name;
1472
1473   memset (sym, 0, sizeof (struct symbol));
1474   name = cs->c_name;
1475   name = EXTERNAL_NAME (name, objfile->obfd);
1476   SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
1477                                     &objfile->symbol_obstack);
1478   SYMBOL_LANGUAGE (sym) = language_auto;
1479   SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
1480
1481   /* default assumptions */
1482   SYMBOL_VALUE (sym) = cs->c_value;
1483   SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1484   SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1485
1486   if (ISFCN (cs->c_type))
1487     {
1488       SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1489       SYMBOL_TYPE (sym) =
1490         lookup_function_type (decode_function_type (cs, cs->c_type, aux));
1491
1492       SYMBOL_CLASS (sym) = LOC_BLOCK;
1493       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1494           || cs->c_sclass == C_THUMBSTATFUNC)
1495         add_symbol_to_list (sym, &file_symbols);
1496       else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1497                || cs->c_sclass == C_THUMBEXTFUNC)
1498         add_symbol_to_list (sym, &global_symbols);
1499     }
1500   else
1501     {
1502       SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
1503       switch (cs->c_sclass)
1504         {
1505         case C_NULL:
1506           break;
1507
1508         case C_AUTO:
1509           SYMBOL_CLASS (sym) = LOC_LOCAL;
1510           add_symbol_to_list (sym, &local_symbols);
1511           break;
1512
1513         case C_THUMBEXT:
1514         case C_THUMBEXTFUNC:
1515         case C_EXT:
1516           SYMBOL_CLASS (sym) = LOC_STATIC;
1517           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1518           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1519           add_symbol_to_list (sym, &global_symbols);
1520           break;
1521
1522         case C_THUMBSTAT:
1523         case C_THUMBSTATFUNC:
1524         case C_STAT:
1525           SYMBOL_CLASS (sym) = LOC_STATIC;
1526           SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1527           SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1528           if (within_function)
1529             {
1530               /* Static symbol of local scope */
1531               add_symbol_to_list (sym, &local_symbols);
1532             }
1533           else
1534             {
1535               /* Static symbol at top level of file */
1536               add_symbol_to_list (sym, &file_symbols);
1537             }
1538           break;
1539
1540 #ifdef C_GLBLREG                /* AMD coff */
1541         case C_GLBLREG:
1542 #endif
1543         case C_REG:
1544           SYMBOL_CLASS (sym) = LOC_REGISTER;
1545           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1546           add_symbol_to_list (sym, &local_symbols);
1547           break;
1548
1549         case C_THUMBLABEL:
1550         case C_LABEL:
1551           break;
1552
1553         case C_ARG:
1554           SYMBOL_CLASS (sym) = LOC_ARG;
1555           add_symbol_to_list (sym, &local_symbols);
1556 #if !defined (BELIEVE_PCC_PROMOTION)
1557           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1558             {
1559               /* If PCC says a parameter is a short or a char,
1560                  aligned on an int boundary, realign it to the
1561                  "little end" of the int.  */
1562               struct type *temptype;
1563               temptype = lookup_fundamental_type (current_objfile,
1564                                                   FT_INTEGER);
1565               if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1566                   && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
1567                   && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
1568                 {
1569                   SYMBOL_VALUE (sym) +=
1570                     TYPE_LENGTH (temptype)
1571                     - TYPE_LENGTH (SYMBOL_TYPE (sym));
1572                 }
1573             }
1574 #endif
1575           break;
1576
1577         case C_REGPARM:
1578           SYMBOL_CLASS (sym) = LOC_REGPARM;
1579           SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
1580           add_symbol_to_list (sym, &local_symbols);
1581 #if !defined (BELIEVE_PCC_PROMOTION)
1582           /* FIXME:  This should retain the current type, since it's just
1583              a register value.  gnu@adobe, 26Feb93 */
1584           {
1585             /* If PCC says a parameter is a short or a char,
1586                it is really an int.  */
1587             struct type *temptype;
1588             temptype =
1589               lookup_fundamental_type (current_objfile, FT_INTEGER);
1590             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1591                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1592               {
1593                 SYMBOL_TYPE (sym) =
1594                   (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1595                    ? lookup_fundamental_type (current_objfile,
1596                                               FT_UNSIGNED_INTEGER)
1597                    : temptype);
1598               }
1599           }
1600 #endif
1601           break;
1602
1603         case C_TPDEF:
1604           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1605           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1606
1607           /* If type has no name, give it one */
1608           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1609             {
1610               if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1611                   || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1612                 {
1613                   /* If we are giving a name to a type such as "pointer to
1614                      foo" or "function returning foo", we better not set
1615                      the TYPE_NAME.  If the program contains "typedef char
1616                      *caddr_t;", we don't want all variables of type char
1617                      * to print as caddr_t.  This is not just a
1618                      consequence of GDB's type management; CC and GCC (at
1619                      least through version 2.4) both output variables of
1620                      either type char * or caddr_t with the type
1621                      refering to the C_TPDEF symbol for caddr_t.  If a future
1622                      compiler cleans this up it GDB is not ready for it
1623                      yet, but if it becomes ready we somehow need to
1624                      disable this check (without breaking the PCC/GCC2.4
1625                      case).
1626
1627                      Sigh.
1628
1629                      Fortunately, this check seems not to be necessary
1630                      for anything except pointers or functions.  */
1631                   ;
1632                 }
1633               else
1634                 TYPE_NAME (SYMBOL_TYPE (sym)) =
1635                   concat (SYMBOL_NAME (sym), NULL);
1636             }
1637 #ifdef CXUX_TARGET
1638           /* Ignore vendor section for Harris CX/UX targets. */
1639           else if (cs->c_name[0] == '$')
1640             break;
1641 #endif /* CXUX_TARGET */
1642
1643           /* Keep track of any type which points to empty structured type,
1644              so it can be filled from a definition from another file.  A
1645              simple forward reference (TYPE_CODE_UNDEF) is not an
1646              empty structured type, though; the forward references
1647              work themselves out via the magic of coff_lookup_type.  */
1648           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
1649               TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
1650               TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
1651               TYPE_CODE_UNDEF)
1652             {
1653               register int i = hashname (SYMBOL_NAME (sym));
1654
1655               SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1656               opaque_type_chain[i] = sym;
1657             }
1658           add_symbol_to_list (sym, &file_symbols);
1659           break;
1660
1661         case C_STRTAG:
1662         case C_UNTAG:
1663         case C_ENTAG:
1664           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1665           SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
1666
1667           /* Some compilers try to be helpful by inventing "fake"
1668              names for anonymous enums, structures, and unions, like
1669              "~0fake" or ".0fake".  Thanks, but no thanks... */
1670           if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1671             if (SYMBOL_NAME (sym) != NULL
1672                 && *SYMBOL_NAME (sym) != '~'
1673                 && *SYMBOL_NAME (sym) != '.')
1674               TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1675                 concat (SYMBOL_NAME (sym), NULL);
1676
1677           add_symbol_to_list (sym, &file_symbols);
1678           break;
1679
1680         default:
1681           break;
1682         }
1683     }
1684   return sym;
1685 }
1686 \f
1687 /* Decode a coff type specifier;  return the type that is meant.  */
1688
1689 static struct type *
1690 decode_type (register struct coff_symbol *cs, unsigned int c_type,
1691              register union internal_auxent *aux)
1692 {
1693   register struct type *type = 0;
1694   unsigned int new_c_type;
1695
1696   if (c_type & ~N_BTMASK)
1697     {
1698       new_c_type = DECREF (c_type);
1699       if (ISPTR (c_type))
1700         {
1701           type = decode_type (cs, new_c_type, aux);
1702           type = lookup_pointer_type (type);
1703         }
1704       else if (ISFCN (c_type))
1705         {
1706           type = decode_type (cs, new_c_type, aux);
1707           type = lookup_function_type (type);
1708         }
1709       else if (ISARY (c_type))
1710         {
1711           int i, n;
1712           register unsigned short *dim;
1713           struct type *base_type, *index_type, *range_type;
1714
1715           /* Define an array type.  */
1716           /* auxent refers to array, not base type */
1717           if (aux->x_sym.x_tagndx.l == 0)
1718             cs->c_naux = 0;
1719
1720           /* shift the indices down */
1721           dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1722           i = 1;
1723           n = dim[0];
1724           for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1725             *dim = *(dim + 1);
1726           *dim = 0;
1727
1728           base_type = decode_type (cs, new_c_type, aux);
1729           index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
1730           range_type =
1731             create_range_type ((struct type *) NULL, index_type, 0, n - 1);
1732           type =
1733             create_array_type ((struct type *) NULL, base_type, range_type);
1734         }
1735       return type;
1736     }
1737
1738   /* Reference to existing type.  This only occurs with the
1739      struct, union, and enum types.  EPI a29k coff
1740      fakes us out by producing aux entries with a nonzero
1741      x_tagndx for definitions of structs, unions, and enums, so we
1742      have to check the c_sclass field.  SCO 3.2v4 cc gets confused
1743      with pointers to pointers to defined structs, and generates
1744      negative x_tagndx fields.  */
1745   if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1746     {
1747       if (cs->c_sclass != C_STRTAG
1748           && cs->c_sclass != C_UNTAG
1749           && cs->c_sclass != C_ENTAG
1750           && aux->x_sym.x_tagndx.l >= 0)
1751         {
1752           type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1753           return type;
1754         }
1755       else
1756         {
1757           complain (&tagndx_bad_complaint, cs->c_name);
1758           /* And fall through to decode_base_type... */
1759         }
1760     }
1761
1762   return decode_base_type (cs, BTYPE (c_type), aux);
1763 }
1764
1765 /* Decode a coff type specifier for function definition;
1766    return the type that the function returns.  */
1767
1768 static struct type *
1769 decode_function_type (register struct coff_symbol *cs, unsigned int c_type,
1770                       register union internal_auxent *aux)
1771 {
1772   if (aux->x_sym.x_tagndx.l == 0)
1773     cs->c_naux = 0;             /* auxent refers to function, not base type */
1774
1775   return decode_type (cs, DECREF (c_type), aux);
1776 }
1777 \f
1778 /* basic C types */
1779
1780 static struct type *
1781 decode_base_type (register struct coff_symbol *cs, unsigned int c_type,
1782                   register union internal_auxent *aux)
1783 {
1784   struct type *type;
1785
1786   switch (c_type)
1787     {
1788     case T_NULL:
1789       /* shows up with "void (*foo)();" structure members */
1790       return lookup_fundamental_type (current_objfile, FT_VOID);
1791
1792 #if 0
1793 /* DGUX actually defines both T_ARG and T_VOID to the same value.  */
1794 #ifdef T_ARG
1795     case T_ARG:
1796       /* Shows up in DGUX, I think.  Not sure where.  */
1797       return lookup_fundamental_type (current_objfile, FT_VOID);        /* shouldn't show up here */
1798 #endif
1799 #endif /* 0 */
1800
1801 #ifdef T_VOID
1802     case T_VOID:
1803       /* Intel 960 COFF has this symbol and meaning.  */
1804       return lookup_fundamental_type (current_objfile, FT_VOID);
1805 #endif
1806
1807     case T_CHAR:
1808       return lookup_fundamental_type (current_objfile, FT_CHAR);
1809
1810     case T_SHORT:
1811       return lookup_fundamental_type (current_objfile, FT_SHORT);
1812
1813     case T_INT:
1814       return lookup_fundamental_type (current_objfile, FT_INTEGER);
1815
1816     case T_LONG:
1817       if (cs->c_sclass == C_FIELD
1818           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1819         return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
1820       else
1821         return lookup_fundamental_type (current_objfile, FT_LONG);
1822
1823     case T_FLOAT:
1824       return lookup_fundamental_type (current_objfile, FT_FLOAT);
1825
1826     case T_DOUBLE:
1827       return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
1828
1829     case T_LNGDBL:
1830       return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
1831
1832     case T_STRUCT:
1833       if (cs->c_naux != 1)
1834         {
1835           /* anonymous structure type */
1836           type = coff_alloc_type (cs->c_symnum);
1837           TYPE_CODE (type) = TYPE_CODE_STRUCT;
1838           TYPE_NAME (type) = NULL;
1839           /* This used to set the tag to "<opaque>".  But I think setting it
1840              to NULL is right, and the printing code can print it as
1841              "struct {...}".  */
1842           TYPE_TAG_NAME (type) = NULL;
1843           INIT_CPLUS_SPECIFIC (type);
1844           TYPE_LENGTH (type) = 0;
1845           TYPE_FIELDS (type) = 0;
1846           TYPE_NFIELDS (type) = 0;
1847         }
1848       else
1849         {
1850           type = coff_read_struct_type (cs->c_symnum,
1851                                         aux->x_sym.x_misc.x_lnsz.x_size,
1852                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1853         }
1854       return type;
1855
1856     case T_UNION:
1857       if (cs->c_naux != 1)
1858         {
1859           /* anonymous union type */
1860           type = coff_alloc_type (cs->c_symnum);
1861           TYPE_NAME (type) = NULL;
1862           /* This used to set the tag to "<opaque>".  But I think setting it
1863              to NULL is right, and the printing code can print it as
1864              "union {...}".  */
1865           TYPE_TAG_NAME (type) = NULL;
1866           INIT_CPLUS_SPECIFIC (type);
1867           TYPE_LENGTH (type) = 0;
1868           TYPE_FIELDS (type) = 0;
1869           TYPE_NFIELDS (type) = 0;
1870         }
1871       else
1872         {
1873           type = coff_read_struct_type (cs->c_symnum,
1874                                         aux->x_sym.x_misc.x_lnsz.x_size,
1875                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1876         }
1877       TYPE_CODE (type) = TYPE_CODE_UNION;
1878       return type;
1879
1880     case T_ENUM:
1881       if (cs->c_naux != 1)
1882         {
1883           /* anonymous enum type */
1884           type = coff_alloc_type (cs->c_symnum);
1885           TYPE_CODE (type) = TYPE_CODE_ENUM;
1886           TYPE_NAME (type) = NULL;
1887           /* This used to set the tag to "<opaque>".  But I think setting it
1888              to NULL is right, and the printing code can print it as
1889              "enum {...}".  */
1890           TYPE_TAG_NAME (type) = NULL;
1891           TYPE_LENGTH (type) = 0;
1892           TYPE_FIELDS (type) = 0;
1893           TYPE_NFIELDS (type) = 0;
1894         }
1895       else
1896         {
1897           type = coff_read_enum_type (cs->c_symnum,
1898                                       aux->x_sym.x_misc.x_lnsz.x_size,
1899                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1900         }
1901       return type;
1902
1903     case T_MOE:
1904       /* shouldn't show up here */
1905       break;
1906
1907     case T_UCHAR:
1908       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
1909
1910     case T_USHORT:
1911       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
1912
1913     case T_UINT:
1914       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
1915
1916     case T_ULONG:
1917       if (cs->c_sclass == C_FIELD
1918           && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
1919         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
1920       else
1921         return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
1922     }
1923   complain (&unexpected_type_complaint, cs->c_name);
1924   return lookup_fundamental_type (current_objfile, FT_VOID);
1925 }
1926 \f
1927 /* This page contains subroutines of read_type.  */
1928
1929 /* Read the description of a structure (or union type) and return an
1930    object describing the type.  */
1931
1932 static struct type *
1933 coff_read_struct_type (int index, int length, int lastsym)
1934 {
1935   struct nextfield
1936     {
1937       struct nextfield *next;
1938       struct field field;
1939     };
1940
1941   register struct type *type;
1942   register struct nextfield *list = 0;
1943   struct nextfield *new;
1944   int nfields = 0;
1945   register int n;
1946   char *name;
1947   struct coff_symbol member_sym;
1948   register struct coff_symbol *ms = &member_sym;
1949   struct internal_syment sub_sym;
1950   union internal_auxent sub_aux;
1951   int done = 0;
1952
1953   type = coff_alloc_type (index);
1954   TYPE_CODE (type) = TYPE_CODE_STRUCT;
1955   INIT_CPLUS_SPECIFIC (type);
1956   TYPE_LENGTH (type) = length;
1957
1958   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
1959     {
1960       read_one_sym (ms, &sub_sym, &sub_aux);
1961       name = ms->c_name;
1962       name = EXTERNAL_NAME (name, current_objfile->obfd);
1963
1964       switch (ms->c_sclass)
1965         {
1966         case C_MOS:
1967         case C_MOU:
1968
1969           /* Get space to record the next field's data.  */
1970           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1971           new->next = list;
1972           list = new;
1973
1974           /* Save the data.  */
1975           list->field.name =
1976             obsavestring (name,
1977                           strlen (name),
1978                           &current_objfile->symbol_obstack);
1979           FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1980           FIELD_BITPOS (list->field) = 8 * ms->c_value;
1981           FIELD_BITSIZE (list->field) = 0;
1982           nfields++;
1983           break;
1984
1985         case C_FIELD:
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) = ms->c_value;
1999           FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
2000           nfields++;
2001           break;
2002
2003         case C_EOS:
2004           done = 1;
2005           break;
2006         }
2007     }
2008   /* Now create the vector of fields, and record how big it is.  */
2009
2010   TYPE_NFIELDS (type) = nfields;
2011   TYPE_FIELDS (type) = (struct field *)
2012     TYPE_ALLOC (type, sizeof (struct field) * nfields);
2013
2014   /* Copy the saved-up fields into the field vector.  */
2015
2016   for (n = nfields; list; list = list->next)
2017     TYPE_FIELD (type, --n) = list->field;
2018
2019   return type;
2020 }
2021 \f
2022 /* Read a definition of an enumeration type,
2023    and create and return a suitable type object.
2024    Also defines the symbols that represent the values of the type.  */
2025
2026 /* ARGSUSED */
2027 static struct type *
2028 coff_read_enum_type (int index, int length, int lastsym)
2029 {
2030   register struct symbol *sym;
2031   register struct type *type;
2032   int nsyms = 0;
2033   int done = 0;
2034   struct pending **symlist;
2035   struct coff_symbol member_sym;
2036   register struct coff_symbol *ms = &member_sym;
2037   struct internal_syment sub_sym;
2038   union internal_auxent sub_aux;
2039   struct pending *osyms, *syms;
2040   int o_nsyms;
2041   register int n;
2042   char *name;
2043   int unsigned_enum = 1;
2044
2045   type = coff_alloc_type (index);
2046   if (within_function)
2047     symlist = &local_symbols;
2048   else
2049     symlist = &file_symbols;
2050   osyms = *symlist;
2051   o_nsyms = osyms ? osyms->nsyms : 0;
2052
2053   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2054     {
2055       read_one_sym (ms, &sub_sym, &sub_aux);
2056       name = ms->c_name;
2057       name = EXTERNAL_NAME (name, current_objfile->obfd);
2058
2059       switch (ms->c_sclass)
2060         {
2061         case C_MOE:
2062           sym = (struct symbol *) obstack_alloc
2063             (&current_objfile->symbol_obstack,
2064              sizeof (struct symbol));
2065           memset (sym, 0, sizeof (struct symbol));
2066
2067           SYMBOL_NAME (sym) =
2068             obsavestring (name, strlen (name),
2069                           &current_objfile->symbol_obstack);
2070           SYMBOL_CLASS (sym) = LOC_CONST;
2071           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2072           SYMBOL_VALUE (sym) = ms->c_value;
2073           add_symbol_to_list (sym, symlist);
2074           nsyms++;
2075           break;
2076
2077         case C_EOS:
2078           /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2079              up the count of how many symbols to read.  So stop
2080              on .eos.  */
2081           done = 1;
2082           break;
2083         }
2084     }
2085
2086   /* Now fill in the fields of the type-structure.  */
2087
2088   if (length > 0)
2089     TYPE_LENGTH (type) = length;
2090   else
2091     TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;      /* Assume ints */
2092   TYPE_CODE (type) = TYPE_CODE_ENUM;
2093   TYPE_NFIELDS (type) = nsyms;
2094   TYPE_FIELDS (type) = (struct field *)
2095     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2096
2097   /* Find the symbols for the values and put them into the type.
2098      The symbols can be found in the symlist that we put them on
2099      to cause them to be defined.  osyms contains the old value
2100      of that symlist; everything up to there was defined by us.  */
2101   /* Note that we preserve the order of the enum constants, so
2102      that in something like "enum {FOO, LAST_THING=FOO}" we print
2103      FOO, not LAST_THING.  */
2104
2105   for (syms = *symlist, n = 0; syms; syms = syms->next)
2106     {
2107       int j = 0;
2108
2109       if (syms == osyms)
2110         j = o_nsyms;
2111       for (; j < syms->nsyms; j++, n++)
2112         {
2113           struct symbol *xsym = syms->symbol[j];
2114           SYMBOL_TYPE (xsym) = type;
2115           TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
2116           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
2117           if (SYMBOL_VALUE (xsym) < 0)
2118             unsigned_enum = 0;
2119           TYPE_FIELD_BITSIZE (type, n) = 0;
2120         }
2121       if (syms == osyms)
2122         break;
2123     }
2124
2125   if (unsigned_enum)
2126     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
2127
2128   return type;
2129 }
2130
2131 /* Register our ability to parse symbols for coff BFD files. */
2132
2133 static struct sym_fns coff_sym_fns =
2134 {
2135   bfd_target_coff_flavour,
2136   coff_new_init,                /* sym_new_init: init anything gbl to entire symtab */
2137   coff_symfile_init,            /* sym_init: read initial info, setup for sym_read() */
2138   coff_symfile_read,            /* sym_read: read a symbol file into symtab */
2139   coff_symfile_finish,          /* sym_finish: finished with file, cleanup */
2140   default_symfile_offsets,      /* sym_offsets:  xlate external to internal form */
2141   NULL                          /* next: pointer to next struct sym_fns */
2142 };
2143
2144 void
2145 _initialize_coffread (void)
2146 {
2147   add_symtab_fns (&coff_sym_fns);
2148 }