1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
4 Free Software Foundation, Inc.
5 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
7 This file is part of GDB.
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 3 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "breakpoint.h"
29 #include "gdb_obstack.h"
31 #include "gdb_string.h"
34 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
35 #include "libcoff.h" /* FIXME secret internal data from BFD */
38 #include "gdb-stabs.h"
39 #include "stabsread.h"
40 #include "complaints.h"
42 #include "gdb_assert.h"
44 #include "dictionary.h"
46 #include "coff-pe-read.h"
48 extern void _initialize_coffread (void);
50 struct coff_symfile_info
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 */
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 */
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)
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
71 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
73 /* Core address of start and end of text of current source file.
74 This comes from a ".text" symbol where x_nlinno > 0. */
76 static CORE_ADDR current_source_start_addr;
77 static CORE_ADDR current_source_end_addr;
79 /* The addresses of the symbol table stream and number of symbols
80 of the object file we are reading (as copied into core). */
82 static bfd *nlist_bfd_global;
83 static int nlist_nsyms_global;
86 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
88 static char *temp_sym;
89 static char *temp_aux;
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 . */
97 static unsigned local_n_btmask;
98 static unsigned local_n_btshft;
99 static unsigned local_n_tmask;
100 static unsigned local_n_tshift;
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
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.) */
112 static unsigned local_linesz;
113 static unsigned local_symesz;
114 static unsigned local_auxesz;
116 /* This is set if this is a PE format file. */
120 /* Chain of typedefs of pointers to empty struct/union types.
121 They are chained thru the SYMBOL_VALUE_CHAIN. */
123 static struct symbol *opaque_type_chain[HASHSIZE];
125 /* Simplified internal version of coff symbol table information */
130 int c_symnum; /* symbol number of this entry */
131 int c_naux; /* 0 if syment only, 1 if syment + auxent, etc */
138 extern void stabsread_clear_cache (void);
140 static struct type *coff_read_struct_type (int, int, int);
142 static struct type *decode_base_type (struct coff_symbol *,
143 unsigned int, union internal_auxent *);
145 static struct type *decode_type (struct coff_symbol *, unsigned int,
146 union internal_auxent *);
148 static struct type *decode_function_type (struct coff_symbol *,
150 union internal_auxent *);
152 static struct type *coff_read_enum_type (int, int, int);
154 static struct symbol *process_coff_symbol (struct coff_symbol *,
155 union internal_auxent *,
158 static void patch_opaque_types (struct symtab *);
160 static void enter_linenos (long, int, int, struct objfile *);
162 static void free_linetab (void);
164 static void free_linetab_cleanup (void *ignore);
166 static int init_lineno (bfd *, long, int);
168 static char *getsymname (struct internal_syment *);
170 static char *coff_getfilename (union internal_auxent *);
172 static void free_stringtab (void);
174 static void free_stringtab_cleanup (void *ignore);
176 static int init_stringtab (bfd *, long);
178 static void read_one_sym (struct coff_symbol *,
179 struct internal_syment *, union internal_auxent *);
181 static void coff_symtab_read (long, unsigned int, struct objfile *);
183 /* We are called once per section from coff_symfile_read. We
184 need to examine each section we are passed, check to see
185 if it is something we are interested in processing, and
186 if so, stash away some access information for the section.
188 FIXME: The section names should not be hardwired strings (what
189 should they be? I don't think most object file formats have enough
190 section flags to specify what kind of debug section it is
194 coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
196 struct coff_symfile_info *csi;
199 csi = (struct coff_symfile_info *) csip;
200 name = bfd_get_section_name (abfd, sectp);
201 if (DEPRECATED_STREQ (name, ".text"))
203 csi->textaddr = bfd_section_vma (abfd, sectp);
204 csi->textsize += bfd_section_size (abfd, sectp);
206 else if (strncmp (name, ".text", sizeof ".text" - 1) == 0)
208 csi->textsize += bfd_section_size (abfd, sectp);
210 else if (DEPRECATED_STREQ (name, ".stabstr"))
212 csi->stabstrsect = sectp;
214 else if (strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
218 /* We can have multiple .stab sections if linked with
220 for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
225 struct stab_section_list *n, **pn;
227 n = ((struct stab_section_list *)
228 xmalloc (sizeof (struct stab_section_list)));
231 for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)
235 /* This will be run after coffstab_build_psymtabs is called
236 in coff_symfile_read, at which point we no longer need
238 make_cleanup (xfree, n);
243 /* Return the section_offsets* that CS points to. */
244 static int cs_to_section (struct coff_symbol *, struct objfile *);
246 struct find_targ_sec_arg
253 find_targ_sec (bfd *abfd, asection *sect, void *obj)
255 struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
256 if (sect->target_index == args->targ_index)
257 *args->resultp = sect;
260 /* Return the bfd_section that CS points to. */
261 static struct bfd_section*
262 cs_to_bfd_section (struct coff_symbol *cs, struct objfile *objfile)
264 asection *sect = NULL;
265 struct find_targ_sec_arg args;
267 args.targ_index = cs->c_secnum;
268 args.resultp = §
269 bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
273 /* Return the section number (SECT_OFF_*) that CS points to. */
275 cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
277 asection *sect = cs_to_bfd_section (cs, objfile);
279 return SECT_OFF_TEXT (objfile);
283 /* Return the address of the section of a COFF symbol. */
285 static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);
288 cs_section_address (struct coff_symbol *cs, bfd *abfd)
290 asection *sect = NULL;
291 struct find_targ_sec_arg args;
294 args.targ_index = cs->c_secnum;
295 args.resultp = §
296 bfd_map_over_sections (abfd, find_targ_sec, &args);
298 addr = bfd_get_section_vma (objfile->obfd, sect);
302 /* Look up a coff type-number index. Return the address of the slot
303 where the type for that index is stored.
304 The type-number is in INDEX.
306 This can be used for finding the type associated with that index
307 or for associating a new type with the index. */
309 static struct type **
310 coff_lookup_type (int index)
312 if (index >= type_vector_length)
314 int old_vector_length = type_vector_length;
316 type_vector_length *= 2;
317 if (index /* is still */ >= type_vector_length)
318 type_vector_length = index * 2;
320 type_vector = (struct type **)
321 xrealloc ((char *) type_vector,
322 type_vector_length * sizeof (struct type *));
323 memset (&type_vector[old_vector_length], 0,
324 (type_vector_length - old_vector_length) * sizeof (struct type *));
326 return &type_vector[index];
329 /* Make sure there is a type allocated for type number index
330 and return the type object.
331 This can create an empty (zeroed) type object. */
334 coff_alloc_type (int index)
336 struct type **type_addr = coff_lookup_type (index);
337 struct type *type = *type_addr;
339 /* If we are referring to a type not known at all yet,
340 allocate an empty type for it.
341 We will fill it in later if we find out how. */
344 type = alloc_type (current_objfile);
350 /* Start a new symtab for a new source file.
351 This is called when a COFF ".file" symbol is seen;
352 it indicates the start of data for one original source file. */
355 coff_start_symtab (char *name)
358 /* We fill in the filename later. start_symtab puts
359 this pointer into last_source_file and we put it in
360 subfiles->name, which end_symtab frees; that's why
361 it must be malloc'd. */
362 savestring (name, strlen (name)),
363 /* We never know the directory name for COFF. */
365 /* The start address is irrelevant, since we set
366 last_source_start_addr in coff_end_symtab. */
368 record_debugformat ("COFF");
371 /* Save the vital information from when starting to read a file,
372 for use when closing off the current file.
373 NAME is the file name the symbols came from, START_ADDR is the first
374 text address for the file, and SIZE is the number of bytes of text. */
377 complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size)
379 if (last_source_file != NULL)
380 xfree (last_source_file);
381 last_source_file = savestring (name, strlen (name));
382 current_source_start_addr = start_addr;
383 current_source_end_addr = start_addr + size;
386 /* Finish the symbol definitions for one main source file,
387 close off all the lexical contexts for that file
388 (creating struct block's for them), then make the
389 struct symtab for that file and put it in the list of all such. */
392 coff_end_symtab (struct objfile *objfile)
394 struct symtab *symtab;
396 last_source_start_addr = current_source_start_addr;
398 symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile));
401 free_named_symtabs (symtab->filename);
403 /* Reinitialize for beginning of new file. */
404 last_source_file = NULL;
407 static struct minimal_symbol *
408 record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address,
409 enum minimal_symbol_type type, int section,
410 struct objfile *objfile)
412 struct bfd_section *bfd_section;
413 /* We don't want TDESC entry points in the minimal symbol table */
414 if (cs->c_name[0] == '@')
417 bfd_section = cs_to_bfd_section (cs, objfile);
418 return prim_record_minimal_symbol_and_info (cs->c_name, address, type,
419 NULL, section, bfd_section, objfile);
422 /* coff_symfile_init ()
423 is the coff-specific initialization routine for reading symbols.
424 It is passed a struct objfile which contains, among other things,
425 the BFD for the file whose symbols are being read, and a slot for
426 a pointer to "private data" which we fill with cookies and other
427 treats for coff_symfile_read ().
429 We will only be called if this is a COFF or COFF-like file.
430 BFD handles figuring out the format of the file, and code in symtab.c
431 uses BFD's determination to vector to us.
433 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
436 coff_symfile_init (struct objfile *objfile)
438 /* Allocate struct to keep track of stab reading. */
439 objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
440 xmalloc (sizeof (struct dbx_symfile_info));
442 memset (objfile->deprecated_sym_stab_info, 0,
443 sizeof (struct dbx_symfile_info));
445 /* Allocate struct to keep track of the symfile */
446 objfile->deprecated_sym_private = xmalloc (sizeof (struct coff_symfile_info));
448 memset (objfile->deprecated_sym_private, 0, sizeof (struct coff_symfile_info));
450 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
451 find this causes a significant slowdown in gdb then we could
452 set it in the debug symbol readers only when necessary. */
453 objfile->flags |= OBJF_REORDERED;
455 init_entry_point_info (objfile);
458 /* This function is called for every section; it finds the outer limits
459 of the line table (minimum and maximum file offset) so that the
460 mainline code can read the whole thing for efficiency. */
463 find_linenos (bfd *abfd, struct bfd_section *asect, void *vpinfo)
465 struct coff_symfile_info *info;
467 file_ptr offset, maxoff;
469 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
470 count = asect->lineno_count;
475 size = count * local_linesz;
477 info = (struct coff_symfile_info *) vpinfo;
478 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
479 offset = asect->line_filepos;
482 if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
483 info->min_lineno_offset = offset;
485 maxoff = offset + size;
486 if (maxoff > info->max_lineno_offset)
487 info->max_lineno_offset = maxoff;
491 /* The BFD for this file -- only good while we're actively reading
492 symbols into a psymtab or a symtab. */
494 static bfd *symfile_bfd;
496 /* Read a symbol file, after initialization by coff_symfile_init. */
499 coff_symfile_read (struct objfile *objfile, int mainline)
501 struct coff_symfile_info *info;
502 struct dbx_symfile_info *dbxinfo;
503 bfd *abfd = objfile->obfd;
504 coff_data_type *cdata = coff_data (abfd);
505 char *name = bfd_get_filename (abfd);
507 unsigned int num_symbols;
509 int stringtab_offset;
510 struct cleanup *back_to, *cleanup_minimal_symbols;
515 info = (struct coff_symfile_info *) objfile->deprecated_sym_private;
516 dbxinfo = objfile->deprecated_sym_stab_info;
517 symfile_bfd = abfd; /* Kludge for swap routines */
519 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
520 num_symbols = bfd_get_symcount (abfd); /* How many syms */
521 symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
522 stringtab_offset = symtab_offset + /* String table file offset */
523 num_symbols * cdata->local_symesz;
525 /* Set a few file-statics that give us specific information about
526 the particular COFF file format we're reading. */
527 local_n_btmask = cdata->local_n_btmask;
528 local_n_btshft = cdata->local_n_btshft;
529 local_n_tmask = cdata->local_n_tmask;
530 local_n_tshift = cdata->local_n_tshift;
531 local_linesz = cdata->local_linesz;
532 local_symesz = cdata->local_symesz;
533 local_auxesz = cdata->local_auxesz;
535 /* Allocate space for raw symbol and aux entries, based on their
536 space requirements as reported by BFD. */
537 temp_sym = (char *) xmalloc
538 (cdata->local_symesz + cdata->local_auxesz);
539 temp_aux = temp_sym + cdata->local_symesz;
540 back_to = make_cleanup (free_current_contents, &temp_sym);
542 /* We need to know whether this is a PE file, because in PE files,
543 unlike standard COFF files, symbol values are stored as offsets
544 from the section address, rather than as absolute addresses.
545 FIXME: We should use BFD to read the symbol table, and thus avoid
548 strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0
549 || strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0;
553 info->min_lineno_offset = 0;
554 info->max_lineno_offset = 0;
556 /* Only read line number information if we have symbols.
558 On Windows NT, some of the system's DLL's have sections with
559 PointerToLinenumbers fields that are non-zero, but point at
560 random places within the image file. (In the case I found,
561 KERNEL32.DLL's .text section has a line number info pointer that
562 points into the middle of the string `lib\\i386\kernel32.dll'.)
564 However, these DLL's also have no symbols. The line number
565 tables are meaningless without symbols. And in fact, GDB never
566 uses the line number information unless there are symbols. So we
567 can avoid spurious error messages (and maybe run a little
568 faster!) by not even reading the line number table unless we have
572 /* Read the line number table, all at once. */
573 bfd_map_over_sections (abfd, find_linenos, (void *) info);
575 make_cleanup (free_linetab_cleanup, 0 /*ignore*/);
576 val = init_lineno (abfd, info->min_lineno_offset,
577 info->max_lineno_offset - info->min_lineno_offset);
579 error (_("\"%s\": error reading line numbers."), name);
582 /* Now read the string table, all at once. */
584 make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
585 val = init_stringtab (abfd, stringtab_offset);
587 error (_("\"%s\": can't get string table"), name);
589 init_minimal_symbol_collection ();
590 cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols ();
592 /* Now that the executable file is positioned at symbol table,
593 process it and define symbols accordingly. */
595 coff_symtab_read ((long) symtab_offset, num_symbols, objfile);
597 /* Install any minimal symbols that have been collected as the current
598 minimal symbols for this objfile. */
600 install_minimal_symbols (objfile);
602 /* Free the installed minimal symbol data. */
603 do_cleanups (cleanup_minimal_symbols);
605 /* If we are reinitializing, or if we have not loaded syms yet,
606 empty the psymtab. "mainline" is cleared so the *_read_psymtab
607 functions do not all re-initialize it. */
610 init_psymbol_list (objfile, 0);
614 bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
618 if (!info->stabstrsect)
620 error (_("The debugging information in `%s' is corrupted.\n"
621 "The file has a `.stabs' section, but no `.stabstr' section."),
625 /* FIXME: dubious. Why can't we use something normal like
626 bfd_get_section_contents? */
627 bfd_seek (abfd, abfd->where, 0);
629 stabstrsize = bfd_section_size (abfd, info->stabstrsect);
631 coffstab_build_psymtabs (objfile,
633 info->textaddr, info->textsize,
635 info->stabstrsect->filepos, stabstrsize);
637 if (dwarf2_has_info (objfile))
639 /* DWARF2 sections. */
640 dwarf2_build_psymtabs (objfile, mainline);
643 dwarf2_build_frame_info (objfile);
645 do_cleanups (back_to);
649 coff_new_init (struct objfile *ignore)
653 /* Perform any local cleanups required when we are done with a particular
654 objfile. I.E, we are in the process of discarding all symbol information
655 for an objfile, freeing up all memory held for it, and unlinking the
656 objfile struct from the global list of known objfiles. */
659 coff_symfile_finish (struct objfile *objfile)
661 if (objfile->deprecated_sym_private != NULL)
663 xfree (objfile->deprecated_sym_private);
666 /* Let stabs reader clean up */
667 stabsread_clear_cache ();
671 /* Given pointers to a symbol table in coff style exec file,
672 analyze them and create struct symtab's describing the symbols.
673 NSYMS is the number of symbols in the symbol table.
674 We read them one at a time using read_one_sym (). */
677 coff_symtab_read (long symtab_offset, unsigned int nsyms,
678 struct objfile *objfile)
680 struct context_stack *new;
681 struct coff_symbol coff_symbol;
682 struct coff_symbol *cs = &coff_symbol;
683 static struct internal_syment main_sym;
684 static union internal_auxent main_aux;
685 struct coff_symbol fcn_cs_saved;
686 static struct internal_syment fcn_sym_saved;
687 static union internal_auxent fcn_aux_saved;
689 /* A .file is open. */
690 int in_source_file = 0;
691 int next_file_symnum = -1;
692 /* Name of the current file. */
693 char *filestring = "";
695 int fcn_first_line = 0;
696 CORE_ADDR fcn_first_line_addr = 0;
697 int fcn_last_line = 0;
698 int fcn_start_addr = 0;
699 long fcn_line_ptr = 0;
702 struct minimal_symbol *msym;
704 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
705 it's hard to know I've really worked around it. The fix should be
706 harmless, anyway). The symptom of the bug is that the first
707 fread (in read_one_sym), will (in my example) actually get data
708 from file offset 268, when the fseek was to 264 (and ftell shows
709 264). This causes all hell to break loose. I was unable to
710 reproduce this on a short test program which operated on the same
711 file, performing (I think) the same sequence of operations.
713 It stopped happening when I put in this (former) rewind().
715 FIXME: Find out if this has been reported to Sun, whether it has
716 been fixed in a later release, etc. */
718 bfd_seek (objfile->obfd, 0, 0);
720 /* Position to read the symbol table. */
721 val = bfd_seek (objfile->obfd, (long) symtab_offset, 0);
723 perror_with_name (objfile->name);
725 current_objfile = objfile;
726 nlist_bfd_global = objfile->obfd;
727 nlist_nsyms_global = nsyms;
728 last_source_file = NULL;
729 memset (opaque_type_chain, 0, sizeof opaque_type_chain);
731 if (type_vector) /* Get rid of previous one */
733 type_vector_length = 160;
734 type_vector = (struct type **)
735 xmalloc (type_vector_length * sizeof (struct type *));
736 memset (type_vector, 0, type_vector_length * sizeof (struct type *));
738 coff_start_symtab ("");
741 while (symnum < nsyms)
743 QUIT; /* Make this command interruptable. */
745 read_one_sym (cs, &main_sym, &main_aux);
747 if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
749 if (last_source_file)
750 coff_end_symtab (objfile);
752 coff_start_symtab ("_globals_");
753 complete_symtab ("_globals_", 0, 0);
754 /* done with all files, everything from here on out is globals */
757 /* Special case for file with type declarations only, no text. */
758 if (!last_source_file && SDB_TYPE (cs->c_type)
759 && cs->c_secnum == N_DEBUG)
760 complete_symtab (filestring, 0, 0);
762 /* Typedefs should not be treated as symbol definitions. */
763 if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
765 /* Record all functions -- external and static -- in minsyms. */
766 int section = cs_to_section (cs, objfile);
767 tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
768 record_minimal_symbol (cs, tmpaddr, mst_text, section, objfile);
770 fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
771 fcn_start_addr = tmpaddr;
773 fcn_sym_saved = main_sym;
774 fcn_aux_saved = main_aux;
778 switch (cs->c_sclass)
787 complaint (&symfile_complaints, _("Bad n_sclass for symbol %s"),
792 /* c_value field contains symnum of next .file entry in table
793 or symnum of first global after last .file. */
794 next_file_symnum = cs->c_value;
796 filestring = coff_getfilename (&main_aux);
800 /* Complete symbol table for last object file
801 containing debugging information. */
802 if (last_source_file)
804 coff_end_symtab (objfile);
805 coff_start_symtab (filestring);
810 /* C_LABEL is used for labels and static functions. Including
811 it here allows gdb to see static functions when no debug
812 info is available. */
814 /* However, labels within a function can make weird backtraces,
815 so filter them out (from phdm@macqel.be). */
821 case C_THUMBSTATFUNC:
822 if (cs->c_name[0] == '.')
824 if (DEPRECATED_STREQ (cs->c_name, ".text"))
826 /* FIXME: don't wire in ".text" as section name
828 /* Check for in_source_file deals with case of
829 a file with debugging symbols
830 followed by a later file with no symbols. */
832 complete_symtab (filestring,
833 cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
834 main_aux.x_scn.x_scnlen);
837 /* flush rest of '.' symbols */
840 else if (!SDB_TYPE (cs->c_type)
841 && cs->c_name[0] == 'L'
842 && (strncmp (cs->c_name, "LI%", 3) == 0
843 || strncmp (cs->c_name, "LF%", 3) == 0
844 || strncmp (cs->c_name, "LC%", 3) == 0
845 || strncmp (cs->c_name, "LP%", 3) == 0
846 || strncmp (cs->c_name, "LPB%", 4) == 0
847 || strncmp (cs->c_name, "LBB%", 4) == 0
848 || strncmp (cs->c_name, "LBE%", 4) == 0
849 || strncmp (cs->c_name, "LPBX%", 5) == 0))
850 /* At least on a 3b1, gcc generates swbeg and string labels
851 that look like this. Ignore them. */
853 /* fall in for static symbols that don't start with '.' */
858 /* Record it in the minimal symbols regardless of
859 SDB_TYPE. This parallels what we do for other debug
860 formats, and probably is needed to make
861 print_address_symbolic work right without the (now
862 gone) "set fast-symbolic-addr off" kludge. */
864 enum minimal_symbol_type ms_type;
867 if (cs->c_secnum == N_UNDEF)
869 /* This is a common symbol. See if the target
870 environment knows where it has been relocated to. */
872 if (target_lookup_symbol (cs->c_name, &reladdr))
874 /* Error in lookup; ignore symbol. */
878 /* The address has already been relocated; make sure that
879 objfile_relocate doesn't relocate it again. */
881 ms_type = cs->c_sclass == C_EXT
882 || cs->c_sclass == C_THUMBEXT ?
883 mst_bss : mst_file_bss;
885 else if (cs->c_secnum == N_ABS)
887 /* Use the correct minimal symbol type (and don't
888 relocate) for absolute values. */
890 sec = cs_to_section (cs, objfile);
891 tmpaddr = cs->c_value;
895 asection *bfd_section = cs_to_bfd_section (cs, objfile);
896 sec = cs_to_section (cs, objfile);
897 tmpaddr = cs->c_value;
898 /* Statics in a PE file also get relocated */
899 if (cs->c_sclass == C_EXT
900 || cs->c_sclass == C_THUMBEXTFUNC
901 || cs->c_sclass == C_THUMBEXT
902 || (pe_file && (cs->c_sclass == C_STAT)))
903 tmpaddr += ANOFFSET (objfile->section_offsets, sec);
905 if (bfd_section->flags & SEC_CODE)
908 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
909 || cs->c_sclass == C_THUMBEXT ?
910 mst_text : mst_file_text;
911 tmpaddr = gdbarch_smash_text_address
912 (current_gdbarch, tmpaddr);
914 else if (bfd_section->flags & SEC_ALLOC
915 && bfd_section->flags & SEC_LOAD)
918 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
919 mst_data : mst_file_data;
921 else if (bfd_section->flags & SEC_ALLOC)
924 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
925 mst_bss : mst_file_bss;
928 ms_type = mst_unknown;
931 msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile);
933 gdbarch_coff_make_msymbol_special
934 (current_gdbarch, cs->c_sclass, msym);
936 if (SDB_TYPE (cs->c_type))
939 sym = process_coff_symbol
940 (cs, &main_aux, objfile);
941 SYMBOL_VALUE (sym) = tmpaddr;
942 SYMBOL_SECTION (sym) = sec;
948 if (DEPRECATED_STREQ (cs->c_name, ".bf"))
952 /* value contains address of first non-init type code */
953 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
954 contains line number of '{' } */
956 complaint (&symfile_complaints,
957 _("`.bf' symbol %d has no aux entry"), cs->c_symnum);
958 fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
959 fcn_first_line_addr = cs->c_value;
961 /* Might want to check that locals are 0 and
962 context_stack_depth is zero, and complain if not. */
965 new = push_context (depth, fcn_start_addr);
966 fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
968 process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
970 else if (DEPRECATED_STREQ (cs->c_name, ".ef"))
972 if (!within_function)
973 error (_("Bad coff function information."));
974 /* the value of .ef is the address of epilogue code;
975 not useful for gdb. */
976 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
977 contains number of lines to '}' */
979 if (context_stack_depth <= 0)
980 { /* We attempted to pop an empty context stack */
981 complaint (&symfile_complaints,
982 _("`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d"),
988 new = pop_context ();
989 /* Stack must be empty now. */
990 if (context_stack_depth > 0 || new == NULL)
992 complaint (&symfile_complaints,
993 _("Unmatched .ef symbol(s) ignored starting at symnum %d"),
1000 complaint (&symfile_complaints,
1001 _("`.ef' symbol %d has no aux entry"), cs->c_symnum);
1002 fcn_last_line = 0x7FFFFFFF;
1006 fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1008 /* fcn_first_line is the line number of the opening '{'.
1009 Do not record it - because it would affect gdb's idea
1010 of the line number of the first statement of the function -
1011 except for one-line functions, for which it is also the line
1012 number of all the statements and of the closing '}', and
1013 for which we do not have any other statement-line-number. */
1014 if (fcn_last_line == 1)
1015 record_line (current_subfile, fcn_first_line,
1016 fcn_first_line_addr);
1018 enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
1021 finish_block (new->name, &local_symbols, new->old_blocks,
1023 #if defined (FUNCTION_EPILOGUE_SIZE)
1024 /* This macro should be defined only on
1026 fcn_aux_saved.x_sym.x_misc.x_fsize
1027 field is always zero.
1028 So use the .bf record information that
1029 points to the epilogue and add the size
1032 + FUNCTION_EPILOGUE_SIZE
1033 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1035 fcn_cs_saved.c_value
1036 + fcn_aux_saved.x_sym.x_misc.x_fsize
1037 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
1041 within_function = 0;
1046 if (DEPRECATED_STREQ (cs->c_name, ".bb"))
1048 tmpaddr = cs->c_value;
1049 tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1050 push_context (++depth, tmpaddr);
1052 else if (DEPRECATED_STREQ (cs->c_name, ".eb"))
1054 if (context_stack_depth <= 0)
1055 { /* We attempted to pop an empty context stack */
1056 complaint (&symfile_complaints,
1057 _("`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d"),
1062 new = pop_context ();
1063 if (depth-- != new->depth)
1065 complaint (&symfile_complaints,
1066 _("Mismatched .eb symbol ignored starting at symnum %d"),
1070 if (local_symbols && context_stack_depth > 0)
1073 cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1074 /* Make a block for the local symbols within. */
1075 finish_block (0, &local_symbols, new->old_blocks,
1076 new->start_addr, tmpaddr, objfile);
1078 /* Now pop locals of block just finished. */
1079 local_symbols = new->locals;
1084 process_coff_symbol (cs, &main_aux, objfile);
1089 if ((nsyms == 0) && (pe_file))
1091 /* We've got no debugging symbols, but it's is a portable
1092 executable, so try to read the export table */
1093 read_pe_exported_syms (objfile);
1096 if (last_source_file)
1097 coff_end_symtab (objfile);
1099 /* Patch up any opaque types (references to types that are not defined
1100 in the file where they are referenced, e.g. "struct foo *bar"). */
1101 ALL_OBJFILE_SYMTABS (objfile, s)
1102 patch_opaque_types (s);
1104 current_objfile = NULL;
1107 /* Routines for reading headers and symbols from executable. */
1109 /* Read the next symbol, swap it, and return it in both internal_syment
1110 form, and coff_symbol form. Also return its first auxent, if any,
1111 in internal_auxent form, and skip any other auxents. */
1114 read_one_sym (struct coff_symbol *cs,
1115 struct internal_syment *sym,
1116 union internal_auxent *aux)
1119 bfd_size_type bytes;
1121 cs->c_symnum = symnum;
1122 bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1123 if (bytes != local_symesz)
1124 error ("%s: error reading symbols", current_objfile->name);
1125 bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1126 cs->c_naux = sym->n_numaux & 0xff;
1127 if (cs->c_naux >= 1)
1129 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1130 if (bytes != local_auxesz)
1131 error ("%s: error reading symbols", current_objfile->name);
1132 bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
1133 0, cs->c_naux, (char *) aux);
1134 /* If more than one aux entry, read past it (only the first aux
1136 for (i = 1; i < cs->c_naux; i++)
1138 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1139 if (bytes != local_auxesz)
1140 error ("%s: error reading symbols", current_objfile->name);
1143 cs->c_name = getsymname (sym);
1144 cs->c_value = sym->n_value;
1145 cs->c_sclass = (sym->n_sclass & 0xff);
1146 cs->c_secnum = sym->n_scnum;
1147 cs->c_type = (unsigned) sym->n_type;
1148 if (!SDB_TYPE (cs->c_type))
1152 if (cs->c_sclass & 128)
1153 printf (_("thumb symbol %s, class 0x%x\n"), cs->c_name, cs->c_sclass);
1156 symnum += 1 + cs->c_naux;
1158 /* The PE file format stores symbol values as offsets within the
1159 section, rather than as absolute addresses. We correct that
1160 here, if the symbol has an appropriate storage class. FIXME: We
1161 should use BFD to read the symbols, rather than duplicating the
1165 switch (cs->c_sclass)
1169 case C_THUMBEXTFUNC:
1174 case C_THUMBSTATFUNC:
1180 if (cs->c_secnum != 0)
1181 cs->c_value += cs_section_address (cs, symfile_bfd);
1187 /* Support for string table handling */
1189 static char *stringtab = NULL;
1192 init_stringtab (bfd *abfd, long offset)
1196 unsigned char lengthbuf[4];
1200 /* If the file is stripped, the offset might be zero, indicating no
1201 string table. Just return with `stringtab' set to null. */
1205 if (bfd_seek (abfd, offset, 0) < 0)
1208 val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1209 length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1211 /* If no string table is needed, then the file may end immediately
1212 after the symbols. Just return with `stringtab' set to null. */
1213 if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1216 stringtab = (char *) xmalloc (length);
1217 /* This is in target format (probably not very useful, and not currently
1218 used), not host format. */
1219 memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1220 if (length == sizeof length) /* Empty table -- just the count */
1223 val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf,
1225 if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1232 free_stringtab (void)
1240 free_stringtab_cleanup (void *ignore)
1246 getsymname (struct internal_syment *symbol_entry)
1248 static char buffer[SYMNMLEN + 1];
1251 if (symbol_entry->_n._n_n._n_zeroes == 0)
1253 /* FIXME: Probably should be detecting corrupt symbol files by
1254 seeing whether offset points to within the stringtab. */
1255 result = stringtab + symbol_entry->_n._n_n._n_offset;
1259 strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1260 buffer[SYMNMLEN] = '\0';
1266 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1267 only the last component of the name. Result is in static storage and
1268 is only good for temporary use. */
1271 coff_getfilename (union internal_auxent *aux_entry)
1273 static char buffer[BUFSIZ];
1277 if (aux_entry->x_file.x_n.x_zeroes == 0)
1278 strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1281 strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1282 buffer[FILNMLEN] = '\0';
1286 /* FIXME: We should not be throwing away the information about what
1287 directory. It should go into dirname of the symtab, or some such
1289 if ((temp = strrchr (result, '/')) != NULL)
1294 /* Support for line number handling. */
1296 static char *linetab = NULL;
1297 static long linetab_offset;
1298 static unsigned long linetab_size;
1300 /* Read in all the line numbers for fast lookups later. Leave them in
1301 external (unswapped) format in memory; we'll swap them as we enter
1302 them into GDB's data structures. */
1305 init_lineno (bfd *abfd, long offset, int size)
1309 linetab_offset = offset;
1310 linetab_size = size;
1317 if (bfd_seek (abfd, offset, 0) < 0)
1320 /* Allocate the desired table, plus a sentinel */
1321 linetab = (char *) xmalloc (size + local_linesz);
1323 val = bfd_bread (linetab, size, abfd);
1327 /* Terminate it with an all-zero sentinel record */
1328 memset (linetab + size, 0, local_linesz);
1342 free_linetab_cleanup (void *ignore)
1347 #if !defined (L_LNNO32)
1348 #define L_LNNO32(lp) ((lp)->l_lnno)
1352 enter_linenos (long file_offset, int first_line,
1353 int last_line, struct objfile *objfile)
1356 struct internal_lineno lptr;
1360 if (file_offset < linetab_offset)
1362 complaint (&symfile_complaints,
1363 _("Line number pointer %ld lower than start of line numbers"),
1365 if (file_offset > linetab_size) /* Too big to be an offset? */
1367 file_offset += linetab_offset; /* Try reading at that linetab offset */
1370 rawptr = &linetab[file_offset - linetab_offset];
1372 /* skip first line entry for each function */
1373 rawptr += local_linesz;
1374 /* line numbers start at one for the first line of the function */
1377 /* If the line number table is full (e.g. 64K lines in COFF debug
1378 info), the next function's L_LNNO32 might not be zero, so don't
1379 overstep the table's end in any case. */
1380 while (rawptr <= &linetab[0] + linetab_size)
1382 bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1383 rawptr += local_linesz;
1384 /* The next function, or the sentinel, will have L_LNNO32 zero;
1386 if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1387 record_line (current_subfile, first_line + L_LNNO32 (&lptr),
1389 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)));
1396 patch_type (struct type *type, struct type *real_type)
1398 struct type *target = TYPE_TARGET_TYPE (type);
1399 struct type *real_target = TYPE_TARGET_TYPE (real_type);
1400 int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1402 TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1403 TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1404 TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target, field_size);
1406 memcpy (TYPE_FIELDS (target), TYPE_FIELDS (real_target), field_size);
1408 if (TYPE_NAME (real_target))
1410 if (TYPE_NAME (target))
1411 xfree (TYPE_NAME (target));
1412 TYPE_NAME (target) = concat (TYPE_NAME (real_target), (char *)NULL);
1416 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1417 so that they can be used to print out opaque data structures properly. */
1420 patch_opaque_types (struct symtab *s)
1423 struct dict_iterator iter;
1424 struct symbol *real_sym;
1426 /* Go through the per-file symbols only */
1427 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1428 ALL_BLOCK_SYMBOLS (b, iter, real_sym)
1430 /* Find completed typedefs to use to fix opaque ones.
1431 Remove syms from the chain when their types are stored,
1432 but search the whole chain, as there may be several syms
1433 from different files with the same name. */
1434 if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
1435 SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN &&
1436 TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
1437 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1439 char *name = DEPRECATED_SYMBOL_NAME (real_sym);
1440 int hash = hashname (name);
1441 struct symbol *sym, *prev;
1444 for (sym = opaque_type_chain[hash]; sym;)
1446 if (name[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
1447 strcmp (name + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
1451 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1455 opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1458 patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1462 sym = SYMBOL_VALUE_CHAIN (prev);
1466 sym = opaque_type_chain[hash];
1472 sym = SYMBOL_VALUE_CHAIN (sym);
1479 static struct symbol *
1480 process_coff_symbol (struct coff_symbol *cs,
1481 union internal_auxent *aux,
1482 struct objfile *objfile)
1485 = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
1486 sizeof (struct symbol));
1489 memset (sym, 0, sizeof (struct symbol));
1491 name = EXTERNAL_NAME (name, objfile->obfd);
1492 SYMBOL_LANGUAGE (sym) = language_auto;
1493 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
1495 /* default assumptions */
1496 SYMBOL_VALUE (sym) = cs->c_value;
1497 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1498 SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1500 if (ISFCN (cs->c_type))
1502 SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1504 lookup_function_type (decode_function_type (cs, cs->c_type, aux));
1506 SYMBOL_CLASS (sym) = LOC_BLOCK;
1507 if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1508 || cs->c_sclass == C_THUMBSTATFUNC)
1509 add_symbol_to_list (sym, &file_symbols);
1510 else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1511 || cs->c_sclass == C_THUMBEXTFUNC)
1512 add_symbol_to_list (sym, &global_symbols);
1516 SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
1517 switch (cs->c_sclass)
1523 SYMBOL_CLASS (sym) = LOC_LOCAL;
1524 add_symbol_to_list (sym, &local_symbols);
1528 case C_THUMBEXTFUNC:
1530 SYMBOL_CLASS (sym) = LOC_STATIC;
1531 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1532 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1533 add_symbol_to_list (sym, &global_symbols);
1537 case C_THUMBSTATFUNC:
1539 SYMBOL_CLASS (sym) = LOC_STATIC;
1540 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1541 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1542 if (within_function)
1544 /* Static symbol of local scope */
1545 add_symbol_to_list (sym, &local_symbols);
1549 /* Static symbol at top level of file */
1550 add_symbol_to_list (sym, &file_symbols);
1554 #ifdef C_GLBLREG /* AMD coff */
1558 SYMBOL_CLASS (sym) = LOC_REGISTER;
1559 SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum
1560 (current_gdbarch, cs->c_value);
1561 add_symbol_to_list (sym, &local_symbols);
1569 SYMBOL_CLASS (sym) = LOC_ARG;
1570 add_symbol_to_list (sym, &local_symbols);
1574 SYMBOL_CLASS (sym) = LOC_REGPARM;
1575 SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum
1576 (current_gdbarch, cs->c_value);
1577 add_symbol_to_list (sym, &local_symbols);
1581 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1582 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1584 /* If type has no name, give it one */
1585 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1587 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1588 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1590 /* If we are giving a name to a type such as "pointer to
1591 foo" or "function returning foo", we better not set
1592 the TYPE_NAME. If the program contains "typedef char
1593 *caddr_t;", we don't want all variables of type char
1594 * to print as caddr_t. This is not just a
1595 consequence of GDB's type management; CC and GCC (at
1596 least through version 2.4) both output variables of
1597 either type char * or caddr_t with the type
1598 refering to the C_TPDEF symbol for caddr_t. If a future
1599 compiler cleans this up it GDB is not ready for it
1600 yet, but if it becomes ready we somehow need to
1601 disable this check (without breaking the PCC/GCC2.4
1606 Fortunately, this check seems not to be necessary
1607 for anything except pointers or functions. */
1611 TYPE_NAME (SYMBOL_TYPE (sym)) =
1612 concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
1615 /* Keep track of any type which points to empty structured type,
1616 so it can be filled from a definition from another file. A
1617 simple forward reference (TYPE_CODE_UNDEF) is not an
1618 empty structured type, though; the forward references
1619 work themselves out via the magic of coff_lookup_type. */
1620 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
1621 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
1622 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
1625 int i = hashname (DEPRECATED_SYMBOL_NAME (sym));
1627 SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1628 opaque_type_chain[i] = sym;
1630 add_symbol_to_list (sym, &file_symbols);
1636 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1637 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1639 /* Some compilers try to be helpful by inventing "fake"
1640 names for anonymous enums, structures, and unions, like
1641 "~0fake" or ".0fake". Thanks, but no thanks... */
1642 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1643 if (DEPRECATED_SYMBOL_NAME (sym) != NULL
1644 && *DEPRECATED_SYMBOL_NAME (sym) != '~'
1645 && *DEPRECATED_SYMBOL_NAME (sym) != '.')
1646 TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1647 concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
1649 add_symbol_to_list (sym, &file_symbols);
1659 /* Decode a coff type specifier; return the type that is meant. */
1661 static struct type *
1662 decode_type (struct coff_symbol *cs, unsigned int c_type,
1663 union internal_auxent *aux)
1665 struct type *type = 0;
1666 unsigned int new_c_type;
1668 if (c_type & ~N_BTMASK)
1670 new_c_type = DECREF (c_type);
1673 type = decode_type (cs, new_c_type, aux);
1674 type = lookup_pointer_type (type);
1676 else if (ISFCN (c_type))
1678 type = decode_type (cs, new_c_type, aux);
1679 type = lookup_function_type (type);
1681 else if (ISARY (c_type))
1684 unsigned short *dim;
1685 struct type *base_type, *index_type, *range_type;
1687 /* Define an array type. */
1688 /* auxent refers to array, not base type */
1689 if (aux->x_sym.x_tagndx.l == 0)
1692 /* shift the indices down */
1693 dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1696 for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1700 base_type = decode_type (cs, new_c_type, aux);
1701 index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
1703 create_range_type ((struct type *) NULL, index_type, 0, n - 1);
1705 create_array_type ((struct type *) NULL, base_type, range_type);
1710 /* Reference to existing type. This only occurs with the
1711 struct, union, and enum types. EPI a29k coff
1712 fakes us out by producing aux entries with a nonzero
1713 x_tagndx for definitions of structs, unions, and enums, so we
1714 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1715 with pointers to pointers to defined structs, and generates
1716 negative x_tagndx fields. */
1717 if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1719 if (cs->c_sclass != C_STRTAG
1720 && cs->c_sclass != C_UNTAG
1721 && cs->c_sclass != C_ENTAG
1722 && aux->x_sym.x_tagndx.l >= 0)
1724 type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1729 complaint (&symfile_complaints,
1730 _("Symbol table entry for %s has bad tagndx value"),
1732 /* And fall through to decode_base_type... */
1736 return decode_base_type (cs, BTYPE (c_type), aux);
1739 /* Decode a coff type specifier for function definition;
1740 return the type that the function returns. */
1742 static struct type *
1743 decode_function_type (struct coff_symbol *cs, unsigned int c_type,
1744 union internal_auxent *aux)
1746 if (aux->x_sym.x_tagndx.l == 0)
1747 cs->c_naux = 0; /* auxent refers to function, not base type */
1749 return decode_type (cs, DECREF (c_type), aux);
1754 static struct type *
1755 decode_base_type (struct coff_symbol *cs, unsigned int c_type,
1756 union internal_auxent *aux)
1763 /* shows up with "void (*foo)();" structure members */
1764 return lookup_fundamental_type (current_objfile, FT_VOID);
1768 /* Intel 960 COFF has this symbol and meaning. */
1769 return lookup_fundamental_type (current_objfile, FT_VOID);
1773 return lookup_fundamental_type (current_objfile, FT_CHAR);
1776 return lookup_fundamental_type (current_objfile, FT_SHORT);
1779 return lookup_fundamental_type (current_objfile, FT_INTEGER);
1782 if (cs->c_sclass == C_FIELD
1783 && aux->x_sym.x_misc.x_lnsz.x_size
1784 > gdbarch_long_bit (current_gdbarch))
1785 return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
1787 return lookup_fundamental_type (current_objfile, FT_LONG);
1790 return lookup_fundamental_type (current_objfile, FT_FLOAT);
1793 return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
1796 return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
1799 if (cs->c_naux != 1)
1801 /* anonymous structure type */
1802 type = coff_alloc_type (cs->c_symnum);
1803 TYPE_CODE (type) = TYPE_CODE_STRUCT;
1804 TYPE_NAME (type) = NULL;
1805 /* This used to set the tag to "<opaque>". But I think setting it
1806 to NULL is right, and the printing code can print it as
1808 TYPE_TAG_NAME (type) = NULL;
1809 INIT_CPLUS_SPECIFIC (type);
1810 TYPE_LENGTH (type) = 0;
1811 TYPE_FIELDS (type) = 0;
1812 TYPE_NFIELDS (type) = 0;
1816 type = coff_read_struct_type (cs->c_symnum,
1817 aux->x_sym.x_misc.x_lnsz.x_size,
1818 aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1823 if (cs->c_naux != 1)
1825 /* anonymous union type */
1826 type = coff_alloc_type (cs->c_symnum);
1827 TYPE_NAME (type) = NULL;
1828 /* This used to set the tag to "<opaque>". But I think setting it
1829 to NULL is right, and the printing code can print it as
1831 TYPE_TAG_NAME (type) = NULL;
1832 INIT_CPLUS_SPECIFIC (type);
1833 TYPE_LENGTH (type) = 0;
1834 TYPE_FIELDS (type) = 0;
1835 TYPE_NFIELDS (type) = 0;
1839 type = coff_read_struct_type (cs->c_symnum,
1840 aux->x_sym.x_misc.x_lnsz.x_size,
1841 aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1843 TYPE_CODE (type) = TYPE_CODE_UNION;
1847 if (cs->c_naux != 1)
1849 /* anonymous enum type */
1850 type = coff_alloc_type (cs->c_symnum);
1851 TYPE_CODE (type) = TYPE_CODE_ENUM;
1852 TYPE_NAME (type) = NULL;
1853 /* This used to set the tag to "<opaque>". But I think setting it
1854 to NULL is right, and the printing code can print it as
1856 TYPE_TAG_NAME (type) = NULL;
1857 TYPE_LENGTH (type) = 0;
1858 TYPE_FIELDS (type) = 0;
1859 TYPE_NFIELDS (type) = 0;
1863 type = coff_read_enum_type (cs->c_symnum,
1864 aux->x_sym.x_misc.x_lnsz.x_size,
1865 aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
1870 /* shouldn't show up here */
1874 return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
1877 return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
1880 return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
1883 if (cs->c_sclass == C_FIELD
1884 && aux->x_sym.x_misc.x_lnsz.x_size
1885 > gdbarch_long_bit (current_gdbarch))
1886 return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
1888 return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
1890 complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);
1891 return lookup_fundamental_type (current_objfile, FT_VOID);
1894 /* This page contains subroutines of read_type. */
1896 /* Read the description of a structure (or union type) and return an
1897 object describing the type. */
1899 static struct type *
1900 coff_read_struct_type (int index, int length, int lastsym)
1904 struct nextfield *next;
1909 struct nextfield *list = 0;
1910 struct nextfield *new;
1914 struct coff_symbol member_sym;
1915 struct coff_symbol *ms = &member_sym;
1916 struct internal_syment sub_sym;
1917 union internal_auxent sub_aux;
1920 type = coff_alloc_type (index);
1921 TYPE_CODE (type) = TYPE_CODE_STRUCT;
1922 INIT_CPLUS_SPECIFIC (type);
1923 TYPE_LENGTH (type) = length;
1925 while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
1927 read_one_sym (ms, &sub_sym, &sub_aux);
1929 name = EXTERNAL_NAME (name, current_objfile->obfd);
1931 switch (ms->c_sclass)
1936 /* Get space to record the next field's data. */
1937 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1941 /* Save the data. */
1945 ¤t_objfile->objfile_obstack);
1946 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1947 FIELD_BITPOS (list->field) = 8 * ms->c_value;
1948 FIELD_BITSIZE (list->field) = 0;
1949 FIELD_STATIC_KIND (list->field) = 0;
1955 /* Get space to record the next field's data. */
1956 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1960 /* Save the data. */
1964 ¤t_objfile->objfile_obstack);
1965 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
1966 FIELD_BITPOS (list->field) = ms->c_value;
1967 FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
1968 FIELD_STATIC_KIND (list->field) = 0;
1977 /* Now create the vector of fields, and record how big it is. */
1979 TYPE_NFIELDS (type) = nfields;
1980 TYPE_FIELDS (type) = (struct field *)
1981 TYPE_ALLOC (type, sizeof (struct field) * nfields);
1983 /* Copy the saved-up fields into the field vector. */
1985 for (n = nfields; list; list = list->next)
1986 TYPE_FIELD (type, --n) = list->field;
1991 /* Read a definition of an enumeration type,
1992 and create and return a suitable type object.
1993 Also defines the symbols that represent the values of the type. */
1995 static struct type *
1996 coff_read_enum_type (int index, int length, int lastsym)
2002 struct pending **symlist;
2003 struct coff_symbol member_sym;
2004 struct coff_symbol *ms = &member_sym;
2005 struct internal_syment sub_sym;
2006 union internal_auxent sub_aux;
2007 struct pending *osyms, *syms;
2011 int unsigned_enum = 1;
2013 type = coff_alloc_type (index);
2014 if (within_function)
2015 symlist = &local_symbols;
2017 symlist = &file_symbols;
2019 o_nsyms = osyms ? osyms->nsyms : 0;
2021 while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2023 read_one_sym (ms, &sub_sym, &sub_aux);
2025 name = EXTERNAL_NAME (name, current_objfile->obfd);
2027 switch (ms->c_sclass)
2030 sym = (struct symbol *) obstack_alloc
2031 (¤t_objfile->objfile_obstack,
2032 sizeof (struct symbol));
2033 memset (sym, 0, sizeof (struct symbol));
2035 DEPRECATED_SYMBOL_NAME (sym) =
2036 obsavestring (name, strlen (name),
2037 ¤t_objfile->objfile_obstack);
2038 SYMBOL_CLASS (sym) = LOC_CONST;
2039 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2040 SYMBOL_VALUE (sym) = ms->c_value;
2041 add_symbol_to_list (sym, symlist);
2046 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2047 up the count of how many symbols to read. So stop
2054 /* Now fill in the fields of the type-structure. */
2057 TYPE_LENGTH (type) = length;
2058 else /* Assume ints. */
2059 TYPE_LENGTH (type) = gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT;
2060 TYPE_CODE (type) = TYPE_CODE_ENUM;
2061 TYPE_NFIELDS (type) = nsyms;
2062 TYPE_FIELDS (type) = (struct field *)
2063 TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2065 /* Find the symbols for the values and put them into the type.
2066 The symbols can be found in the symlist that we put them on
2067 to cause them to be defined. osyms contains the old value
2068 of that symlist; everything up to there was defined by us. */
2069 /* Note that we preserve the order of the enum constants, so
2070 that in something like "enum {FOO, LAST_THING=FOO}" we print
2071 FOO, not LAST_THING. */
2073 for (syms = *symlist, n = 0; syms; syms = syms->next)
2079 for (; j < syms->nsyms; j++, n++)
2081 struct symbol *xsym = syms->symbol[j];
2082 SYMBOL_TYPE (xsym) = type;
2083 TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
2084 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
2085 if (SYMBOL_VALUE (xsym) < 0)
2087 TYPE_FIELD_BITSIZE (type, n) = 0;
2088 TYPE_FIELD_STATIC_KIND (type, n) = 0;
2095 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
2100 /* Register our ability to parse symbols for coff BFD files. */
2102 static struct sym_fns coff_sym_fns =
2104 bfd_target_coff_flavour,
2105 coff_new_init, /* sym_new_init: init anything gbl to entire symtab */
2106 coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2107 coff_symfile_read, /* sym_read: read a symbol file into symtab */
2108 coff_symfile_finish, /* sym_finish: finished with file, cleanup */
2109 default_symfile_offsets, /* sym_offsets: xlate external to internal form */
2110 default_symfile_segments, /* sym_segments: Get segment information from
2112 NULL, /* sym_read_linetable */
2113 NULL /* next: pointer to next struct sym_fns */
2117 _initialize_coffread (void)
2119 add_symtab_fns (&coff_sym_fns);