1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
3 Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 #include "breakpoint.h"
30 #include "gdb-stabs.h"
31 #include "complaints.h"
36 #include <time.h> /* For time_t in libbfd.h. */
37 #include <sys/types.h> /* For time_t, if not in time.h. */
38 #include "libbfd.h" /* FIXME secret internal data from BFD */
39 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
40 #include "libcoff.h" /* FIXME secret internal data from BFD */
42 struct coff_symfile_info
{
43 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
44 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
46 asection
*stabsect
; /* Section pointer for .stab section */
47 asection
*stabstrsect
; /* Section pointer for .stab section */
48 asection
*stabindexsect
; /* Section pointer for .stab.index section */
52 /* Translate an external name string into a user-visible name. */
53 #define EXTERNAL_NAME(string, abfd) \
54 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
56 /* To be an sdb debug type, type must have at least a basic or primary
57 derived type. Using this rather than checking against T_NULL is
58 said to prevent core dumps if we try to operate on Michael Bloom
61 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
64 * Convert from an sdb register number to an internal gdb register number.
65 * This should be defined in tm.h, if REGISTER_NAMES is not set up
66 * to map one to one onto the sdb register numbers.
68 #ifndef SDB_REG_TO_REGNUM
69 # define SDB_REG_TO_REGNUM(value) (value)
72 /* Core address of start and end of text of current source file.
73 This comes from a ".text" symbol where x_nlinno > 0. */
75 static CORE_ADDR cur_src_start_addr
;
76 static CORE_ADDR cur_src_end_addr
;
78 /* Core address of the end of the first object file. */
79 static CORE_ADDR first_object_file_end
;
81 /* The addresses of the symbol table stream and number of symbols
82 of the object file we are reading (as copied into core). */
84 static FILE *nlist_stream_global
;
85 static int nlist_nsyms_global
;
87 /* Vector of line number information. */
89 static struct linetable
*line_vector
;
91 /* Index of next entry to go in line_vector_index. */
93 static int line_vector_index
;
95 /* Last line number recorded in the line vector. */
97 static int prev_line_number
;
99 /* Number of elements allocated for line_vector currently. */
101 static int line_vector_length
;
103 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
105 static char *temp_sym
;
106 static char *temp_aux
;
108 /* Local variables that hold the shift and mask values for the
109 COFF file that we are currently reading. These come back to us
110 from BFD, and are referenced by their macro names, as well as
111 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
112 macros from ../internalcoff.h . */
114 static unsigned local_n_btmask
;
115 static unsigned local_n_btshft
;
116 static unsigned local_n_tmask
;
117 static unsigned local_n_tshift
;
119 #define N_BTMASK local_n_btmask
120 #define N_BTSHFT local_n_btshft
121 #define N_TMASK local_n_tmask
122 #define N_TSHIFT local_n_tshift
124 /* Local variables that hold the sizes in the file of various COFF structures.
125 (We only need to know this to read them from the file -- BFD will then
126 translate the data in them, into `internal_xxx' structs in the right
127 byte order, alignment, etc.) */
129 static unsigned local_linesz
;
130 static unsigned local_symesz
;
131 static unsigned local_auxesz
;
134 /* Chain of typedefs of pointers to empty struct/union types.
135 They are chained thru the SYMBOL_VALUE_CHAIN. */
137 static struct symbol
*opaque_type_chain
[HASHSIZE
];
140 /* The type of the function we are currently reading in. This is
141 used by define_symbol to record the type of arguments to a function. */
143 struct type
*in_function_type
;
146 struct pending_block
*pending_blocks
;
148 /* Complaints about various problems in the file being read */
150 struct complaint ef_complaint
=
151 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
153 struct complaint bf_no_aux_complaint
=
154 {"`.bf' symbol %d has no aux entry", 0, 0};
156 struct complaint ef_no_aux_complaint
=
157 {"`.ef' symbol %d has no aux entry", 0, 0};
159 struct complaint lineno_complaint
=
160 {"Line number pointer %d lower than start of line numbers", 0, 0};
162 struct complaint unexpected_type_complaint
=
163 {"Unexpected type for symbol %s", 0, 0};
165 struct complaint bad_sclass_complaint
=
166 {"Bad n_sclass for symbol %s", 0, 0};
168 struct complaint misordered_blocks_complaint
=
169 {"Blocks out of order at address %x", 0, 0};
171 struct complaint tagndx_bad_complaint
=
172 {"Symbol table entry for %s has bad tagndx value", 0, 0};
174 struct complaint eb_complaint
=
175 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
177 /* Simplified internal version of coff symbol table information */
181 int c_symnum
; /* symbol number of this entry */
182 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
190 coff_read_struct_type
PARAMS ((int, int, int));
193 decode_base_type
PARAMS ((struct coff_symbol
*, unsigned int,
194 union internal_auxent
*));
197 decode_type
PARAMS ((struct coff_symbol
*, unsigned int,
198 union internal_auxent
*));
201 decode_function_type
PARAMS ((struct coff_symbol
*, unsigned int,
202 union internal_auxent
*));
205 coff_read_enum_type
PARAMS ((int, int, int));
207 static struct symbol
*
208 process_coff_symbol
PARAMS ((struct coff_symbol
*, union internal_auxent
*,
212 patch_opaque_types
PARAMS ((struct symtab
*));
215 patch_type
PARAMS ((struct type
*, struct type
*));
218 enter_linenos
PARAMS ((long, int, int));
221 free_linetab
PARAMS ((void));
224 init_lineno
PARAMS ((int, long, int));
227 getfilename
PARAMS ((union internal_auxent
*));
230 getsymname
PARAMS ((struct internal_syment
*));
233 free_stringtab
PARAMS ((void));
236 init_stringtab
PARAMS ((int, long));
239 read_one_sym
PARAMS ((struct coff_symbol
*, struct internal_syment
*,
240 union internal_auxent
*));
243 read_coff_symtab
PARAMS ((long, int, struct objfile
*));
246 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
249 coff_symfile_init
PARAMS ((struct objfile
*));
252 coff_new_init
PARAMS ((struct objfile
*));
255 coff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
258 coff_symfile_finish
PARAMS ((struct objfile
*));
261 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
));
264 coff_end_symtab
PARAMS ((struct objfile
*));
267 complete_symtab
PARAMS ((char *, CORE_ADDR
, unsigned int));
270 coff_start_symtab
PARAMS ((void));
273 coff_record_line
PARAMS ((int, CORE_ADDR
));
276 coff_alloc_type
PARAMS ((int));
278 static struct type
**
279 coff_lookup_type
PARAMS ((int));
283 coff_locate_sections
PARAMS ((bfd
*, asection
*, PTR
));
285 /* We are called once per section from coff_symfile_read. We
286 need to examine each section we are passed, check to see
287 if it is something we are interested in processing, and
288 if so, stash away some access information for the section.
290 FIXME: The section names should not be hardwired strings (what
291 should they be? I don't think most object file formats have enough
292 section flags to specify what kind of debug section it is
296 coff_locate_sections (ignore_abfd
, sectp
, csip
)
301 register struct coff_symfile_info
*csi
;
303 csi
= (struct coff_symfile_info
*) csip
;
304 if (STREQ (sectp
->name
, ".stab"))
306 csi
->stabsect
= sectp
;
308 else if (STREQ (sectp
->name
, ".stabstr"))
310 csi
->stabstrsect
= sectp
;
312 else if (STREQ (sectp
->name
, ".stab.index"))
314 csi
->stabindexsect
= sectp
;
318 /* Look up a coff type-number index. Return the address of the slot
319 where the type for that index is stored.
320 The type-number is in INDEX.
322 This can be used for finding the type associated with that index
323 or for associating a new type with the index. */
325 static struct type
**
326 coff_lookup_type (index
)
329 if (index
>= type_vector_length
)
331 int old_vector_length
= type_vector_length
;
333 type_vector_length
*= 2;
334 if (index
/* is still */ >= type_vector_length
) {
335 type_vector_length
= index
* 2;
337 type_vector
= (struct type
**)
338 xrealloc ((char *) type_vector
,
339 type_vector_length
* sizeof (struct type
*));
340 memset (&type_vector
[old_vector_length
], 0,
341 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
343 return &type_vector
[index
];
346 /* Make sure there is a type allocated for type number index
347 and return the type object.
348 This can create an empty (zeroed) type object. */
351 coff_alloc_type (index
)
354 register struct type
**type_addr
= coff_lookup_type (index
);
355 register struct type
*type
= *type_addr
;
357 /* If we are referring to a type not known at all yet,
358 allocate an empty type for it.
359 We will fill it in later if we find out how. */
362 type
= alloc_type (current_objfile
);
368 /* Record a line number entry for line LINE at address PC.
369 FIXME: Use record_line instead. */
372 coff_record_line (line
, pc
)
376 struct linetable_entry
*e
;
377 /* Make sure line vector is big enough. */
379 if (line_vector_index
+ 2 >= line_vector_length
)
381 line_vector_length
*= 2;
382 line_vector
= (struct linetable
*)
383 xrealloc ((char *) line_vector
, sizeof (struct linetable
)
384 + (line_vector_length
385 * sizeof (struct linetable_entry
)));
388 e
= line_vector
->item
+ line_vector_index
++;
389 e
->line
= line
; e
->pc
= pc
;
392 /* Start a new symtab for a new source file.
393 This is called when a COFF ".file" symbol is seen;
394 it indicates the start of data for one original source file. */
400 /* We fill in the filename later. start_symtab
401 puts this pointer into last_source file and in
402 coff_end_symtab we assume we can free() it.
403 FIXME: leaks memory. */
405 /* We never know the directory name for COFF. */
407 /* The start address is irrelevant, since we set
408 last_source_start_addr in coff_end_symtab. */
411 /* Initialize the source file line number information for this file. */
413 if (line_vector
) /* Unlikely, but maybe possible? */
414 free ((PTR
)line_vector
);
415 line_vector_index
= 0;
416 line_vector_length
= 1000;
417 prev_line_number
= -2; /* Force first line number to be explicit */
418 line_vector
= (struct linetable
*)
419 xmalloc (sizeof (struct linetable
)
420 + line_vector_length
* sizeof (struct linetable_entry
));
423 /* Save the vital information from when starting to read a file,
424 for use when closing off the current file.
425 NAME is the file name the symbols came from, START_ADDR is the first
426 text address for the file, and SIZE is the number of bytes of text. */
429 complete_symtab (name
, start_addr
, size
)
431 CORE_ADDR start_addr
;
434 last_source_file
= savestring (name
, strlen (name
));
435 cur_src_start_addr
= start_addr
;
436 cur_src_end_addr
= start_addr
+ size
;
438 if (current_objfile
-> ei
.entry_point
>= cur_src_start_addr
&&
439 current_objfile
-> ei
.entry_point
< cur_src_end_addr
)
441 current_objfile
-> ei
.entry_file_lowpc
= cur_src_start_addr
;
442 current_objfile
-> ei
.entry_file_highpc
= cur_src_end_addr
;
446 /* Finish the symbol definitions for one main source file,
447 close off all the lexical contexts for that file
448 (creating struct block's for them), then make the
449 struct symtab for that file and put it in the list of all such. */
452 coff_end_symtab (objfile
)
453 struct objfile
*objfile
;
455 struct symtab
*symtab
;
457 last_source_start_addr
= cur_src_start_addr
;
459 /* For no good reason, this file stores the number of entries in a
460 separate variable instead of in line_vector->nitems. Fix it. */
462 line_vector
->nitems
= line_vector_index
;
464 /* For COFF, we only have one subfile, so we can just look at
465 subfiles and not worry about there being other elements in the
466 chain. We fill in various fields now because we didn't know them
467 before (or because doing it now is simply an artifact of how this
468 file used to be written). */
469 subfiles
->line_vector
= line_vector
;
470 subfiles
->name
= last_source_file
;
472 /* sort_pending is needed for amdcoff, at least.
473 sort_linevec is needed for the SCO compiler. */
474 symtab
= end_symtab (cur_src_end_addr
, 1, 1, objfile
, 0);
477 free_named_symtabs (symtab
->filename
);
479 /* Reinitialize for beginning of new file. */
481 line_vector_length
= -1;
482 last_source_file
= NULL
;
486 record_minimal_symbol (name
, address
, type
)
489 enum minimal_symbol_type type
;
491 /* We don't want TDESC entry points in the minimal symbol table */
492 if (name
[0] == '@') return;
494 prim_record_minimal_symbol (savestring (name
, strlen (name
)), address
, type
);
497 /* coff_symfile_init ()
498 is the coff-specific initialization routine for reading symbols.
499 It is passed a struct objfile which contains, among other things,
500 the BFD for the file whose symbols are being read, and a slot for
501 a pointer to "private data" which we fill with cookies and other
502 treats for coff_symfile_read ().
504 We will only be called if this is a COFF or COFF-like file.
505 BFD handles figuring out the format of the file, and code in symtab.c
506 uses BFD's determination to vector to us.
508 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
510 static int text_bfd_scnum
;
513 coff_symfile_init (objfile
)
514 struct objfile
*objfile
;
516 asection
*section
, *strsection
;
517 bfd
*abfd
= objfile
->obfd
;
519 /* Allocate struct to keep track of stab reading. */
520 objfile
->sym_stab_info
= (PTR
)
521 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
523 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
525 /* Allocate struct to keep track of the symfile */
526 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
527 sizeof (struct coff_symfile_info
));
529 memset (objfile
->sym_private
, 0, sizeof (struct coff_symfile_info
));
531 init_entry_point_info (objfile
);
533 /* Save the section number for the text section */
534 section
= bfd_get_section_by_name (abfd
, ".text");
536 text_bfd_scnum
= section
->index
;
541 /* This function is called for every section; it finds the outer limits
542 of the line table (minimum and maximum file offset) so that the
543 mainline code can read the whole thing for efficiency. */
547 find_linenos (abfd
, asect
, vpinfo
)
552 struct coff_symfile_info
*info
;
554 file_ptr offset
, maxoff
;
556 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
557 count
= asect
->lineno_count
;
562 size
= count
* local_linesz
;
564 info
= (struct coff_symfile_info
*)vpinfo
;
565 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
566 offset
= asect
->line_filepos
;
569 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
570 info
->min_lineno_offset
= offset
;
572 maxoff
= offset
+ size
;
573 if (maxoff
> info
->max_lineno_offset
)
574 info
->max_lineno_offset
= maxoff
;
578 /* The BFD for this file -- only good while we're actively reading
579 symbols into a psymtab or a symtab. */
581 static bfd
*symfile_bfd
;
583 /* Read a symbol file, after initialization by coff_symfile_init. */
584 /* FIXME! Addr and Mainline are not used yet -- this will not work for
585 shared libraries or add_file! */
589 coff_symfile_read (objfile
, section_offsets
, mainline
)
590 struct objfile
*objfile
;
591 struct section_offsets
*section_offsets
;
594 struct coff_symfile_info
*info
;
595 struct dbx_symfile_info
*dbxinfo
;
596 bfd
*abfd
= objfile
->obfd
;
597 coff_data_type
*cdata
= coff_data (abfd
);
598 char *name
= bfd_get_filename (abfd
);
603 int stringtab_offset
;
604 struct cleanup
*back_to
;
605 int stabsize
, stabstrsize
;
607 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
608 dbxinfo
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
609 symfile_bfd
= abfd
; /* Kludge for swap routines */
611 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
612 desc
= fileno ((FILE *)(abfd
->iostream
)); /* File descriptor */
613 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
614 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
615 stringtab_offset
= symtab_offset
+ /* String table file offset */
616 num_symbols
* cdata
->local_symesz
;
618 /* Set a few file-statics that give us specific information about
619 the particular COFF file format we're reading. */
620 local_linesz
= cdata
->local_linesz
;
621 local_n_btmask
= cdata
->local_n_btmask
;
622 local_n_btshft
= cdata
->local_n_btshft
;
623 local_n_tmask
= cdata
->local_n_tmask
;
624 local_n_tshift
= cdata
->local_n_tshift
;
625 local_linesz
= cdata
->local_linesz
;
626 local_symesz
= cdata
->local_symesz
;
627 local_auxesz
= cdata
->local_auxesz
;
629 /* Allocate space for raw symbol and aux entries, based on their
630 space requirements as reported by BFD. */
631 temp_sym
= (char *) xmalloc
632 (cdata
->local_symesz
+ cdata
->local_auxesz
);
633 temp_aux
= temp_sym
+ cdata
->local_symesz
;
634 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
637 /* Read the line number table, all at once. */
638 info
->min_lineno_offset
= 0;
639 info
->max_lineno_offset
= 0;
640 bfd_map_over_sections (abfd
, find_linenos
, (PTR
) info
);
642 make_cleanup (free_linetab
, 0);
643 val
= init_lineno (desc
, info
->min_lineno_offset
,
644 info
->max_lineno_offset
- info
->min_lineno_offset
);
646 error ("\"%s\": error reading line numbers\n", name
);
648 /* Now read the string table, all at once. */
650 make_cleanup (free_stringtab
, 0);
651 val
= init_stringtab (desc
, stringtab_offset
);
653 error ("\"%s\": can't get string table", name
);
655 init_minimal_symbol_collection ();
656 make_cleanup (discard_minimal_symbols
, 0);
658 /* Now that the executable file is positioned at symbol table,
659 process it and define symbols accordingly. */
661 read_coff_symtab ((long)symtab_offset
, num_symbols
, objfile
);
663 /* Sort symbols alphabetically within each block. */
665 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
667 sort_symtab_syms (s
);
670 /* Install any minimal symbols that have been collected as the current
671 minimal symbols for this objfile. */
673 install_minimal_symbols (objfile
);
675 bfd_map_over_sections (abfd
, coff_locate_sections
, (PTR
) info
);
679 /* FIXME: dubious. Why can't we use something normal like
680 bfd_get_section_contents? */
681 fseek ((FILE *) abfd
->iostream
, abfd
->where
, 0);
683 stabsize
= bfd_section_size (abfd
, info
->stabsect
);
684 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
686 coffstab_build_psymtabs (objfile
,
689 info
->stabsect
->filepos
, stabsize
,
690 info
->stabstrsect
->filepos
, stabstrsize
);
693 do_cleanups (back_to
);
697 coff_new_init (ignore
)
698 struct objfile
*ignore
;
702 /* Perform any local cleanups required when we are done with a particular
703 objfile. I.E, we are in the process of discarding all symbol information
704 for an objfile, freeing up all memory held for it, and unlinking the
705 objfile struct from the global list of known objfiles. */
708 coff_symfile_finish (objfile
)
709 struct objfile
*objfile
;
711 if (objfile
-> sym_private
!= NULL
)
713 mfree (objfile
-> md
, objfile
-> sym_private
);
718 /* Given pointers to a symbol table in coff style exec file,
719 analyze them and create struct symtab's describing the symbols.
720 NSYMS is the number of symbols in the symbol table.
721 We read them one at a time using read_one_sym (). */
724 read_coff_symtab (symtab_offset
, nsyms
, objfile
)
727 struct objfile
*objfile
;
730 register struct context_stack
*new;
731 struct coff_symbol coff_symbol
;
732 register struct coff_symbol
*cs
= &coff_symbol
;
733 static struct internal_syment main_sym
;
734 static union internal_auxent main_aux
;
735 struct coff_symbol fcn_cs_saved
;
736 static struct internal_syment fcn_sym_saved
;
737 static union internal_auxent fcn_aux_saved
;
740 /* A .file is open. */
741 int in_source_file
= 0;
742 int num_object_files
= 0;
743 int next_file_symnum
= -1;
745 /* Name of the current file. */
746 char *filestring
= "";
748 int fcn_first_line
= 0;
749 int fcn_last_line
= 0;
750 int fcn_start_addr
= 0;
751 long fcn_line_ptr
= 0;
754 stream
= bfd_cache_lookup(objfile
->obfd
);
756 perror_with_name(objfile
->name
);
758 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
759 it's hard to know I've really worked around it. The fix should be
760 harmless, anyway). The symptom of the bug is that the first
761 fread (in read_one_sym), will (in my example) actually get data
762 from file offset 268, when the fseek was to 264 (and ftell shows
763 264). This causes all hell to break loose. I was unable to
764 reproduce this on a short test program which operated on the same
765 file, performing (I think) the same sequence of operations.
767 It stopped happening when I put in this rewind().
769 FIXME: Find out if this has been reported to Sun, whether it has
770 been fixed in a later release, etc. */
774 /* Position to read the symbol table. */
775 val
= fseek (stream
, (long)symtab_offset
, 0);
777 perror_with_name (objfile
->name
);
779 current_objfile
= objfile
;
780 nlist_stream_global
= stream
;
781 nlist_nsyms_global
= nsyms
;
782 last_source_file
= NULL
;
783 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
785 if (type_vector
) /* Get rid of previous one */
786 free ((PTR
)type_vector
);
787 type_vector_length
= 160;
788 type_vector
= (struct type
**)
789 xmalloc (type_vector_length
* sizeof (struct type
*));
790 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
792 coff_start_symtab ();
795 while (symnum
< nsyms
)
797 QUIT
; /* Make this command interruptable. */
798 read_one_sym (cs
, &main_sym
, &main_aux
);
801 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
802 cs
->c_name
[2] << 8 | cs
->c_name
[3];
803 if (int_sem_val
== temp_sem_val
)
804 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
807 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
809 if (last_source_file
)
810 coff_end_symtab (objfile
);
812 coff_start_symtab ();
813 complete_symtab ("_globals_", 0, first_object_file_end
);
814 /* done with all files, everything from here on out is globals */
817 /* Special case for file with type declarations only, no text. */
818 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
819 && cs
->c_secnum
== N_DEBUG
)
820 complete_symtab (filestring
, 0, 0);
822 /* Typedefs should not be treated as symbol definitions. */
823 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
825 /* Record all functions -- external and static -- in minsyms. */
826 record_minimal_symbol (cs
->c_name
, cs
->c_value
, mst_text
);
828 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
829 fcn_start_addr
= cs
->c_value
;
831 fcn_sym_saved
= main_sym
;
832 fcn_aux_saved
= main_aux
;
836 switch (cs
->c_sclass
)
845 complain (&bad_sclass_complaint
, cs
->c_name
);
850 * c_value field contains symnum of next .file entry in table
851 * or symnum of first global after last .file.
853 next_file_symnum
= cs
->c_value
;
855 filestring
= getfilename (&main_aux
);
860 * Complete symbol table for last object file
861 * containing debugging information.
863 if (last_source_file
)
865 coff_end_symtab (objfile
);
866 coff_start_symtab ();
872 if (cs
->c_name
[0] == '.') {
873 if (STREQ (cs
->c_name
, ".text")) {
874 /* FIXME: don't wire in ".text" as section name
876 if (++num_object_files
== 1) {
877 /* last address of startup file */
878 first_object_file_end
= cs
->c_value
+
879 main_aux
.x_scn
.x_scnlen
;
881 /* Check for in_source_file deals with case of
882 a file with debugging symbols
883 followed by a later file with no symbols. */
885 complete_symtab (filestring
, cs
->c_value
,
886 main_aux
.x_scn
.x_scnlen
);
889 /* flush rest of '.' symbols */
892 else if (!SDB_TYPE (cs
->c_type
)
893 && cs
->c_name
[0] == 'L'
894 && (strncmp (cs
->c_name
, "LI%", 3) == 0
895 || strncmp (cs
->c_name
, "LF%", 3) == 0
896 || strncmp (cs
->c_name
,"LC%",3) == 0
897 || strncmp (cs
->c_name
,"LP%",3) == 0
898 || strncmp (cs
->c_name
,"LPB%",4) == 0
899 || strncmp (cs
->c_name
,"LBB%",4) == 0
900 || strncmp (cs
->c_name
,"LBE%",4) == 0
901 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
902 /* At least on a 3b1, gcc generates swbeg and string labels
903 that look like this. Ignore them. */
905 /* fall in for static symbols that don't start with '.' */
907 /* Record external symbols in minsyms if we don't have debug
908 info for them. FIXME, this is probably the wrong thing
909 to do. Why don't we record them even if we do have
910 debug symbol info? What really belongs in the minsyms
912 if (!SDB_TYPE (cs
->c_type
)) {
913 /* FIXME: This is BOGUS Will Robinson!
914 Coff should provide the SEC_CODE flag for executable sections,
915 then if we could look up sections by section number we
916 could see if the flags indicate SEC_CODE. If so, then
917 record this symbol as a function in the minimal symbol table.
918 But why are absolute syms recorded as functions, anyway? */
919 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
920 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
924 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
929 process_coff_symbol (cs
, &main_aux
, objfile
);
933 if (STREQ (cs
->c_name
, ".bf"))
937 /* value contains address of first non-init type code */
938 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
939 contains line number of '{' } */
941 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
942 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
944 /* Might want to check that locals are 0 and
945 context_stack_depth is zero, and complain if not. */
948 new = push_context (depth
, fcn_start_addr
);
949 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
950 new->name
= process_coff_symbol (&fcn_cs_saved
,
951 &fcn_aux_saved
, objfile
);
953 else if (STREQ (cs
->c_name
, ".ef"))
955 /* the value of .ef is the address of epilogue code;
956 not useful for gdb. */
957 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
958 contains number of lines to '}' */
959 new = pop_context ();
960 /* Stack must be empty now. */
961 if (context_stack_depth
> 0 || new == NULL
)
963 complain (&ef_complaint
, cs
->c_symnum
);
969 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
970 fcn_last_line
= 0x7FFFFFFF;
974 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
976 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
978 finish_block (new->name
, &local_symbols
, new->old_blocks
,
980 #if defined (FUNCTION_EPILOGUE_SIZE)
981 /* This macro should be defined only on
983 fcn_aux_saved.x_sym.x_misc.x_fsize
984 field is always zero.
985 So use the .bf record information that
986 points to the epilogue and add the size
988 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
990 fcn_cs_saved
.c_value
+
991 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
1000 if (STREQ (cs
->c_name
, ".bb"))
1002 push_context (++depth
, cs
->c_value
);
1004 else if (STREQ (cs
->c_name
, ".eb"))
1006 new = pop_context ();
1007 if (depth
-- != new->depth
)
1009 complain (&eb_complaint
, symnum
);
1012 if (local_symbols
&& context_stack_depth
> 0)
1014 /* Make a block for the local symbols within. */
1015 finish_block (0, &local_symbols
, new->old_blocks
,
1016 new->start_addr
, cs
->c_value
, objfile
);
1018 /* Now pop locals of block just finished. */
1019 local_symbols
= new->locals
;
1024 process_coff_symbol (cs
, &main_aux
, objfile
);
1029 if (last_source_file
)
1030 coff_end_symtab (objfile
);
1032 /* Patch up any opaque types (references to types that are not defined
1033 in the file where they are referenced, e.g. "struct foo *bar"). */
1034 ALL_OBJFILE_SYMTABS (objfile
, s
)
1035 patch_opaque_types (s
);
1037 current_objfile
= NULL
;
1040 /* Routines for reading headers and symbols from executable. */
1043 /* Move these XXXMAGIC symbol defns into BFD! */
1045 /* Read COFF file header, check magic number,
1046 and return number of symbols. */
1047 read_file_hdr (chan
, file_hdr
)
1051 lseek (chan
, 0L, 0);
1052 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1055 switch (file_hdr
->f_magic
)
1070 #if defined (MC68KWRMAGIC) \
1071 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1085 case I960ROMAGIC
: /* Intel 960 */
1088 case I960RWMAGIC
: /* Intel 960 */
1090 return file_hdr
->f_nsyms
;
1094 if (BADMAG(file_hdr
))
1097 return file_hdr
->f_nsyms
;
1105 /* Read the next symbol, swap it, and return it in both internal_syment
1106 form, and coff_symbol form. Also return its first auxent, if any,
1107 in internal_auxent form, and skip any other auxents. */
1110 read_one_sym (cs
, sym
, aux
)
1111 register struct coff_symbol
*cs
;
1112 register struct internal_syment
*sym
;
1113 register union internal_auxent
*aux
;
1117 cs
->c_symnum
= symnum
;
1118 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1119 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1120 cs
->c_naux
= sym
->n_numaux
& 0xff;
1121 if (cs
->c_naux
>= 1)
1123 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1124 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1126 /* If more than one aux entry, read past it (only the first aux
1128 for (i
= 1; i
< cs
->c_naux
; i
++)
1129 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1131 cs
->c_name
= getsymname (sym
);
1132 cs
->c_value
= sym
->n_value
;
1133 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1134 cs
->c_secnum
= sym
->n_scnum
;
1135 cs
->c_type
= (unsigned) sym
->n_type
;
1136 if (!SDB_TYPE (cs
->c_type
))
1139 symnum
+= 1 + cs
->c_naux
;
1142 /* Support for string table handling */
1144 static char *stringtab
= NULL
;
1147 init_stringtab (chan
, offset
)
1153 unsigned char lengthbuf
[4];
1157 if (lseek (chan
, offset
, 0) < 0)
1160 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1161 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1163 /* If no string table is needed, then the file may end immediately
1164 after the symbols. Just return with `stringtab' set to null. */
1165 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1168 stringtab
= (char *) xmalloc (length
);
1169 memcpy (stringtab
, &length
, sizeof length
);
1170 if (length
== sizeof length
) /* Empty table -- just the count */
1173 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1174 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1189 getsymname (symbol_entry
)
1190 struct internal_syment
*symbol_entry
;
1192 static char buffer
[SYMNMLEN
+1];
1195 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1197 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1201 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1202 buffer
[SYMNMLEN
] = '\0';
1208 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1209 only the last component of the name. Result is in static storage and
1210 is only good for temporary use. */
1213 getfilename (aux_entry
)
1214 union internal_auxent
*aux_entry
;
1216 static char buffer
[BUFSIZ
];
1217 register char *temp
;
1220 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1221 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1224 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1225 buffer
[FILNMLEN
] = '\0';
1228 if ((temp
= strrchr (result
, '/')) != NULL
)
1233 /* Support for line number handling */
1234 static char *linetab
= NULL
;
1235 static long linetab_offset
;
1236 static unsigned long linetab_size
;
1238 /* Read in all the line numbers for fast lookups later. Leave them in
1239 external (unswapped) format in memory; we'll swap them as we enter
1240 them into GDB's data structures. */
1243 init_lineno (chan
, offset
, size
)
1250 linetab_offset
= offset
;
1251 linetab_size
= size
;
1258 if (lseek (chan
, offset
, 0) < 0)
1261 /* Allocate the desired table, plus a sentinel */
1262 linetab
= (char *) xmalloc (size
+ local_linesz
);
1264 val
= myread (chan
, linetab
, size
);
1268 /* Terminate it with an all-zero sentinel record */
1269 memset (linetab
+ size
, 0, local_linesz
);
1282 #if !defined (L_LNNO32)
1283 #define L_LNNO32(lp) ((lp)->l_lnno)
1287 enter_linenos (file_offset
, first_line
, last_line
)
1289 register int first_line
;
1290 register int last_line
;
1292 register char *rawptr
;
1293 struct internal_lineno lptr
;
1295 if (file_offset
< linetab_offset
)
1297 complain (&lineno_complaint
, file_offset
);
1298 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1300 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1303 rawptr
= &linetab
[file_offset
- linetab_offset
];
1305 /* skip first line entry for each function */
1306 rawptr
+= local_linesz
;
1307 /* line numbers start at one for the first line of the function */
1311 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1312 rawptr
+= local_linesz
;
1313 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1314 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1315 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1322 patch_type (type
, real_type
)
1324 struct type
*real_type
;
1326 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1327 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1328 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1330 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1331 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1332 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1334 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1336 if (TYPE_NAME (real_target
))
1338 if (TYPE_NAME (target
))
1339 free (TYPE_NAME (target
));
1340 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1344 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1345 so that they can be used to print out opaque data structures properly. */
1348 patch_opaque_types (s
)
1351 register struct block
*b
;
1353 register struct symbol
*real_sym
;
1355 /* Go through the per-file symbols only */
1356 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1357 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1359 /* Find completed typedefs to use to fix opaque ones.
1360 Remove syms from the chain when their types are stored,
1361 but search the whole chain, as there may be several syms
1362 from different files with the same name. */
1363 real_sym
= BLOCK_SYM (b
, i
);
1364 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1365 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1366 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1367 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1369 register char *name
= SYMBOL_NAME (real_sym
);
1370 register int hash
= hashname (name
);
1371 register struct symbol
*sym
, *prev
;
1374 for (sym
= opaque_type_chain
[hash
]; sym
;)
1376 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1377 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1381 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1385 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1388 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1392 sym
= SYMBOL_VALUE_CHAIN (prev
);
1396 sym
= opaque_type_chain
[hash
];
1402 sym
= SYMBOL_VALUE_CHAIN (sym
);
1409 static struct symbol
*
1410 process_coff_symbol (cs
, aux
, objfile
)
1411 register struct coff_symbol
*cs
;
1412 register union internal_auxent
*aux
;
1413 struct objfile
*objfile
;
1415 register struct symbol
*sym
1416 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1417 sizeof (struct symbol
));
1419 struct type
*temptype
;
1421 memset (sym
, 0, sizeof (struct symbol
));
1423 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1424 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1427 /* default assumptions */
1428 SYMBOL_VALUE (sym
) = cs
->c_value
;
1429 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1431 if (ISFCN (cs
->c_type
))
1434 /* FIXME: This has NOT been tested. The DBX version has.. */
1435 /* Generate a template for the type of this function. The
1436 types of the arguments will be added as we read the symbol
1438 struct type
*new = (struct type
*)
1439 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1441 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1442 sizeof(struct type
));
1443 SYMBOL_TYPE (sym
) = new;
1444 in_function_type
= SYMBOL_TYPE(sym
);
1447 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1450 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1451 if (cs
->c_sclass
== C_STAT
)
1452 add_symbol_to_list (sym
, &file_symbols
);
1453 else if (cs
->c_sclass
== C_EXT
)
1454 add_symbol_to_list (sym
, &global_symbols
);
1458 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1459 switch (cs
->c_sclass
)
1465 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1466 add_symbol_to_list (sym
, &local_symbols
);
1470 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1471 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1472 add_symbol_to_list (sym
, &global_symbols
);
1476 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1477 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1478 if (within_function
) {
1479 /* Static symbol of local scope */
1480 add_symbol_to_list (sym
, &local_symbols
);
1483 /* Static symbol at top level of file */
1484 add_symbol_to_list (sym
, &file_symbols
);
1488 #ifdef C_GLBLREG /* AMD coff */
1492 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1493 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1494 add_symbol_to_list (sym
, &local_symbols
);
1501 SYMBOL_CLASS (sym
) = LOC_ARG
;
1503 /* FIXME: This has not been tested. */
1504 /* Add parameter to function. */
1505 add_param_to_type(&in_function_type
,sym
);
1507 add_symbol_to_list (sym
, &local_symbols
);
1508 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1509 /* If PCC says a parameter is a short or a char,
1510 aligned on an int boundary, realign it to the "little end"
1512 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1513 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1514 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1515 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1517 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1518 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1524 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1525 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1526 add_symbol_to_list (sym
, &local_symbols
);
1527 #if !defined (BELIEVE_PCC_PROMOTION)
1528 /* FIXME: This should retain the current type, since it's just
1529 a register value. gnu@adobe, 26Feb93 */
1530 /* If PCC says a parameter is a short or a char,
1531 it is really an int. */
1532 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1533 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1534 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1536 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1537 ? lookup_fundamental_type (current_objfile
,
1538 FT_UNSIGNED_INTEGER
)
1545 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1546 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1548 /* If type has no name, give it one */
1549 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1550 TYPE_NAME (SYMBOL_TYPE (sym
)) = concat (SYMBOL_NAME (sym
), NULL
);
1552 /* Keep track of any type which points to empty structured type,
1553 so it can be filled from a definition from another file. A
1554 simple forward reference (TYPE_CODE_UNDEF) is not an
1555 empty structured type, though; the forward references
1556 work themselves out via the magic of coff_lookup_type. */
1557 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1558 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1559 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1562 register int i
= hashname (SYMBOL_NAME (sym
));
1564 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1565 opaque_type_chain
[i
] = sym
;
1567 add_symbol_to_list (sym
, &file_symbols
);
1573 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1574 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1576 /* Some compilers try to be helpful by inventing "fake"
1577 names for anonymous enums, structures, and unions, like
1578 "~0fake" or ".0fake". Thanks, but no thanks... */
1579 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1580 if (SYMBOL_NAME(sym
) != NULL
1581 && *SYMBOL_NAME(sym
) != '~'
1582 && *SYMBOL_NAME(sym
) != '.')
1583 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1584 concat (SYMBOL_NAME (sym
), NULL
);
1586 add_symbol_to_list (sym
, &file_symbols
);
1596 /* Decode a coff type specifier;
1597 return the type that is meant. */
1601 decode_type (cs
, c_type
, aux
)
1602 register struct coff_symbol
*cs
;
1603 unsigned int c_type
;
1604 register union internal_auxent
*aux
;
1606 register struct type
*type
= 0;
1607 unsigned int new_c_type
;
1609 if (c_type
& ~N_BTMASK
)
1611 new_c_type
= DECREF (c_type
);
1614 type
= decode_type (cs
, new_c_type
, aux
);
1615 type
= lookup_pointer_type (type
);
1617 else if (ISFCN (c_type
))
1619 type
= decode_type (cs
, new_c_type
, aux
);
1620 type
= lookup_function_type (type
);
1622 else if (ISARY (c_type
))
1625 register unsigned short *dim
;
1626 struct type
*base_type
, *index_type
, *range_type
;
1628 /* Define an array type. */
1629 /* auxent refers to array, not base type */
1630 if (aux
->x_sym
.x_tagndx
.l
== 0)
1633 /* shift the indices down */
1634 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1637 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1641 base_type
= decode_type (cs
, new_c_type
, aux
);
1642 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1644 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1646 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1651 /* Reference to existing type. This only occurs with the
1652 struct, union, and enum types. EPI a29k coff
1653 fakes us out by producing aux entries with a nonzero
1654 x_tagndx for definitions of structs, unions, and enums, so we
1655 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1656 with pointers to pointers to defined structs, and generates
1657 negative x_tagndx fields. */
1658 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1660 if (cs
->c_sclass
!= C_STRTAG
1661 && cs
->c_sclass
!= C_UNTAG
1662 && cs
->c_sclass
!= C_ENTAG
1663 && aux
->x_sym
.x_tagndx
.l
>= 0)
1665 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1668 complain (&tagndx_bad_complaint
, cs
->c_name
);
1669 /* And fall through to decode_base_type... */
1673 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1676 /* Decode a coff type specifier for function definition;
1677 return the type that the function returns. */
1681 decode_function_type (cs
, c_type
, aux
)
1682 register struct coff_symbol
*cs
;
1683 unsigned int c_type
;
1684 register union internal_auxent
*aux
;
1686 if (aux
->x_sym
.x_tagndx
.l
== 0)
1687 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1689 return decode_type (cs
, DECREF (c_type
), aux
);
1696 decode_base_type (cs
, c_type
, aux
)
1697 register struct coff_symbol
*cs
;
1698 unsigned int c_type
;
1699 register union internal_auxent
*aux
;
1706 /* shows up with "void (*foo)();" structure members */
1707 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1710 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1713 /* Shows up in DGUX, I think. Not sure where. */
1714 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1720 /* Intel 960 COFF has this symbol and meaning. */
1721 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1725 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1728 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1731 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1734 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1737 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1740 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1743 if (cs
->c_naux
!= 1)
1745 /* anonymous structure type */
1746 type
= coff_alloc_type (cs
->c_symnum
);
1747 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1748 TYPE_NAME (type
) = NULL
;
1749 /* This used to set the tag to "<opaque>". But I think setting it
1750 to NULL is right, and the printing code can print it as
1752 TYPE_TAG_NAME (type
) = NULL
;
1753 INIT_CPLUS_SPECIFIC(type
);
1754 TYPE_LENGTH (type
) = 0;
1755 TYPE_FIELDS (type
) = 0;
1756 TYPE_NFIELDS (type
) = 0;
1760 type
= coff_read_struct_type (cs
->c_symnum
,
1761 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1762 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1767 if (cs
->c_naux
!= 1)
1769 /* anonymous union type */
1770 type
= coff_alloc_type (cs
->c_symnum
);
1771 TYPE_NAME (type
) = NULL
;
1772 /* This used to set the tag to "<opaque>". But I think setting it
1773 to NULL is right, and the printing code can print it as
1775 TYPE_TAG_NAME (type
) = NULL
;
1776 INIT_CPLUS_SPECIFIC(type
);
1777 TYPE_LENGTH (type
) = 0;
1778 TYPE_FIELDS (type
) = 0;
1779 TYPE_NFIELDS (type
) = 0;
1783 type
= coff_read_struct_type (cs
->c_symnum
,
1784 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1785 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1787 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1791 if (cs
->c_naux
!= 1)
1793 /* anonymous enum type */
1794 type
= coff_alloc_type (cs
->c_symnum
);
1795 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1796 TYPE_NAME (type
) = NULL
;
1797 /* This used to set the tag to "<opaque>". But I think setting it
1798 to NULL is right, and the printing code can print it as
1800 TYPE_TAG_NAME (type
) = NULL
;
1801 TYPE_LENGTH (type
) = 0;
1802 TYPE_FIELDS (type
) = 0;
1803 TYPE_NFIELDS(type
) = 0;
1807 type
= coff_read_enum_type (cs
->c_symnum
,
1808 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1809 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1814 /* shouldn't show up here */
1818 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1821 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1824 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1827 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
1829 complain (&unexpected_type_complaint
, cs
->c_name
);
1830 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1833 /* This page contains subroutines of read_type. */
1835 /* Read the description of a structure (or union type)
1836 and return an object describing the type. */
1838 static struct type
*
1839 coff_read_struct_type (index
, length
, lastsym
)
1846 struct nextfield
*next
;
1850 register struct type
*type
;
1851 register struct nextfield
*list
= 0;
1852 struct nextfield
*new;
1856 struct coff_symbol member_sym
;
1857 register struct coff_symbol
*ms
= &member_sym
;
1858 struct internal_syment sub_sym
;
1859 union internal_auxent sub_aux
;
1862 type
= coff_alloc_type (index
);
1863 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1864 INIT_CPLUS_SPECIFIC(type
);
1865 TYPE_LENGTH (type
) = length
;
1867 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1869 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1871 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1873 switch (ms
->c_sclass
)
1878 /* Get space to record the next field's data. */
1879 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1883 /* Save the data. */
1884 list
->field
.name
= savestring (name
, strlen (name
));
1885 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1886 list
->field
.bitpos
= 8 * ms
->c_value
;
1887 list
->field
.bitsize
= 0;
1893 /* Get space to record the next field's data. */
1894 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1898 /* Save the data. */
1899 list
->field
.name
= savestring (name
, strlen (name
));
1900 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1901 list
->field
.bitpos
= ms
->c_value
;
1902 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1911 /* Now create the vector of fields, and record how big it is. */
1913 TYPE_NFIELDS (type
) = nfields
;
1914 TYPE_FIELDS (type
) = (struct field
*)
1915 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1917 /* Copy the saved-up fields into the field vector. */
1919 for (n
= nfields
; list
; list
= list
->next
)
1920 TYPE_FIELD (type
, --n
) = list
->field
;
1925 /* Read a definition of an enumeration type,
1926 and create and return a suitable type object.
1927 Also defines the symbols that represent the values of the type. */
1930 static struct type
*
1931 coff_read_enum_type (index
, length
, lastsym
)
1936 register struct symbol
*sym
;
1937 register struct type
*type
;
1940 struct pending
**symlist
;
1941 struct coff_symbol member_sym
;
1942 register struct coff_symbol
*ms
= &member_sym
;
1943 struct internal_syment sub_sym
;
1944 union internal_auxent sub_aux
;
1945 struct pending
*osyms
, *syms
;
1950 type
= coff_alloc_type (index
);
1951 if (within_function
)
1952 symlist
= &local_symbols
;
1954 symlist
= &file_symbols
;
1956 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1958 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1960 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1962 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1964 switch (ms
->c_sclass
)
1967 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1968 memset (sym
, 0, sizeof (struct symbol
));
1970 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1971 SYMBOL_CLASS (sym
) = LOC_CONST
;
1972 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1973 SYMBOL_VALUE (sym
) = ms
->c_value
;
1974 add_symbol_to_list (sym
, symlist
);
1979 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
1980 up the count of how many symbols to read. So stop
1987 /* Now fill in the fields of the type-structure. */
1990 TYPE_LENGTH (type
) = length
;
1992 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
1993 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1994 TYPE_NFIELDS (type
) = nsyms
;
1995 TYPE_FIELDS (type
) = (struct field
*)
1996 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
1998 /* Find the symbols for the values and put them into the type.
1999 The symbols can be found in the symlist that we put them on
2000 to cause them to be defined. osyms contains the old value
2001 of that symlist; everything up to there was defined by us. */
2002 /* Note that we preserve the order of the enum constants, so
2003 that in something like "enum {FOO, LAST_THING=FOO}" we print
2004 FOO, not LAST_THING. */
2006 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2011 for (; j
< syms
->nsyms
; j
++,n
++)
2013 struct symbol
*xsym
= syms
->symbol
[j
];
2014 SYMBOL_TYPE (xsym
) = type
;
2015 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2016 TYPE_FIELD_VALUE (type
, n
) = 0;
2017 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2018 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2025 /* This screws up perfectly good C programs with enums. FIXME. */
2026 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2027 if(TYPE_NFIELDS(type
) == 2 &&
2028 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2029 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2030 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2031 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2032 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2037 struct section_offsets
*
2038 coff_symfile_offsets (objfile
, addr
)
2039 struct objfile
*objfile
;
2042 struct section_offsets
*section_offsets
;
2045 section_offsets
= (struct section_offsets
*)
2046 obstack_alloc (&objfile
-> psymbol_obstack
,
2047 sizeof (struct section_offsets
) +
2048 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2050 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2051 ANOFFSET (section_offsets
, i
) = addr
;
2053 return section_offsets
;
2056 /* Register our ability to parse symbols for coff BFD files */
2058 static struct sym_fns coff_sym_fns
=
2060 "coff", /* sym_name: name or name prefix of BFD target type */
2061 4, /* sym_namelen: number of significant sym_name chars */
2062 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2063 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2064 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2065 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2066 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2067 NULL
/* next: pointer to next struct sym_fns */
2071 _initialize_coffread ()
2073 add_symtab_fns(&coff_sym_fns
);