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 "complaints.h"
35 #include "libbfd.h" /* FIXME secret internal data from BFD */
36 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
37 #include "libcoff.h" /* FIXME secret internal data from BFD */
39 /* Translate an external name string into a user-visible name. */
40 #define EXTERNAL_NAME(string, abfd) \
41 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
43 /* To be an sdb debug type, type must have at least a basic or primary
44 derived type. Using this rather than checking against T_NULL is
45 said to prevent core dumps if we try to operate on Michael Bloom
48 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
51 * Convert from an sdb register number to an internal gdb register number.
52 * This should be defined in tm.h, if REGISTER_NAMES is not set up
53 * to map one to one onto the sdb register numbers.
55 #ifndef SDB_REG_TO_REGNUM
56 # define SDB_REG_TO_REGNUM(value) (value)
59 /* Core address of start and end of text of current source file.
60 This comes from a ".text" symbol where x_nlinno > 0. */
62 static CORE_ADDR cur_src_start_addr
;
63 static CORE_ADDR cur_src_end_addr
;
65 /* Core address of the end of the first object file. */
66 static CORE_ADDR first_object_file_end
;
68 /* The addresses of the symbol table stream and number of symbols
69 of the object file we are reading (as copied into core). */
71 static FILE *nlist_stream_global
;
72 static int nlist_nsyms_global
;
74 /* Vector of line number information. */
76 static struct linetable
*line_vector
;
78 /* Index of next entry to go in line_vector_index. */
80 static int line_vector_index
;
82 /* Last line number recorded in the line vector. */
84 static int prev_line_number
;
86 /* Number of elements allocated for line_vector currently. */
88 static int line_vector_length
;
90 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
92 static char *temp_sym
;
93 static char *temp_aux
;
95 /* Local variables that hold the shift and mask values for the
96 COFF file that we are currently reading. These come back to us
97 from BFD, and are referenced by their macro names, as well as
98 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
99 macros from ../internalcoff.h . */
101 static unsigned local_n_btmask
;
102 static unsigned local_n_btshft
;
103 static unsigned local_n_tmask
;
104 static unsigned local_n_tshift
;
106 #define N_BTMASK local_n_btmask
107 #define N_BTSHFT local_n_btshft
108 #define N_TMASK local_n_tmask
109 #define N_TSHIFT local_n_tshift
111 /* Local variables that hold the sizes in the file of various COFF structures.
112 (We only need to know this to read them from the file -- BFD will then
113 translate the data in them, into `internal_xxx' structs in the right
114 byte order, alignment, etc.) */
116 static unsigned local_linesz
;
117 static unsigned local_symesz
;
118 static unsigned local_auxesz
;
121 /* Chain of typedefs of pointers to empty struct/union types.
122 They are chained thru the SYMBOL_VALUE_CHAIN. */
124 static struct symbol
*opaque_type_chain
[HASHSIZE
];
127 /* The type of the function we are currently reading in. This is
128 used by define_symbol to record the type of arguments to a function. */
130 struct type
*in_function_type
;
133 struct pending_block
*pending_blocks
;
135 /* Complaints about various problems in the file being read */
137 struct complaint ef_complaint
=
138 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
140 struct complaint bf_no_aux_complaint
=
141 {"`.bf' symbol %d has no aux entry", 0, 0};
143 struct complaint ef_no_aux_complaint
=
144 {"`.ef' symbol %d has no aux entry", 0, 0};
146 struct complaint lineno_complaint
=
147 {"Line number pointer %d lower than start of line numbers", 0, 0};
149 struct complaint unexpected_type_complaint
=
150 {"Unexpected type for symbol %s", 0, 0};
152 struct complaint bad_sclass_complaint
=
153 {"Bad n_sclass for symbol %s", 0, 0};
155 struct complaint misordered_blocks_complaint
=
156 {"Blocks out of order at address %x", 0, 0};
158 struct complaint tagndx_bad_complaint
=
159 {"Symbol table entry for %s has bad tagndx value", 0, 0};
161 struct complaint eb_complaint
=
162 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
164 /* Simplified internal version of coff symbol table information */
168 int c_symnum
; /* symbol number of this entry */
169 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
177 coff_read_struct_type
PARAMS ((int, int, int));
180 decode_base_type
PARAMS ((struct coff_symbol
*, unsigned int,
181 union internal_auxent
*));
184 decode_type
PARAMS ((struct coff_symbol
*, unsigned int,
185 union internal_auxent
*));
188 decode_function_type
PARAMS ((struct coff_symbol
*, unsigned int,
189 union internal_auxent
*));
192 coff_read_enum_type
PARAMS ((int, int, int));
194 static struct symbol
*
195 process_coff_symbol
PARAMS ((struct coff_symbol
*, union internal_auxent
*,
199 patch_opaque_types
PARAMS ((struct symtab
*));
202 patch_type
PARAMS ((struct type
*, struct type
*));
205 enter_linenos
PARAMS ((long, int, int));
208 free_linetab
PARAMS ((void));
211 init_lineno
PARAMS ((int, long, int));
214 getfilename
PARAMS ((union internal_auxent
*));
217 getsymname
PARAMS ((struct internal_syment
*));
220 free_stringtab
PARAMS ((void));
223 init_stringtab
PARAMS ((int, long));
226 read_one_sym
PARAMS ((struct coff_symbol
*, struct internal_syment
*,
227 union internal_auxent
*));
230 read_coff_symtab
PARAMS ((long, int, struct objfile
*));
233 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
236 coff_symfile_init
PARAMS ((struct objfile
*));
239 coff_new_init
PARAMS ((struct objfile
*));
242 coff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
245 coff_symfile_finish
PARAMS ((struct objfile
*));
248 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
));
251 coff_end_symtab
PARAMS ((struct objfile
*));
254 complete_symtab
PARAMS ((char *, CORE_ADDR
, unsigned int));
257 coff_start_symtab
PARAMS ((void));
260 coff_record_line
PARAMS ((int, CORE_ADDR
));
263 coff_alloc_type
PARAMS ((int));
265 static struct type
**
266 coff_lookup_type
PARAMS ((int));
269 /* Look up a coff type-number index. Return the address of the slot
270 where the type for that index is stored.
271 The type-number is in INDEX.
273 This can be used for finding the type associated with that index
274 or for associating a new type with the index. */
276 static struct type
**
277 coff_lookup_type (index
)
280 if (index
>= type_vector_length
)
282 int old_vector_length
= type_vector_length
;
284 type_vector_length
*= 2;
285 if (index
/* is still */ >= type_vector_length
) {
286 type_vector_length
= index
* 2;
288 type_vector
= (struct type
**)
289 xrealloc ((char *) type_vector
,
290 type_vector_length
* sizeof (struct type
*));
291 memset (&type_vector
[old_vector_length
], 0,
292 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
294 return &type_vector
[index
];
297 /* Make sure there is a type allocated for type number index
298 and return the type object.
299 This can create an empty (zeroed) type object. */
302 coff_alloc_type (index
)
305 register struct type
**type_addr
= coff_lookup_type (index
);
306 register struct type
*type
= *type_addr
;
308 /* If we are referring to a type not known at all yet,
309 allocate an empty type for it.
310 We will fill it in later if we find out how. */
313 type
= alloc_type (current_objfile
);
319 /* Manage the vector of line numbers. */
322 coff_record_line (line
, pc
)
326 struct linetable_entry
*e
;
327 /* Make sure line vector is big enough. */
329 if (line_vector_index
+ 2 >= line_vector_length
)
331 line_vector_length
*= 2;
332 line_vector
= (struct linetable
*)
333 xrealloc ((char *) line_vector
, sizeof (struct linetable
)
334 + (line_vector_length
335 * sizeof (struct linetable_entry
)));
338 e
= line_vector
->item
+ line_vector_index
++;
339 e
->line
= line
; e
->pc
= pc
;
342 /* Start a new symtab for a new source file.
343 This is called when a COFF ".file" symbol is seen;
344 it indicates the start of data for one original source file. */
350 /* We fill in the filename later. */
352 /* We never know the directory name for COFF. */
354 /* The start address is irrelevant, since we set
355 last_source_start_addr in coff_end_symtab. */
358 /* Initialize the source file line number information for this file. */
360 if (line_vector
) /* Unlikely, but maybe possible? */
361 free ((PTR
)line_vector
);
362 line_vector_index
= 0;
363 line_vector_length
= 1000;
364 prev_line_number
= -2; /* Force first line number to be explicit */
365 line_vector
= (struct linetable
*)
366 xmalloc (sizeof (struct linetable
)
367 + line_vector_length
* sizeof (struct linetable_entry
));
370 /* Save the vital information from when starting to read a file,
371 for use when closing off the current file.
372 NAME is the file name the symbols came from, START_ADDR is the first
373 text address for the file, and SIZE is the number of bytes of text. */
376 complete_symtab (name
, start_addr
, size
)
378 CORE_ADDR start_addr
;
381 last_source_file
= savestring (name
, strlen (name
));
382 cur_src_start_addr
= start_addr
;
383 cur_src_end_addr
= start_addr
+ size
;
385 if (current_objfile
-> ei
.entry_point
>= cur_src_start_addr
&&
386 current_objfile
-> ei
.entry_point
< cur_src_end_addr
)
388 current_objfile
-> ei
.entry_file_lowpc
= cur_src_start_addr
;
389 current_objfile
-> ei
.entry_file_highpc
= cur_src_end_addr
;
393 /* Finish the symbol definitions for one main source file,
394 close off all the lexical contexts for that file
395 (creating struct block's for them), then make the
396 struct symtab for that file and put it in the list of all such. */
399 coff_end_symtab (objfile
)
400 struct objfile
*objfile
;
402 struct symtab
*symtab
;
404 last_source_start_addr
= cur_src_start_addr
;
406 /* For COFF, we only have one subfile, so we can just look at
407 subfiles and not worry about there being other elements in the
408 chain. We fill in various fields now because we didn't know them
409 before (or because doing it now is simply an artifact of how this
410 file used to be written). */
411 subfiles
->line_vector
= line_vector
;
412 subfiles
->name
= last_source_file
;
414 /* sort_pending is needed for amdcoff, at least.
415 sort_linevec is needed for the SCO compiler. */
416 symtab
= end_symtab (cur_src_end_addr
, 1, 1, objfile
, 0);
419 free_named_symtabs (symtab
->filename
);
421 /* Reinitialize for beginning of new file. */
423 line_vector_length
= -1;
424 last_source_file
= NULL
;
428 record_minimal_symbol (name
, address
, type
)
431 enum minimal_symbol_type type
;
433 /* We don't want TDESC entry points in the minimal symbol table */
434 if (name
[0] == '@') return;
436 prim_record_minimal_symbol (savestring (name
, strlen (name
)), address
, type
);
439 /* coff_symfile_init ()
440 is the coff-specific initialization routine for reading symbols.
441 It is passed a struct objfile which contains, among other things,
442 the BFD for the file whose symbols are being read, and a slot for
443 a pointer to "private data" which we fill with cookies and other
444 treats for coff_symfile_read ().
446 We will only be called if this is a COFF or COFF-like file.
447 BFD handles figuring out the format of the file, and code in symtab.c
448 uses BFD's determination to vector to us.
450 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
452 struct coff_symfile_info
{
453 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
454 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
457 static int text_bfd_scnum
;
460 coff_symfile_init (objfile
)
461 struct objfile
*objfile
;
464 bfd
*abfd
= objfile
->obfd
;
466 /* Allocate struct to keep track of the symfile */
467 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
468 sizeof (struct coff_symfile_info
));
470 init_entry_point_info (objfile
);
472 /* Save the section number for the text section */
473 section
= bfd_get_section_by_name(abfd
,".text");
475 text_bfd_scnum
= section
->index
;
480 /* This function is called for every section; it finds the outer limits
481 of the line table (minimum and maximum file offset) so that the
482 mainline code can read the whole thing for efficiency. */
486 find_linenos (abfd
, asect
, vpinfo
)
491 struct coff_symfile_info
*info
;
493 file_ptr offset
, maxoff
;
495 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
496 count
= asect
->lineno_count
;
501 size
= count
* local_linesz
;
503 info
= (struct coff_symfile_info
*)vpinfo
;
504 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
505 offset
= asect
->line_filepos
;
508 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
509 info
->min_lineno_offset
= offset
;
511 maxoff
= offset
+ size
;
512 if (maxoff
> info
->max_lineno_offset
)
513 info
->max_lineno_offset
= maxoff
;
517 /* The BFD for this file -- only good while we're actively reading
518 symbols into a psymtab or a symtab. */
520 static bfd
*symfile_bfd
;
522 /* Read a symbol file, after initialization by coff_symfile_init. */
523 /* FIXME! Addr and Mainline are not used yet -- this will not work for
524 shared libraries or add_file! */
528 coff_symfile_read (objfile
, section_offsets
, mainline
)
529 struct objfile
*objfile
;
530 struct section_offsets
*section_offsets
;
533 struct coff_symfile_info
*info
;
534 bfd
*abfd
= objfile
->obfd
;
535 coff_data_type
*cdata
= coff_data (abfd
);
536 char *name
= bfd_get_filename (abfd
);
541 int stringtab_offset
;
542 struct cleanup
*back_to
;
544 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
545 symfile_bfd
= abfd
; /* Kludge for swap routines */
547 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
548 desc
= fileno ((FILE *)(abfd
->iostream
)); /* File descriptor */
549 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
550 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
551 stringtab_offset
= symtab_offset
+ /* String table file offset */
552 num_symbols
* cdata
->local_symesz
;
554 /* Set a few file-statics that give us specific information about
555 the particular COFF file format we're reading. */
556 local_linesz
= cdata
->local_linesz
;
557 local_n_btmask
= cdata
->local_n_btmask
;
558 local_n_btshft
= cdata
->local_n_btshft
;
559 local_n_tmask
= cdata
->local_n_tmask
;
560 local_n_tshift
= cdata
->local_n_tshift
;
561 local_linesz
= cdata
->local_linesz
;
562 local_symesz
= cdata
->local_symesz
;
563 local_auxesz
= cdata
->local_auxesz
;
565 /* Allocate space for raw symbol and aux entries, based on their
566 space requirements as reported by BFD. */
567 temp_sym
= (char *) xmalloc
568 (cdata
->local_symesz
+ cdata
->local_auxesz
);
569 temp_aux
= temp_sym
+ cdata
->local_symesz
;
570 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
573 /* Read the line number table, all at once. */
574 info
->min_lineno_offset
= 0;
575 info
->max_lineno_offset
= 0;
576 bfd_map_over_sections (abfd
, find_linenos
, (PTR
)info
);
578 make_cleanup (free_linetab
, 0);
579 val
= init_lineno (desc
, info
->min_lineno_offset
,
580 info
->max_lineno_offset
- info
->min_lineno_offset
);
582 error ("\"%s\": error reading line numbers\n", name
);
584 /* Now read the string table, all at once. */
586 make_cleanup (free_stringtab
, 0);
587 val
= init_stringtab (desc
, stringtab_offset
);
589 error ("\"%s\": can't get string table", name
);
591 init_minimal_symbol_collection ();
592 make_cleanup (discard_minimal_symbols
, 0);
594 /* Now that the executable file is positioned at symbol table,
595 process it and define symbols accordingly. */
597 read_coff_symtab ((long)symtab_offset
, num_symbols
, objfile
);
599 /* Sort symbols alphabetically within each block. */
601 sort_all_symtab_syms ();
603 /* Install any minimal symbols that have been collected as the current
604 minimal symbols for this objfile. */
606 install_minimal_symbols (objfile
);
608 do_cleanups (back_to
);
612 coff_new_init (ignore
)
613 struct objfile
*ignore
;
618 /* Perform any local cleanups required when we are done with a particular
619 objfile. I.E, we are in the process of discarding all symbol information
620 for an objfile, freeing up all memory held for it, and unlinking the
621 objfile struct from the global list of known objfiles. */
624 coff_symfile_finish (objfile
)
625 struct objfile
*objfile
;
627 if (objfile
-> sym_private
!= NULL
)
629 mfree (objfile
-> md
, objfile
-> sym_private
);
634 /* Given pointers to a symbol table in coff style exec file,
635 analyze them and create struct symtab's describing the symbols.
636 NSYMS is the number of symbols in the symbol table.
637 We read them one at a time using read_one_sym (). */
640 read_coff_symtab (symtab_offset
, nsyms
, objfile
)
643 struct objfile
*objfile
;
646 register struct context_stack
*new;
647 struct coff_symbol coff_symbol
;
648 register struct coff_symbol
*cs
= &coff_symbol
;
649 static struct internal_syment main_sym
;
650 static union internal_auxent main_aux
;
651 struct coff_symbol fcn_cs_saved
;
652 static struct internal_syment fcn_sym_saved
;
653 static union internal_auxent fcn_aux_saved
;
656 /* A .file is open. */
657 int in_source_file
= 0;
658 int num_object_files
= 0;
659 int next_file_symnum
= -1;
661 /* Name of the current file. */
662 char *filestring
= "";
664 int fcn_first_line
= 0;
665 int fcn_last_line
= 0;
666 int fcn_start_addr
= 0;
667 long fcn_line_ptr
= 0;
670 stream
= bfd_cache_lookup(objfile
->obfd
);
672 perror_with_name(objfile
->name
);
674 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
675 it's hard to know I've really worked around it. The fix should be
676 harmless, anyway). The symptom of the bug is that the first
677 fread (in read_one_sym), will (in my example) actually get data
678 from file offset 268, when the fseek was to 264 (and ftell shows
679 264). This causes all hell to break loose. I was unable to
680 reproduce this on a short test program which operated on the same
681 file, performing (I think) the same sequence of operations.
683 It stopped happening when I put in this rewind().
685 FIXME: Find out if this has been reported to Sun, whether it has
686 been fixed in a later release, etc. */
690 /* Position to read the symbol table. */
691 val
= fseek (stream
, (long)symtab_offset
, 0);
693 perror_with_name (objfile
->name
);
695 current_objfile
= objfile
;
696 nlist_stream_global
= stream
;
697 nlist_nsyms_global
= nsyms
;
698 last_source_file
= NULL
;
699 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
701 if (type_vector
) /* Get rid of previous one */
702 free ((PTR
)type_vector
);
703 type_vector_length
= 160;
704 type_vector
= (struct type
**)
705 xmalloc (type_vector_length
* sizeof (struct type
*));
706 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
708 coff_start_symtab ();
711 while (symnum
< nsyms
)
713 QUIT
; /* Make this command interruptable. */
714 read_one_sym (cs
, &main_sym
, &main_aux
);
717 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
718 cs
->c_name
[2] << 8 | cs
->c_name
[3];
719 if (int_sem_val
== temp_sem_val
)
720 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
723 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
725 if (last_source_file
)
726 coff_end_symtab (objfile
);
728 coff_start_symtab ();
729 complete_symtab ("_globals_", 0, first_object_file_end
);
730 /* done with all files, everything from here on out is globals */
733 /* Special case for file with type declarations only, no text. */
734 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
735 && cs
->c_secnum
== N_DEBUG
)
736 complete_symtab (filestring
, 0, 0);
738 /* Typedefs should not be treated as symbol definitions. */
739 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
741 /* Record all functions -- external and static -- in minsyms. */
742 record_minimal_symbol (cs
->c_name
, cs
->c_value
, mst_text
);
744 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
745 fcn_start_addr
= cs
->c_value
;
747 fcn_sym_saved
= main_sym
;
748 fcn_aux_saved
= main_aux
;
752 switch (cs
->c_sclass
)
761 complain (&bad_sclass_complaint
, cs
->c_name
);
766 * c_value field contains symnum of next .file entry in table
767 * or symnum of first global after last .file.
769 next_file_symnum
= cs
->c_value
;
770 filestring
= getfilename (&main_aux
);
772 * Complete symbol table for last object file
773 * containing debugging information.
775 if (last_source_file
)
777 coff_end_symtab (objfile
);
778 coff_start_symtab ();
784 if (cs
->c_name
[0] == '.') {
785 if (STREQ (cs
->c_name
, ".text")) {
786 /* FIXME: don't wire in ".text" as section name
788 if (++num_object_files
== 1) {
789 /* last address of startup file */
790 first_object_file_end
= cs
->c_value
+
791 main_aux
.x_scn
.x_scnlen
;
793 /* Check for in_source_file deals with case of
794 a file with debugging symbols
795 followed by a later file with no symbols. */
797 complete_symtab (filestring
, cs
->c_value
,
798 main_aux
.x_scn
.x_scnlen
);
801 /* flush rest of '.' symbols */
804 else if (!SDB_TYPE (cs
->c_type
)
805 && cs
->c_name
[0] == 'L'
806 && (strncmp (cs
->c_name
, "LI%", 3) == 0
807 || strncmp (cs
->c_name
, "LF%", 3) == 0
808 || strncmp (cs
->c_name
,"LC%",3) == 0
809 || strncmp (cs
->c_name
,"LP%",3) == 0
810 || strncmp (cs
->c_name
,"LPB%",4) == 0
811 || strncmp (cs
->c_name
,"LBB%",4) == 0
812 || strncmp (cs
->c_name
,"LBE%",4) == 0
813 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
814 /* At least on a 3b1, gcc generates swbeg and string labels
815 that look like this. Ignore them. */
817 /* fall in for static symbols that don't start with '.' */
819 /* Record external symbols in minsyms if we don't have debug
820 info for them. FIXME, this is probably the wrong thing
821 to do. Why don't we record them even if we do have
822 debug symbol info? What really belongs in the minsyms
824 if (!SDB_TYPE (cs
->c_type
)) {
825 /* FIXME: This is BOGUS Will Robinson!
826 Coff should provide the SEC_CODE flag for executable sections,
827 then if we could look up sections by section number we
828 could see if the flags indicate SEC_CODE. If so, then
829 record this symbol as a function in the minimal symbol table.
830 But why are absolute syms recorded as functions, anyway? */
831 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
832 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
836 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
841 process_coff_symbol (cs
, &main_aux
, objfile
);
845 if (STREQ (cs
->c_name
, ".bf"))
849 /* value contains address of first non-init type code */
850 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
851 contains line number of '{' } */
853 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
854 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
856 /* Might want to check that locals are 0 and
857 context_stack_depth is zero, and complain if not. */
860 new = push_context (depth
, fcn_start_addr
);
861 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
862 new->name
= process_coff_symbol (&fcn_cs_saved
,
863 &fcn_aux_saved
, objfile
);
865 else if (STREQ (cs
->c_name
, ".ef"))
867 /* the value of .ef is the address of epilogue code;
868 not useful for gdb. */
869 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
870 contains number of lines to '}' */
871 new = pop_context ();
872 /* Stack must be empty now. */
873 if (context_stack_depth
> 0 || new == NULL
)
875 complain (&ef_complaint
, cs
->c_symnum
);
881 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
882 fcn_last_line
= 0x7FFFFFFF;
886 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
888 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
890 finish_block (new->name
, &local_symbols
, new->old_blocks
,
892 #if defined (FUNCTION_EPILOGUE_SIZE)
893 /* This macro should be defined only on
895 fcn_aux_saved.x_sym.x_misc.x_fsize
896 field is always zero.
897 So use the .bf record information that
898 points to the epilogue and add the size
900 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
902 fcn_cs_saved
.c_value
+
903 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
912 if (STREQ (cs
->c_name
, ".bb"))
914 push_context (++depth
, cs
->c_value
);
916 else if (STREQ (cs
->c_name
, ".eb"))
918 new = pop_context ();
919 if (depth
-- != new->depth
)
921 complain (&eb_complaint
, (char *)symnum
);
924 if (local_symbols
&& context_stack_depth
> 0)
926 /* Make a block for the local symbols within. */
927 finish_block (0, &local_symbols
, new->old_blocks
,
928 new->start_addr
, cs
->c_value
, objfile
);
930 /* Now pop locals of block just finished. */
931 local_symbols
= new->locals
;
936 process_coff_symbol (cs
, &main_aux
, objfile
);
941 if (last_source_file
)
942 coff_end_symtab (objfile
);
944 /* Patch up any opaque types (references to types that are not defined
945 in the file where they are referenced, e.g. "struct foo *bar"). */
946 ALL_OBJFILE_SYMTABS (objfile
, s
)
947 patch_opaque_types (s
);
949 current_objfile
= NULL
;
952 /* Routines for reading headers and symbols from executable. */
955 /* Move these XXXMAGIC symbol defns into BFD! */
957 /* Read COFF file header, check magic number,
958 and return number of symbols. */
959 read_file_hdr (chan
, file_hdr
)
964 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
967 switch (file_hdr
->f_magic
)
982 #if defined (MC68KWRMAGIC) \
983 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
997 case I960ROMAGIC
: /* Intel 960 */
1000 case I960RWMAGIC
: /* Intel 960 */
1002 return file_hdr
->f_nsyms
;
1006 if (BADMAG(file_hdr
))
1009 return file_hdr
->f_nsyms
;
1017 /* Read the next symbol, swap it, and return it in both internal_syment
1018 form, and coff_symbol form. Also return its first auxent, if any,
1019 in internal_auxent form, and skip any other auxents. */
1022 read_one_sym (cs
, sym
, aux
)
1023 register struct coff_symbol
*cs
;
1024 register struct internal_syment
*sym
;
1025 register union internal_auxent
*aux
;
1029 cs
->c_symnum
= symnum
;
1030 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1031 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1032 cs
->c_naux
= sym
->n_numaux
& 0xff;
1033 if (cs
->c_naux
>= 1)
1035 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1036 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1038 /* If more than one aux entry, read past it (only the first aux
1040 for (i
= 1; i
< cs
->c_naux
; i
++)
1041 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1043 cs
->c_name
= getsymname (sym
);
1044 cs
->c_value
= sym
->n_value
;
1045 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1046 cs
->c_secnum
= sym
->n_scnum
;
1047 cs
->c_type
= (unsigned) sym
->n_type
;
1048 if (!SDB_TYPE (cs
->c_type
))
1051 symnum
+= 1 + cs
->c_naux
;
1054 /* Support for string table handling */
1056 static char *stringtab
= NULL
;
1059 init_stringtab (chan
, offset
)
1065 unsigned char lengthbuf
[4];
1069 if (lseek (chan
, offset
, 0) < 0)
1072 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1073 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1075 /* If no string table is needed, then the file may end immediately
1076 after the symbols. Just return with `stringtab' set to null. */
1077 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1080 stringtab
= (char *) xmalloc (length
);
1081 memcpy (stringtab
, &length
, sizeof length
);
1082 if (length
== sizeof length
) /* Empty table -- just the count */
1085 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1086 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1101 getsymname (symbol_entry
)
1102 struct internal_syment
*symbol_entry
;
1104 static char buffer
[SYMNMLEN
+1];
1107 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1109 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1113 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1114 buffer
[SYMNMLEN
] = '\0';
1120 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1121 only the last component of the name. Result is in static storage and
1122 is only good for temporary use. */
1125 getfilename (aux_entry
)
1126 union internal_auxent
*aux_entry
;
1128 static char buffer
[BUFSIZ
];
1129 register char *temp
;
1132 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1133 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1136 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1137 buffer
[FILNMLEN
] = '\0';
1140 if ((temp
= strrchr (result
, '/')) != NULL
)
1145 /* Support for line number handling */
1146 static char *linetab
= NULL
;
1147 static long linetab_offset
;
1148 static unsigned long linetab_size
;
1150 /* Read in all the line numbers for fast lookups later. Leave them in
1151 external (unswapped) format in memory; we'll swap them as we enter
1152 them into GDB's data structures. */
1155 init_lineno (chan
, offset
, size
)
1162 linetab_offset
= offset
;
1163 linetab_size
= size
;
1170 if (lseek (chan
, offset
, 0) < 0)
1173 /* Allocate the desired table, plus a sentinel */
1174 linetab
= (char *) xmalloc (size
+ local_linesz
);
1176 val
= myread (chan
, linetab
, size
);
1180 /* Terminate it with an all-zero sentinel record */
1181 memset (linetab
+ size
, 0, local_linesz
);
1194 #if !defined (L_LNNO32)
1195 #define L_LNNO32(lp) ((lp)->l_lnno)
1199 enter_linenos (file_offset
, first_line
, last_line
)
1201 register int first_line
;
1202 register int last_line
;
1204 register char *rawptr
;
1205 struct internal_lineno lptr
;
1207 if (file_offset
< linetab_offset
)
1209 complain (&lineno_complaint
, file_offset
);
1210 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1212 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1215 rawptr
= &linetab
[file_offset
- linetab_offset
];
1217 /* skip first line entry for each function */
1218 rawptr
+= local_linesz
;
1219 /* line numbers start at one for the first line of the function */
1223 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1224 rawptr
+= local_linesz
;
1225 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1226 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1227 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1234 patch_type (type
, real_type
)
1236 struct type
*real_type
;
1238 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1239 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1240 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1242 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1243 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1244 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1246 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1248 if (TYPE_NAME (real_target
))
1250 if (TYPE_NAME (target
))
1251 free (TYPE_NAME (target
));
1252 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1256 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1257 so that they can be used to print out opaque data structures properly. */
1260 patch_opaque_types (s
)
1263 register struct block
*b
;
1265 register struct symbol
*real_sym
;
1267 /* Go through the per-file symbols only */
1268 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1269 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1271 /* Find completed typedefs to use to fix opaque ones.
1272 Remove syms from the chain when their types are stored,
1273 but search the whole chain, as there may be several syms
1274 from different files with the same name. */
1275 real_sym
= BLOCK_SYM (b
, i
);
1276 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1277 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1278 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1279 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1281 register char *name
= SYMBOL_NAME (real_sym
);
1282 register int hash
= hashname (name
);
1283 register struct symbol
*sym
, *prev
;
1286 for (sym
= opaque_type_chain
[hash
]; sym
;)
1288 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1289 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1293 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1297 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1300 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1304 sym
= SYMBOL_VALUE_CHAIN (prev
);
1308 sym
= opaque_type_chain
[hash
];
1314 sym
= SYMBOL_VALUE_CHAIN (sym
);
1321 static struct symbol
*
1322 process_coff_symbol (cs
, aux
, objfile
)
1323 register struct coff_symbol
*cs
;
1324 register union internal_auxent
*aux
;
1325 struct objfile
*objfile
;
1327 register struct symbol
*sym
1328 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1329 sizeof (struct symbol
));
1331 struct type
*temptype
;
1333 memset (sym
, 0, sizeof (struct symbol
));
1335 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1336 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1339 /* default assumptions */
1340 SYMBOL_VALUE (sym
) = cs
->c_value
;
1341 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1343 if (ISFCN (cs
->c_type
))
1346 /* FIXME: This has NOT been tested. The DBX version has.. */
1347 /* Generate a template for the type of this function. The
1348 types of the arguments will be added as we read the symbol
1350 struct type
*new = (struct type
*)
1351 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1353 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1354 sizeof(struct type
));
1355 SYMBOL_TYPE (sym
) = new;
1356 in_function_type
= SYMBOL_TYPE(sym
);
1359 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1362 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1363 if (cs
->c_sclass
== C_STAT
)
1364 add_symbol_to_list (sym
, &file_symbols
);
1365 else if (cs
->c_sclass
== C_EXT
)
1366 add_symbol_to_list (sym
, &global_symbols
);
1370 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1371 switch (cs
->c_sclass
)
1377 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1378 add_symbol_to_list (sym
, &local_symbols
);
1382 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1383 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1384 add_symbol_to_list (sym
, &global_symbols
);
1388 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1389 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1390 if (within_function
) {
1391 /* Static symbol of local scope */
1392 add_symbol_to_list (sym
, &local_symbols
);
1395 /* Static symbol at top level of file */
1396 add_symbol_to_list (sym
, &file_symbols
);
1400 #ifdef C_GLBLREG /* AMD coff */
1404 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1405 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1406 add_symbol_to_list (sym
, &local_symbols
);
1413 SYMBOL_CLASS (sym
) = LOC_ARG
;
1415 /* FIXME: This has not been tested. */
1416 /* Add parameter to function. */
1417 add_param_to_type(&in_function_type
,sym
);
1419 add_symbol_to_list (sym
, &local_symbols
);
1420 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1421 /* If PCC says a parameter is a short or a char,
1422 aligned on an int boundary, realign it to the "little end"
1424 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1425 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1426 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1427 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1429 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1430 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1436 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1437 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1438 add_symbol_to_list (sym
, &local_symbols
);
1439 #if !defined (BELIEVE_PCC_PROMOTION)
1440 /* FIXME: This should retain the current type, since it's just
1441 a register value. gnu@adobe, 26Feb93 */
1442 /* If PCC says a parameter is a short or a char,
1443 it is really an int. */
1444 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1445 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1446 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1448 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1449 ? lookup_fundamental_type (current_objfile
,
1450 FT_UNSIGNED_INTEGER
)
1457 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1458 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1460 /* If type has no name, give it one */
1461 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1462 TYPE_NAME (SYMBOL_TYPE (sym
)) = concat (SYMBOL_NAME (sym
), NULL
);
1464 /* Keep track of any type which points to empty structured type,
1465 so it can be filled from a definition from another file. A
1466 simple forward reference (TYPE_CODE_UNDEF) is not an
1467 empty structured type, though; the forward references
1468 work themselves out via the magic of coff_lookup_type. */
1469 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1470 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1471 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1474 register int i
= hashname (SYMBOL_NAME (sym
));
1476 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1477 opaque_type_chain
[i
] = sym
;
1479 add_symbol_to_list (sym
, &file_symbols
);
1485 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1486 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1488 /* Some compilers try to be helpful by inventing "fake"
1489 names for anonymous enums, structures, and unions, like
1490 "~0fake" or ".0fake". Thanks, but no thanks... */
1491 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1492 if (SYMBOL_NAME(sym
) != NULL
1493 && *SYMBOL_NAME(sym
) != '~'
1494 && *SYMBOL_NAME(sym
) != '.')
1495 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1496 concat (SYMBOL_NAME (sym
), NULL
);
1498 add_symbol_to_list (sym
, &file_symbols
);
1508 /* Decode a coff type specifier;
1509 return the type that is meant. */
1513 decode_type (cs
, c_type
, aux
)
1514 register struct coff_symbol
*cs
;
1515 unsigned int c_type
;
1516 register union internal_auxent
*aux
;
1518 register struct type
*type
= 0;
1519 unsigned int new_c_type
;
1521 if (c_type
& ~N_BTMASK
)
1523 new_c_type
= DECREF (c_type
);
1526 type
= decode_type (cs
, new_c_type
, aux
);
1527 type
= lookup_pointer_type (type
);
1529 else if (ISFCN (c_type
))
1531 type
= decode_type (cs
, new_c_type
, aux
);
1532 type
= lookup_function_type (type
);
1534 else if (ISARY (c_type
))
1537 register unsigned short *dim
;
1538 struct type
*base_type
, *index_type
, *range_type
;
1540 /* Define an array type. */
1541 /* auxent refers to array, not base type */
1542 if (aux
->x_sym
.x_tagndx
.l
== 0)
1545 /* shift the indices down */
1546 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1549 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1553 base_type
= decode_type (cs
, new_c_type
, aux
);
1554 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1556 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1558 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1563 /* Reference to existing type. This only occurs with the
1564 struct, union, and enum types. EPI a29k coff
1565 fakes us out by producing aux entries with a nonzero
1566 x_tagndx for definitions of structs, unions, and enums, so we
1567 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1568 with pointers to pointers to defined structs, and generates
1569 negative x_tagndx fields. */
1570 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1572 if (cs
->c_sclass
!= C_STRTAG
1573 && cs
->c_sclass
!= C_UNTAG
1574 && cs
->c_sclass
!= C_ENTAG
1575 && aux
->x_sym
.x_tagndx
.l
>= 0)
1577 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1580 complain (&tagndx_bad_complaint
, cs
->c_name
);
1581 /* And fall through to decode_base_type... */
1585 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1588 /* Decode a coff type specifier for function definition;
1589 return the type that the function returns. */
1593 decode_function_type (cs
, c_type
, aux
)
1594 register struct coff_symbol
*cs
;
1595 unsigned int c_type
;
1596 register union internal_auxent
*aux
;
1598 if (aux
->x_sym
.x_tagndx
.l
== 0)
1599 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1601 return decode_type (cs
, DECREF (c_type
), aux
);
1608 decode_base_type (cs
, c_type
, aux
)
1609 register struct coff_symbol
*cs
;
1610 unsigned int c_type
;
1611 register union internal_auxent
*aux
;
1618 /* shows up with "void (*foo)();" structure members */
1619 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1622 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1625 /* Shows up in DGUX, I think. Not sure where. */
1626 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1632 /* Intel 960 COFF has this symbol and meaning. */
1633 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1637 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1640 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1643 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1646 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1649 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1652 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1655 if (cs
->c_naux
!= 1)
1657 /* anonymous structure type */
1658 type
= coff_alloc_type (cs
->c_symnum
);
1659 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1660 TYPE_NAME (type
) = NULL
;
1661 /* This used to set the tag to "<opaque>". But I think setting it
1662 to NULL is right, and the printing code can print it as
1664 TYPE_TAG_NAME (type
) = NULL
;
1665 INIT_CPLUS_SPECIFIC(type
);
1666 TYPE_LENGTH (type
) = 0;
1667 TYPE_FIELDS (type
) = 0;
1668 TYPE_NFIELDS (type
) = 0;
1672 type
= coff_read_struct_type (cs
->c_symnum
,
1673 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1674 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1679 if (cs
->c_naux
!= 1)
1681 /* anonymous union type */
1682 type
= coff_alloc_type (cs
->c_symnum
);
1683 TYPE_NAME (type
) = NULL
;
1684 /* This used to set the tag to "<opaque>". But I think setting it
1685 to NULL is right, and the printing code can print it as
1687 TYPE_TAG_NAME (type
) = NULL
;
1688 INIT_CPLUS_SPECIFIC(type
);
1689 TYPE_LENGTH (type
) = 0;
1690 TYPE_FIELDS (type
) = 0;
1691 TYPE_NFIELDS (type
) = 0;
1695 type
= coff_read_struct_type (cs
->c_symnum
,
1696 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1697 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1699 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1703 if (cs
->c_naux
!= 1)
1705 /* anonymous enum type */
1706 type
= coff_alloc_type (cs
->c_symnum
);
1707 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1708 TYPE_NAME (type
) = NULL
;
1709 /* This used to set the tag to "<opaque>". But I think setting it
1710 to NULL is right, and the printing code can print it as
1712 TYPE_TAG_NAME (type
) = NULL
;
1713 TYPE_LENGTH (type
) = 0;
1714 TYPE_FIELDS (type
) = 0;
1715 TYPE_NFIELDS(type
) = 0;
1719 type
= coff_read_enum_type (cs
->c_symnum
,
1720 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1721 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1726 /* shouldn't show up here */
1730 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1733 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1736 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1739 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
1741 complain (&unexpected_type_complaint
, cs
->c_name
);
1742 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1745 /* This page contains subroutines of read_type. */
1747 /* Read the description of a structure (or union type)
1748 and return an object describing the type. */
1750 static struct type
*
1751 coff_read_struct_type (index
, length
, lastsym
)
1758 struct nextfield
*next
;
1762 register struct type
*type
;
1763 register struct nextfield
*list
= 0;
1764 struct nextfield
*new;
1768 struct coff_symbol member_sym
;
1769 register struct coff_symbol
*ms
= &member_sym
;
1770 struct internal_syment sub_sym
;
1771 union internal_auxent sub_aux
;
1774 type
= coff_alloc_type (index
);
1775 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1776 INIT_CPLUS_SPECIFIC(type
);
1777 TYPE_LENGTH (type
) = length
;
1779 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1781 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1783 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1785 switch (ms
->c_sclass
)
1790 /* Get space to record the next field's data. */
1791 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1795 /* Save the data. */
1796 list
->field
.name
= savestring (name
, strlen (name
));
1797 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1798 list
->field
.bitpos
= 8 * ms
->c_value
;
1799 list
->field
.bitsize
= 0;
1805 /* Get space to record the next field's data. */
1806 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1810 /* Save the data. */
1811 list
->field
.name
= savestring (name
, strlen (name
));
1812 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1813 list
->field
.bitpos
= ms
->c_value
;
1814 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1823 /* Now create the vector of fields, and record how big it is. */
1825 TYPE_NFIELDS (type
) = nfields
;
1826 TYPE_FIELDS (type
) = (struct field
*)
1827 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1829 /* Copy the saved-up fields into the field vector. */
1831 for (n
= nfields
; list
; list
= list
->next
)
1832 TYPE_FIELD (type
, --n
) = list
->field
;
1837 /* Read a definition of an enumeration type,
1838 and create and return a suitable type object.
1839 Also defines the symbols that represent the values of the type. */
1842 static struct type
*
1843 coff_read_enum_type (index
, length
, lastsym
)
1848 register struct symbol
*sym
;
1849 register struct type
*type
;
1852 struct pending
**symlist
;
1853 struct coff_symbol member_sym
;
1854 register struct coff_symbol
*ms
= &member_sym
;
1855 struct internal_syment sub_sym
;
1856 union internal_auxent sub_aux
;
1857 struct pending
*osyms
, *syms
;
1862 type
= coff_alloc_type (index
);
1863 if (within_function
)
1864 symlist
= &local_symbols
;
1866 symlist
= &file_symbols
;
1868 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1870 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1872 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1874 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1876 switch (ms
->c_sclass
)
1879 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1880 memset (sym
, 0, sizeof (struct symbol
));
1882 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1883 SYMBOL_CLASS (sym
) = LOC_CONST
;
1884 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1885 SYMBOL_VALUE (sym
) = ms
->c_value
;
1886 add_symbol_to_list (sym
, symlist
);
1891 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
1892 up the count of how many symbols to read. So stop
1899 /* Now fill in the fields of the type-structure. */
1902 TYPE_LENGTH (type
) = length
;
1904 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
1905 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1906 TYPE_NFIELDS (type
) = nsyms
;
1907 TYPE_FIELDS (type
) = (struct field
*)
1908 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
1910 /* Find the symbols for the values and put them into the type.
1911 The symbols can be found in the symlist that we put them on
1912 to cause them to be defined. osyms contains the old value
1913 of that symlist; everything up to there was defined by us. */
1914 /* Note that we preserve the order of the enum constants, so
1915 that in something like "enum {FOO, LAST_THING=FOO}" we print
1916 FOO, not LAST_THING. */
1918 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
1923 for (; j
< syms
->nsyms
; j
++,n
++)
1925 struct symbol
*xsym
= syms
->symbol
[j
];
1926 SYMBOL_TYPE (xsym
) = type
;
1927 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
1928 TYPE_FIELD_VALUE (type
, n
) = 0;
1929 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
1930 TYPE_FIELD_BITSIZE (type
, n
) = 0;
1937 /* This screws up perfectly good C programs with enums. FIXME. */
1938 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
1939 if(TYPE_NFIELDS(type
) == 2 &&
1940 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
1941 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
1942 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
1943 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
1944 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
1949 /* Fake up support for relocating symbol addresses. FIXME. */
1951 struct section_offsets coff_symfile_faker
= {0};
1953 struct section_offsets
*
1954 coff_symfile_offsets (objfile
, addr
)
1955 struct objfile
*objfile
;
1958 return &coff_symfile_faker
;
1961 /* Register our ability to parse symbols for coff BFD files */
1963 static struct sym_fns coff_sym_fns
=
1965 "coff", /* sym_name: name or name prefix of BFD target type */
1966 4, /* sym_namelen: number of significant sym_name chars */
1967 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
1968 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
1969 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
1970 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
1971 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
1972 NULL
/* next: pointer to next struct sym_fns */
1976 _initialize_coffread ()
1978 add_symtab_fns(&coff_sym_fns
);