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 <time.h> /* For time_t in libbfd.h. */
36 #include "libbfd.h" /* FIXME secret internal data from BFD */
37 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
38 #include "libcoff.h" /* FIXME secret internal data from BFD */
40 /* Translate an external name string into a user-visible name. */
41 #define EXTERNAL_NAME(string, abfd) \
42 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
44 /* To be an sdb debug type, type must have at least a basic or primary
45 derived type. Using this rather than checking against T_NULL is
46 said to prevent core dumps if we try to operate on Michael Bloom
49 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
52 * Convert from an sdb register number to an internal gdb register number.
53 * This should be defined in tm.h, if REGISTER_NAMES is not set up
54 * to map one to one onto the sdb register numbers.
56 #ifndef SDB_REG_TO_REGNUM
57 # define SDB_REG_TO_REGNUM(value) (value)
60 /* Core address of start and end of text of current source file.
61 This comes from a ".text" symbol where x_nlinno > 0. */
63 static CORE_ADDR cur_src_start_addr
;
64 static CORE_ADDR cur_src_end_addr
;
66 /* Core address of the end of the first object file. */
67 static CORE_ADDR first_object_file_end
;
69 /* The addresses of the symbol table stream and number of symbols
70 of the object file we are reading (as copied into core). */
72 static FILE *nlist_stream_global
;
73 static int nlist_nsyms_global
;
75 /* Vector of line number information. */
77 static struct linetable
*line_vector
;
79 /* Index of next entry to go in line_vector_index. */
81 static int line_vector_index
;
83 /* Last line number recorded in the line vector. */
85 static int prev_line_number
;
87 /* Number of elements allocated for line_vector currently. */
89 static int line_vector_length
;
91 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
93 static char *temp_sym
;
94 static char *temp_aux
;
96 /* Local variables that hold the shift and mask values for the
97 COFF file that we are currently reading. These come back to us
98 from BFD, and are referenced by their macro names, as well as
99 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
100 macros from ../internalcoff.h . */
102 static unsigned local_n_btmask
;
103 static unsigned local_n_btshft
;
104 static unsigned local_n_tmask
;
105 static unsigned local_n_tshift
;
107 #define N_BTMASK local_n_btmask
108 #define N_BTSHFT local_n_btshft
109 #define N_TMASK local_n_tmask
110 #define N_TSHIFT local_n_tshift
112 /* Local variables that hold the sizes in the file of various COFF structures.
113 (We only need to know this to read them from the file -- BFD will then
114 translate the data in them, into `internal_xxx' structs in the right
115 byte order, alignment, etc.) */
117 static unsigned local_linesz
;
118 static unsigned local_symesz
;
119 static unsigned local_auxesz
;
122 /* Chain of typedefs of pointers to empty struct/union types.
123 They are chained thru the SYMBOL_VALUE_CHAIN. */
125 static struct symbol
*opaque_type_chain
[HASHSIZE
];
128 /* The type of the function we are currently reading in. This is
129 used by define_symbol to record the type of arguments to a function. */
131 struct type
*in_function_type
;
134 struct pending_block
*pending_blocks
;
136 /* Complaints about various problems in the file being read */
138 struct complaint ef_complaint
=
139 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
141 struct complaint bf_no_aux_complaint
=
142 {"`.bf' symbol %d has no aux entry", 0, 0};
144 struct complaint ef_no_aux_complaint
=
145 {"`.ef' symbol %d has no aux entry", 0, 0};
147 struct complaint lineno_complaint
=
148 {"Line number pointer %d lower than start of line numbers", 0, 0};
150 struct complaint unexpected_type_complaint
=
151 {"Unexpected type for symbol %s", 0, 0};
153 struct complaint bad_sclass_complaint
=
154 {"Bad n_sclass for symbol %s", 0, 0};
156 struct complaint misordered_blocks_complaint
=
157 {"Blocks out of order at address %x", 0, 0};
159 struct complaint tagndx_bad_complaint
=
160 {"Symbol table entry for %s has bad tagndx value", 0, 0};
162 struct complaint eb_complaint
=
163 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
165 /* Simplified internal version of coff symbol table information */
169 int c_symnum
; /* symbol number of this entry */
170 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
178 coff_read_struct_type
PARAMS ((int, int, int));
181 decode_base_type
PARAMS ((struct coff_symbol
*, unsigned int,
182 union internal_auxent
*));
185 decode_type
PARAMS ((struct coff_symbol
*, unsigned int,
186 union internal_auxent
*));
189 decode_function_type
PARAMS ((struct coff_symbol
*, unsigned int,
190 union internal_auxent
*));
193 coff_read_enum_type
PARAMS ((int, int, int));
195 static struct symbol
*
196 process_coff_symbol
PARAMS ((struct coff_symbol
*, union internal_auxent
*,
200 patch_opaque_types
PARAMS ((struct symtab
*));
203 patch_type
PARAMS ((struct type
*, struct type
*));
206 enter_linenos
PARAMS ((long, int, int));
209 free_linetab
PARAMS ((void));
212 init_lineno
PARAMS ((int, long, int));
215 getfilename
PARAMS ((union internal_auxent
*));
218 getsymname
PARAMS ((struct internal_syment
*));
221 free_stringtab
PARAMS ((void));
224 init_stringtab
PARAMS ((int, long));
227 read_one_sym
PARAMS ((struct coff_symbol
*, struct internal_syment
*,
228 union internal_auxent
*));
231 read_coff_symtab
PARAMS ((long, int, struct objfile
*));
234 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
237 coff_symfile_init
PARAMS ((struct objfile
*));
240 coff_new_init
PARAMS ((struct objfile
*));
243 coff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
246 coff_symfile_finish
PARAMS ((struct objfile
*));
249 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
));
252 coff_end_symtab
PARAMS ((struct objfile
*));
255 complete_symtab
PARAMS ((char *, CORE_ADDR
, unsigned int));
258 coff_start_symtab
PARAMS ((void));
261 coff_record_line
PARAMS ((int, CORE_ADDR
));
264 coff_alloc_type
PARAMS ((int));
266 static struct type
**
267 coff_lookup_type
PARAMS ((int));
270 /* Look up a coff type-number index. Return the address of the slot
271 where the type for that index is stored.
272 The type-number is in INDEX.
274 This can be used for finding the type associated with that index
275 or for associating a new type with the index. */
277 static struct type
**
278 coff_lookup_type (index
)
281 if (index
>= type_vector_length
)
283 int old_vector_length
= type_vector_length
;
285 type_vector_length
*= 2;
286 if (index
/* is still */ >= type_vector_length
) {
287 type_vector_length
= index
* 2;
289 type_vector
= (struct type
**)
290 xrealloc ((char *) type_vector
,
291 type_vector_length
* sizeof (struct type
*));
292 memset (&type_vector
[old_vector_length
], 0,
293 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
295 return &type_vector
[index
];
298 /* Make sure there is a type allocated for type number index
299 and return the type object.
300 This can create an empty (zeroed) type object. */
303 coff_alloc_type (index
)
306 register struct type
**type_addr
= coff_lookup_type (index
);
307 register struct type
*type
= *type_addr
;
309 /* If we are referring to a type not known at all yet,
310 allocate an empty type for it.
311 We will fill it in later if we find out how. */
314 type
= alloc_type (current_objfile
);
320 /* Manage the vector of line numbers. FIXME: Use record_line instead. */
323 coff_record_line (line
, pc
)
327 struct linetable_entry
*e
;
328 /* Make sure line vector is big enough. */
330 if (line_vector_index
+ 2 >= line_vector_length
)
332 line_vector_length
*= 2;
333 line_vector
= (struct linetable
*)
334 xrealloc ((char *) line_vector
, sizeof (struct linetable
)
335 + (line_vector_length
336 * sizeof (struct linetable_entry
)));
339 e
= line_vector
->item
+ line_vector_index
++;
340 e
->line
= line
; e
->pc
= pc
;
343 /* Start a new symtab for a new source file.
344 This is called when a COFF ".file" symbol is seen;
345 it indicates the start of data for one original source file. */
351 /* We fill in the filename later. start_symtab
352 puts this pointer into last_source file and in
353 coff_end_symtab we assume we can free() it.
354 FIXME: leaks memory. */
356 /* We never know the directory name for COFF. */
358 /* The start address is irrelevant, since we set
359 last_source_start_addr in coff_end_symtab. */
362 /* Initialize the source file line number information for this file. */
364 if (line_vector
) /* Unlikely, but maybe possible? */
365 free ((PTR
)line_vector
);
366 line_vector_index
= 0;
367 line_vector_length
= 1000;
368 prev_line_number
= -2; /* Force first line number to be explicit */
369 line_vector
= (struct linetable
*)
370 xmalloc (sizeof (struct linetable
)
371 + line_vector_length
* sizeof (struct linetable_entry
));
374 /* Save the vital information from when starting to read a file,
375 for use when closing off the current file.
376 NAME is the file name the symbols came from, START_ADDR is the first
377 text address for the file, and SIZE is the number of bytes of text. */
380 complete_symtab (name
, start_addr
, size
)
382 CORE_ADDR start_addr
;
385 last_source_file
= savestring (name
, strlen (name
));
386 cur_src_start_addr
= start_addr
;
387 cur_src_end_addr
= start_addr
+ size
;
389 if (current_objfile
-> ei
.entry_point
>= cur_src_start_addr
&&
390 current_objfile
-> ei
.entry_point
< cur_src_end_addr
)
392 current_objfile
-> ei
.entry_file_lowpc
= cur_src_start_addr
;
393 current_objfile
-> ei
.entry_file_highpc
= cur_src_end_addr
;
397 /* Finish the symbol definitions for one main source file,
398 close off all the lexical contexts for that file
399 (creating struct block's for them), then make the
400 struct symtab for that file and put it in the list of all such. */
403 coff_end_symtab (objfile
)
404 struct objfile
*objfile
;
406 struct symtab
*symtab
;
408 last_source_start_addr
= cur_src_start_addr
;
410 /* For no good reason, this file stores the number of entries in a
411 separate variable instead of in line_vector->nitems. Fix it. */
413 line_vector
->nitems
= line_vector_index
;
415 /* For COFF, we only have one subfile, so we can just look at
416 subfiles and not worry about there being other elements in the
417 chain. We fill in various fields now because we didn't know them
418 before (or because doing it now is simply an artifact of how this
419 file used to be written). */
420 subfiles
->line_vector
= line_vector
;
421 subfiles
->name
= last_source_file
;
423 /* sort_pending is needed for amdcoff, at least.
424 sort_linevec is needed for the SCO compiler. */
425 symtab
= end_symtab (cur_src_end_addr
, 1, 1, objfile
, 0);
428 free_named_symtabs (symtab
->filename
);
430 /* Reinitialize for beginning of new file. */
432 line_vector_length
= -1;
433 last_source_file
= NULL
;
437 record_minimal_symbol (name
, address
, type
)
440 enum minimal_symbol_type type
;
442 /* We don't want TDESC entry points in the minimal symbol table */
443 if (name
[0] == '@') return;
445 prim_record_minimal_symbol (savestring (name
, strlen (name
)), address
, type
);
448 /* coff_symfile_init ()
449 is the coff-specific initialization routine for reading symbols.
450 It is passed a struct objfile which contains, among other things,
451 the BFD for the file whose symbols are being read, and a slot for
452 a pointer to "private data" which we fill with cookies and other
453 treats for coff_symfile_read ().
455 We will only be called if this is a COFF or COFF-like file.
456 BFD handles figuring out the format of the file, and code in symtab.c
457 uses BFD's determination to vector to us.
459 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
461 struct coff_symfile_info
{
462 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
463 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
466 static int text_bfd_scnum
;
469 coff_symfile_init (objfile
)
470 struct objfile
*objfile
;
473 bfd
*abfd
= objfile
->obfd
;
475 /* Allocate struct to keep track of the symfile */
476 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
477 sizeof (struct coff_symfile_info
));
479 init_entry_point_info (objfile
);
481 /* Save the section number for the text section */
482 section
= bfd_get_section_by_name(abfd
,".text");
484 text_bfd_scnum
= section
->index
;
489 /* This function is called for every section; it finds the outer limits
490 of the line table (minimum and maximum file offset) so that the
491 mainline code can read the whole thing for efficiency. */
495 find_linenos (abfd
, asect
, vpinfo
)
500 struct coff_symfile_info
*info
;
502 file_ptr offset
, maxoff
;
504 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
505 count
= asect
->lineno_count
;
510 size
= count
* local_linesz
;
512 info
= (struct coff_symfile_info
*)vpinfo
;
513 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
514 offset
= asect
->line_filepos
;
517 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
518 info
->min_lineno_offset
= offset
;
520 maxoff
= offset
+ size
;
521 if (maxoff
> info
->max_lineno_offset
)
522 info
->max_lineno_offset
= maxoff
;
526 /* The BFD for this file -- only good while we're actively reading
527 symbols into a psymtab or a symtab. */
529 static bfd
*symfile_bfd
;
531 /* Read a symbol file, after initialization by coff_symfile_init. */
532 /* FIXME! Addr and Mainline are not used yet -- this will not work for
533 shared libraries or add_file! */
537 coff_symfile_read (objfile
, section_offsets
, mainline
)
538 struct objfile
*objfile
;
539 struct section_offsets
*section_offsets
;
542 struct coff_symfile_info
*info
;
543 bfd
*abfd
= objfile
->obfd
;
544 coff_data_type
*cdata
= coff_data (abfd
);
545 char *name
= bfd_get_filename (abfd
);
550 int stringtab_offset
;
551 struct cleanup
*back_to
;
553 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
554 symfile_bfd
= abfd
; /* Kludge for swap routines */
556 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
557 desc
= fileno ((FILE *)(abfd
->iostream
)); /* File descriptor */
558 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
559 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
560 stringtab_offset
= symtab_offset
+ /* String table file offset */
561 num_symbols
* cdata
->local_symesz
;
563 /* Set a few file-statics that give us specific information about
564 the particular COFF file format we're reading. */
565 local_linesz
= cdata
->local_linesz
;
566 local_n_btmask
= cdata
->local_n_btmask
;
567 local_n_btshft
= cdata
->local_n_btshft
;
568 local_n_tmask
= cdata
->local_n_tmask
;
569 local_n_tshift
= cdata
->local_n_tshift
;
570 local_linesz
= cdata
->local_linesz
;
571 local_symesz
= cdata
->local_symesz
;
572 local_auxesz
= cdata
->local_auxesz
;
574 /* Allocate space for raw symbol and aux entries, based on their
575 space requirements as reported by BFD. */
576 temp_sym
= (char *) xmalloc
577 (cdata
->local_symesz
+ cdata
->local_auxesz
);
578 temp_aux
= temp_sym
+ cdata
->local_symesz
;
579 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
582 /* Read the line number table, all at once. */
583 info
->min_lineno_offset
= 0;
584 info
->max_lineno_offset
= 0;
585 bfd_map_over_sections (abfd
, find_linenos
, (PTR
)info
);
587 make_cleanup (free_linetab
, 0);
588 val
= init_lineno (desc
, info
->min_lineno_offset
,
589 info
->max_lineno_offset
- info
->min_lineno_offset
);
591 error ("\"%s\": error reading line numbers\n", name
);
593 /* Now read the string table, all at once. */
595 make_cleanup (free_stringtab
, 0);
596 val
= init_stringtab (desc
, stringtab_offset
);
598 error ("\"%s\": can't get string table", name
);
600 init_minimal_symbol_collection ();
601 make_cleanup (discard_minimal_symbols
, 0);
603 /* Now that the executable file is positioned at symbol table,
604 process it and define symbols accordingly. */
606 read_coff_symtab ((long)symtab_offset
, num_symbols
, objfile
);
608 /* Sort symbols alphabetically within each block. */
610 sort_all_symtab_syms ();
612 /* Install any minimal symbols that have been collected as the current
613 minimal symbols for this objfile. */
615 install_minimal_symbols (objfile
);
617 do_cleanups (back_to
);
621 coff_new_init (ignore
)
622 struct objfile
*ignore
;
627 /* Perform any local cleanups required when we are done with a particular
628 objfile. I.E, we are in the process of discarding all symbol information
629 for an objfile, freeing up all memory held for it, and unlinking the
630 objfile struct from the global list of known objfiles. */
633 coff_symfile_finish (objfile
)
634 struct objfile
*objfile
;
636 if (objfile
-> sym_private
!= NULL
)
638 mfree (objfile
-> md
, objfile
-> sym_private
);
643 /* Given pointers to a symbol table in coff style exec file,
644 analyze them and create struct symtab's describing the symbols.
645 NSYMS is the number of symbols in the symbol table.
646 We read them one at a time using read_one_sym (). */
649 read_coff_symtab (symtab_offset
, nsyms
, objfile
)
652 struct objfile
*objfile
;
655 register struct context_stack
*new;
656 struct coff_symbol coff_symbol
;
657 register struct coff_symbol
*cs
= &coff_symbol
;
658 static struct internal_syment main_sym
;
659 static union internal_auxent main_aux
;
660 struct coff_symbol fcn_cs_saved
;
661 static struct internal_syment fcn_sym_saved
;
662 static union internal_auxent fcn_aux_saved
;
665 /* A .file is open. */
666 int in_source_file
= 0;
667 int num_object_files
= 0;
668 int next_file_symnum
= -1;
670 /* Name of the current file. */
671 char *filestring
= "";
673 int fcn_first_line
= 0;
674 int fcn_last_line
= 0;
675 int fcn_start_addr
= 0;
676 long fcn_line_ptr
= 0;
679 stream
= bfd_cache_lookup(objfile
->obfd
);
681 perror_with_name(objfile
->name
);
683 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
684 it's hard to know I've really worked around it. The fix should be
685 harmless, anyway). The symptom of the bug is that the first
686 fread (in read_one_sym), will (in my example) actually get data
687 from file offset 268, when the fseek was to 264 (and ftell shows
688 264). This causes all hell to break loose. I was unable to
689 reproduce this on a short test program which operated on the same
690 file, performing (I think) the same sequence of operations.
692 It stopped happening when I put in this rewind().
694 FIXME: Find out if this has been reported to Sun, whether it has
695 been fixed in a later release, etc. */
699 /* Position to read the symbol table. */
700 val
= fseek (stream
, (long)symtab_offset
, 0);
702 perror_with_name (objfile
->name
);
704 current_objfile
= objfile
;
705 nlist_stream_global
= stream
;
706 nlist_nsyms_global
= nsyms
;
707 last_source_file
= NULL
;
708 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
710 if (type_vector
) /* Get rid of previous one */
711 free ((PTR
)type_vector
);
712 type_vector_length
= 160;
713 type_vector
= (struct type
**)
714 xmalloc (type_vector_length
* sizeof (struct type
*));
715 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
717 coff_start_symtab ();
720 while (symnum
< nsyms
)
722 QUIT
; /* Make this command interruptable. */
723 read_one_sym (cs
, &main_sym
, &main_aux
);
726 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
727 cs
->c_name
[2] << 8 | cs
->c_name
[3];
728 if (int_sem_val
== temp_sem_val
)
729 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
732 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
734 if (last_source_file
)
735 coff_end_symtab (objfile
);
737 coff_start_symtab ();
738 complete_symtab ("_globals_", 0, first_object_file_end
);
739 /* done with all files, everything from here on out is globals */
742 /* Special case for file with type declarations only, no text. */
743 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
744 && cs
->c_secnum
== N_DEBUG
)
745 complete_symtab (filestring
, 0, 0);
747 /* Typedefs should not be treated as symbol definitions. */
748 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
750 /* Record all functions -- external and static -- in minsyms. */
751 record_minimal_symbol (cs
->c_name
, cs
->c_value
, mst_text
);
753 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
754 fcn_start_addr
= cs
->c_value
;
756 fcn_sym_saved
= main_sym
;
757 fcn_aux_saved
= main_aux
;
761 switch (cs
->c_sclass
)
770 complain (&bad_sclass_complaint
, cs
->c_name
);
775 * c_value field contains symnum of next .file entry in table
776 * or symnum of first global after last .file.
778 next_file_symnum
= cs
->c_value
;
779 filestring
= getfilename (&main_aux
);
781 * Complete symbol table for last object file
782 * containing debugging information.
784 if (last_source_file
)
786 coff_end_symtab (objfile
);
787 coff_start_symtab ();
793 if (cs
->c_name
[0] == '.') {
794 if (STREQ (cs
->c_name
, ".text")) {
795 /* FIXME: don't wire in ".text" as section name
797 if (++num_object_files
== 1) {
798 /* last address of startup file */
799 first_object_file_end
= cs
->c_value
+
800 main_aux
.x_scn
.x_scnlen
;
802 /* Check for in_source_file deals with case of
803 a file with debugging symbols
804 followed by a later file with no symbols. */
806 complete_symtab (filestring
, cs
->c_value
,
807 main_aux
.x_scn
.x_scnlen
);
810 /* flush rest of '.' symbols */
813 else if (!SDB_TYPE (cs
->c_type
)
814 && cs
->c_name
[0] == 'L'
815 && (strncmp (cs
->c_name
, "LI%", 3) == 0
816 || strncmp (cs
->c_name
, "LF%", 3) == 0
817 || strncmp (cs
->c_name
,"LC%",3) == 0
818 || strncmp (cs
->c_name
,"LP%",3) == 0
819 || strncmp (cs
->c_name
,"LPB%",4) == 0
820 || strncmp (cs
->c_name
,"LBB%",4) == 0
821 || strncmp (cs
->c_name
,"LBE%",4) == 0
822 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
823 /* At least on a 3b1, gcc generates swbeg and string labels
824 that look like this. Ignore them. */
826 /* fall in for static symbols that don't start with '.' */
828 /* Record external symbols in minsyms if we don't have debug
829 info for them. FIXME, this is probably the wrong thing
830 to do. Why don't we record them even if we do have
831 debug symbol info? What really belongs in the minsyms
833 if (!SDB_TYPE (cs
->c_type
)) {
834 /* FIXME: This is BOGUS Will Robinson!
835 Coff should provide the SEC_CODE flag for executable sections,
836 then if we could look up sections by section number we
837 could see if the flags indicate SEC_CODE. If so, then
838 record this symbol as a function in the minimal symbol table.
839 But why are absolute syms recorded as functions, anyway? */
840 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
841 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
845 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
850 process_coff_symbol (cs
, &main_aux
, objfile
);
854 if (STREQ (cs
->c_name
, ".bf"))
858 /* value contains address of first non-init type code */
859 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
860 contains line number of '{' } */
862 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
863 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
865 /* Might want to check that locals are 0 and
866 context_stack_depth is zero, and complain if not. */
869 new = push_context (depth
, fcn_start_addr
);
870 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
871 new->name
= process_coff_symbol (&fcn_cs_saved
,
872 &fcn_aux_saved
, objfile
);
874 else if (STREQ (cs
->c_name
, ".ef"))
876 /* the value of .ef is the address of epilogue code;
877 not useful for gdb. */
878 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
879 contains number of lines to '}' */
880 new = pop_context ();
881 /* Stack must be empty now. */
882 if (context_stack_depth
> 0 || new == NULL
)
884 complain (&ef_complaint
, cs
->c_symnum
);
890 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
891 fcn_last_line
= 0x7FFFFFFF;
895 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
897 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
899 finish_block (new->name
, &local_symbols
, new->old_blocks
,
901 #if defined (FUNCTION_EPILOGUE_SIZE)
902 /* This macro should be defined only on
904 fcn_aux_saved.x_sym.x_misc.x_fsize
905 field is always zero.
906 So use the .bf record information that
907 points to the epilogue and add the size
909 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
911 fcn_cs_saved
.c_value
+
912 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
921 if (STREQ (cs
->c_name
, ".bb"))
923 push_context (++depth
, cs
->c_value
);
925 else if (STREQ (cs
->c_name
, ".eb"))
927 new = pop_context ();
928 if (depth
-- != new->depth
)
930 complain (&eb_complaint
, (char *)symnum
);
933 if (local_symbols
&& context_stack_depth
> 0)
935 /* Make a block for the local symbols within. */
936 finish_block (0, &local_symbols
, new->old_blocks
,
937 new->start_addr
, cs
->c_value
, objfile
);
939 /* Now pop locals of block just finished. */
940 local_symbols
= new->locals
;
945 process_coff_symbol (cs
, &main_aux
, objfile
);
950 if (last_source_file
)
951 coff_end_symtab (objfile
);
953 /* Patch up any opaque types (references to types that are not defined
954 in the file where they are referenced, e.g. "struct foo *bar"). */
955 ALL_OBJFILE_SYMTABS (objfile
, s
)
956 patch_opaque_types (s
);
958 current_objfile
= NULL
;
961 /* Routines for reading headers and symbols from executable. */
964 /* Move these XXXMAGIC symbol defns into BFD! */
966 /* Read COFF file header, check magic number,
967 and return number of symbols. */
968 read_file_hdr (chan
, file_hdr
)
973 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
976 switch (file_hdr
->f_magic
)
991 #if defined (MC68KWRMAGIC) \
992 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1006 case I960ROMAGIC
: /* Intel 960 */
1009 case I960RWMAGIC
: /* Intel 960 */
1011 return file_hdr
->f_nsyms
;
1015 if (BADMAG(file_hdr
))
1018 return file_hdr
->f_nsyms
;
1026 /* Read the next symbol, swap it, and return it in both internal_syment
1027 form, and coff_symbol form. Also return its first auxent, if any,
1028 in internal_auxent form, and skip any other auxents. */
1031 read_one_sym (cs
, sym
, aux
)
1032 register struct coff_symbol
*cs
;
1033 register struct internal_syment
*sym
;
1034 register union internal_auxent
*aux
;
1038 cs
->c_symnum
= symnum
;
1039 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1040 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1041 cs
->c_naux
= sym
->n_numaux
& 0xff;
1042 if (cs
->c_naux
>= 1)
1044 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1045 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1047 /* If more than one aux entry, read past it (only the first aux
1049 for (i
= 1; i
< cs
->c_naux
; i
++)
1050 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1052 cs
->c_name
= getsymname (sym
);
1053 cs
->c_value
= sym
->n_value
;
1054 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1055 cs
->c_secnum
= sym
->n_scnum
;
1056 cs
->c_type
= (unsigned) sym
->n_type
;
1057 if (!SDB_TYPE (cs
->c_type
))
1060 symnum
+= 1 + cs
->c_naux
;
1063 /* Support for string table handling */
1065 static char *stringtab
= NULL
;
1068 init_stringtab (chan
, offset
)
1074 unsigned char lengthbuf
[4];
1078 if (lseek (chan
, offset
, 0) < 0)
1081 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1082 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1084 /* If no string table is needed, then the file may end immediately
1085 after the symbols. Just return with `stringtab' set to null. */
1086 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1089 stringtab
= (char *) xmalloc (length
);
1090 memcpy (stringtab
, &length
, sizeof length
);
1091 if (length
== sizeof length
) /* Empty table -- just the count */
1094 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1095 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1110 getsymname (symbol_entry
)
1111 struct internal_syment
*symbol_entry
;
1113 static char buffer
[SYMNMLEN
+1];
1116 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1118 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1122 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1123 buffer
[SYMNMLEN
] = '\0';
1129 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1130 only the last component of the name. Result is in static storage and
1131 is only good for temporary use. */
1134 getfilename (aux_entry
)
1135 union internal_auxent
*aux_entry
;
1137 static char buffer
[BUFSIZ
];
1138 register char *temp
;
1141 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1142 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1145 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1146 buffer
[FILNMLEN
] = '\0';
1149 if ((temp
= strrchr (result
, '/')) != NULL
)
1154 /* Support for line number handling */
1155 static char *linetab
= NULL
;
1156 static long linetab_offset
;
1157 static unsigned long linetab_size
;
1159 /* Read in all the line numbers for fast lookups later. Leave them in
1160 external (unswapped) format in memory; we'll swap them as we enter
1161 them into GDB's data structures. */
1164 init_lineno (chan
, offset
, size
)
1171 linetab_offset
= offset
;
1172 linetab_size
= size
;
1179 if (lseek (chan
, offset
, 0) < 0)
1182 /* Allocate the desired table, plus a sentinel */
1183 linetab
= (char *) xmalloc (size
+ local_linesz
);
1185 val
= myread (chan
, linetab
, size
);
1189 /* Terminate it with an all-zero sentinel record */
1190 memset (linetab
+ size
, 0, local_linesz
);
1203 #if !defined (L_LNNO32)
1204 #define L_LNNO32(lp) ((lp)->l_lnno)
1208 enter_linenos (file_offset
, first_line
, last_line
)
1210 register int first_line
;
1211 register int last_line
;
1213 register char *rawptr
;
1214 struct internal_lineno lptr
;
1216 if (file_offset
< linetab_offset
)
1218 complain (&lineno_complaint
, file_offset
);
1219 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1221 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1224 rawptr
= &linetab
[file_offset
- linetab_offset
];
1226 /* skip first line entry for each function */
1227 rawptr
+= local_linesz
;
1228 /* line numbers start at one for the first line of the function */
1232 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1233 rawptr
+= local_linesz
;
1234 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1235 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1236 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1243 patch_type (type
, real_type
)
1245 struct type
*real_type
;
1247 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1248 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1249 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1251 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1252 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1253 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1255 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1257 if (TYPE_NAME (real_target
))
1259 if (TYPE_NAME (target
))
1260 free (TYPE_NAME (target
));
1261 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1265 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1266 so that they can be used to print out opaque data structures properly. */
1269 patch_opaque_types (s
)
1272 register struct block
*b
;
1274 register struct symbol
*real_sym
;
1276 /* Go through the per-file symbols only */
1277 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1278 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1280 /* Find completed typedefs to use to fix opaque ones.
1281 Remove syms from the chain when their types are stored,
1282 but search the whole chain, as there may be several syms
1283 from different files with the same name. */
1284 real_sym
= BLOCK_SYM (b
, i
);
1285 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1286 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1287 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1288 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1290 register char *name
= SYMBOL_NAME (real_sym
);
1291 register int hash
= hashname (name
);
1292 register struct symbol
*sym
, *prev
;
1295 for (sym
= opaque_type_chain
[hash
]; sym
;)
1297 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1298 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1302 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1306 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1309 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1313 sym
= SYMBOL_VALUE_CHAIN (prev
);
1317 sym
= opaque_type_chain
[hash
];
1323 sym
= SYMBOL_VALUE_CHAIN (sym
);
1330 static struct symbol
*
1331 process_coff_symbol (cs
, aux
, objfile
)
1332 register struct coff_symbol
*cs
;
1333 register union internal_auxent
*aux
;
1334 struct objfile
*objfile
;
1336 register struct symbol
*sym
1337 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1338 sizeof (struct symbol
));
1340 struct type
*temptype
;
1342 memset (sym
, 0, sizeof (struct symbol
));
1344 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1345 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1348 /* default assumptions */
1349 SYMBOL_VALUE (sym
) = cs
->c_value
;
1350 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1352 if (ISFCN (cs
->c_type
))
1355 /* FIXME: This has NOT been tested. The DBX version has.. */
1356 /* Generate a template for the type of this function. The
1357 types of the arguments will be added as we read the symbol
1359 struct type
*new = (struct type
*)
1360 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1362 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1363 sizeof(struct type
));
1364 SYMBOL_TYPE (sym
) = new;
1365 in_function_type
= SYMBOL_TYPE(sym
);
1368 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1371 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1372 if (cs
->c_sclass
== C_STAT
)
1373 add_symbol_to_list (sym
, &file_symbols
);
1374 else if (cs
->c_sclass
== C_EXT
)
1375 add_symbol_to_list (sym
, &global_symbols
);
1379 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1380 switch (cs
->c_sclass
)
1386 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1387 add_symbol_to_list (sym
, &local_symbols
);
1391 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1392 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1393 add_symbol_to_list (sym
, &global_symbols
);
1397 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1398 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1399 if (within_function
) {
1400 /* Static symbol of local scope */
1401 add_symbol_to_list (sym
, &local_symbols
);
1404 /* Static symbol at top level of file */
1405 add_symbol_to_list (sym
, &file_symbols
);
1409 #ifdef C_GLBLREG /* AMD coff */
1413 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1414 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1415 add_symbol_to_list (sym
, &local_symbols
);
1422 SYMBOL_CLASS (sym
) = LOC_ARG
;
1424 /* FIXME: This has not been tested. */
1425 /* Add parameter to function. */
1426 add_param_to_type(&in_function_type
,sym
);
1428 add_symbol_to_list (sym
, &local_symbols
);
1429 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1430 /* If PCC says a parameter is a short or a char,
1431 aligned on an int boundary, realign it to the "little end"
1433 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1434 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1435 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1436 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1438 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1439 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1445 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1446 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1447 add_symbol_to_list (sym
, &local_symbols
);
1448 #if !defined (BELIEVE_PCC_PROMOTION)
1449 /* FIXME: This should retain the current type, since it's just
1450 a register value. gnu@adobe, 26Feb93 */
1451 /* If PCC says a parameter is a short or a char,
1452 it is really an int. */
1453 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1454 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1455 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1457 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1458 ? lookup_fundamental_type (current_objfile
,
1459 FT_UNSIGNED_INTEGER
)
1466 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1467 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1469 /* If type has no name, give it one */
1470 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1471 TYPE_NAME (SYMBOL_TYPE (sym
)) = concat (SYMBOL_NAME (sym
), NULL
);
1473 /* Keep track of any type which points to empty structured type,
1474 so it can be filled from a definition from another file. A
1475 simple forward reference (TYPE_CODE_UNDEF) is not an
1476 empty structured type, though; the forward references
1477 work themselves out via the magic of coff_lookup_type. */
1478 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1479 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1480 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1483 register int i
= hashname (SYMBOL_NAME (sym
));
1485 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1486 opaque_type_chain
[i
] = sym
;
1488 add_symbol_to_list (sym
, &file_symbols
);
1494 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1495 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1497 /* Some compilers try to be helpful by inventing "fake"
1498 names for anonymous enums, structures, and unions, like
1499 "~0fake" or ".0fake". Thanks, but no thanks... */
1500 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1501 if (SYMBOL_NAME(sym
) != NULL
1502 && *SYMBOL_NAME(sym
) != '~'
1503 && *SYMBOL_NAME(sym
) != '.')
1504 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1505 concat (SYMBOL_NAME (sym
), NULL
);
1507 add_symbol_to_list (sym
, &file_symbols
);
1517 /* Decode a coff type specifier;
1518 return the type that is meant. */
1522 decode_type (cs
, c_type
, aux
)
1523 register struct coff_symbol
*cs
;
1524 unsigned int c_type
;
1525 register union internal_auxent
*aux
;
1527 register struct type
*type
= 0;
1528 unsigned int new_c_type
;
1530 if (c_type
& ~N_BTMASK
)
1532 new_c_type
= DECREF (c_type
);
1535 type
= decode_type (cs
, new_c_type
, aux
);
1536 type
= lookup_pointer_type (type
);
1538 else if (ISFCN (c_type
))
1540 type
= decode_type (cs
, new_c_type
, aux
);
1541 type
= lookup_function_type (type
);
1543 else if (ISARY (c_type
))
1546 register unsigned short *dim
;
1547 struct type
*base_type
, *index_type
, *range_type
;
1549 /* Define an array type. */
1550 /* auxent refers to array, not base type */
1551 if (aux
->x_sym
.x_tagndx
.l
== 0)
1554 /* shift the indices down */
1555 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1558 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1562 base_type
= decode_type (cs
, new_c_type
, aux
);
1563 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1565 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1567 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1572 /* Reference to existing type. This only occurs with the
1573 struct, union, and enum types. EPI a29k coff
1574 fakes us out by producing aux entries with a nonzero
1575 x_tagndx for definitions of structs, unions, and enums, so we
1576 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1577 with pointers to pointers to defined structs, and generates
1578 negative x_tagndx fields. */
1579 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1581 if (cs
->c_sclass
!= C_STRTAG
1582 && cs
->c_sclass
!= C_UNTAG
1583 && cs
->c_sclass
!= C_ENTAG
1584 && aux
->x_sym
.x_tagndx
.l
>= 0)
1586 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1589 complain (&tagndx_bad_complaint
, cs
->c_name
);
1590 /* And fall through to decode_base_type... */
1594 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1597 /* Decode a coff type specifier for function definition;
1598 return the type that the function returns. */
1602 decode_function_type (cs
, c_type
, aux
)
1603 register struct coff_symbol
*cs
;
1604 unsigned int c_type
;
1605 register union internal_auxent
*aux
;
1607 if (aux
->x_sym
.x_tagndx
.l
== 0)
1608 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1610 return decode_type (cs
, DECREF (c_type
), aux
);
1617 decode_base_type (cs
, c_type
, aux
)
1618 register struct coff_symbol
*cs
;
1619 unsigned int c_type
;
1620 register union internal_auxent
*aux
;
1627 /* shows up with "void (*foo)();" structure members */
1628 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1631 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1634 /* Shows up in DGUX, I think. Not sure where. */
1635 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1641 /* Intel 960 COFF has this symbol and meaning. */
1642 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1646 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1649 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1652 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1655 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1658 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1661 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1664 if (cs
->c_naux
!= 1)
1666 /* anonymous structure type */
1667 type
= coff_alloc_type (cs
->c_symnum
);
1668 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1669 TYPE_NAME (type
) = NULL
;
1670 /* This used to set the tag to "<opaque>". But I think setting it
1671 to NULL is right, and the printing code can print it as
1673 TYPE_TAG_NAME (type
) = NULL
;
1674 INIT_CPLUS_SPECIFIC(type
);
1675 TYPE_LENGTH (type
) = 0;
1676 TYPE_FIELDS (type
) = 0;
1677 TYPE_NFIELDS (type
) = 0;
1681 type
= coff_read_struct_type (cs
->c_symnum
,
1682 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1683 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1688 if (cs
->c_naux
!= 1)
1690 /* anonymous union type */
1691 type
= coff_alloc_type (cs
->c_symnum
);
1692 TYPE_NAME (type
) = NULL
;
1693 /* This used to set the tag to "<opaque>". But I think setting it
1694 to NULL is right, and the printing code can print it as
1696 TYPE_TAG_NAME (type
) = NULL
;
1697 INIT_CPLUS_SPECIFIC(type
);
1698 TYPE_LENGTH (type
) = 0;
1699 TYPE_FIELDS (type
) = 0;
1700 TYPE_NFIELDS (type
) = 0;
1704 type
= coff_read_struct_type (cs
->c_symnum
,
1705 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1706 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1708 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1712 if (cs
->c_naux
!= 1)
1714 /* anonymous enum type */
1715 type
= coff_alloc_type (cs
->c_symnum
);
1716 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1717 TYPE_NAME (type
) = NULL
;
1718 /* This used to set the tag to "<opaque>". But I think setting it
1719 to NULL is right, and the printing code can print it as
1721 TYPE_TAG_NAME (type
) = NULL
;
1722 TYPE_LENGTH (type
) = 0;
1723 TYPE_FIELDS (type
) = 0;
1724 TYPE_NFIELDS(type
) = 0;
1728 type
= coff_read_enum_type (cs
->c_symnum
,
1729 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1730 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1735 /* shouldn't show up here */
1739 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1742 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1745 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1748 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
1750 complain (&unexpected_type_complaint
, cs
->c_name
);
1751 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1754 /* This page contains subroutines of read_type. */
1756 /* Read the description of a structure (or union type)
1757 and return an object describing the type. */
1759 static struct type
*
1760 coff_read_struct_type (index
, length
, lastsym
)
1767 struct nextfield
*next
;
1771 register struct type
*type
;
1772 register struct nextfield
*list
= 0;
1773 struct nextfield
*new;
1777 struct coff_symbol member_sym
;
1778 register struct coff_symbol
*ms
= &member_sym
;
1779 struct internal_syment sub_sym
;
1780 union internal_auxent sub_aux
;
1783 type
= coff_alloc_type (index
);
1784 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1785 INIT_CPLUS_SPECIFIC(type
);
1786 TYPE_LENGTH (type
) = length
;
1788 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1790 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1792 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1794 switch (ms
->c_sclass
)
1799 /* Get space to record the next field's data. */
1800 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1804 /* Save the data. */
1805 list
->field
.name
= savestring (name
, strlen (name
));
1806 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1807 list
->field
.bitpos
= 8 * ms
->c_value
;
1808 list
->field
.bitsize
= 0;
1814 /* Get space to record the next field's data. */
1815 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1819 /* Save the data. */
1820 list
->field
.name
= savestring (name
, strlen (name
));
1821 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1822 list
->field
.bitpos
= ms
->c_value
;
1823 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1832 /* Now create the vector of fields, and record how big it is. */
1834 TYPE_NFIELDS (type
) = nfields
;
1835 TYPE_FIELDS (type
) = (struct field
*)
1836 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1838 /* Copy the saved-up fields into the field vector. */
1840 for (n
= nfields
; list
; list
= list
->next
)
1841 TYPE_FIELD (type
, --n
) = list
->field
;
1846 /* Read a definition of an enumeration type,
1847 and create and return a suitable type object.
1848 Also defines the symbols that represent the values of the type. */
1851 static struct type
*
1852 coff_read_enum_type (index
, length
, lastsym
)
1857 register struct symbol
*sym
;
1858 register struct type
*type
;
1861 struct pending
**symlist
;
1862 struct coff_symbol member_sym
;
1863 register struct coff_symbol
*ms
= &member_sym
;
1864 struct internal_syment sub_sym
;
1865 union internal_auxent sub_aux
;
1866 struct pending
*osyms
, *syms
;
1871 type
= coff_alloc_type (index
);
1872 if (within_function
)
1873 symlist
= &local_symbols
;
1875 symlist
= &file_symbols
;
1877 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1879 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1881 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1883 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1885 switch (ms
->c_sclass
)
1888 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1889 memset (sym
, 0, sizeof (struct symbol
));
1891 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1892 SYMBOL_CLASS (sym
) = LOC_CONST
;
1893 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1894 SYMBOL_VALUE (sym
) = ms
->c_value
;
1895 add_symbol_to_list (sym
, symlist
);
1900 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
1901 up the count of how many symbols to read. So stop
1908 /* Now fill in the fields of the type-structure. */
1911 TYPE_LENGTH (type
) = length
;
1913 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
1914 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1915 TYPE_NFIELDS (type
) = nsyms
;
1916 TYPE_FIELDS (type
) = (struct field
*)
1917 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
1919 /* Find the symbols for the values and put them into the type.
1920 The symbols can be found in the symlist that we put them on
1921 to cause them to be defined. osyms contains the old value
1922 of that symlist; everything up to there was defined by us. */
1923 /* Note that we preserve the order of the enum constants, so
1924 that in something like "enum {FOO, LAST_THING=FOO}" we print
1925 FOO, not LAST_THING. */
1927 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
1932 for (; j
< syms
->nsyms
; j
++,n
++)
1934 struct symbol
*xsym
= syms
->symbol
[j
];
1935 SYMBOL_TYPE (xsym
) = type
;
1936 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
1937 TYPE_FIELD_VALUE (type
, n
) = 0;
1938 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
1939 TYPE_FIELD_BITSIZE (type
, n
) = 0;
1946 /* This screws up perfectly good C programs with enums. FIXME. */
1947 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
1948 if(TYPE_NFIELDS(type
) == 2 &&
1949 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
1950 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
1951 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
1952 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
1953 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
1958 /* Fake up support for relocating symbol addresses. FIXME. */
1960 struct section_offsets coff_symfile_faker
= {{0}};
1962 struct section_offsets
*
1963 coff_symfile_offsets (objfile
, addr
)
1964 struct objfile
*objfile
;
1967 return &coff_symfile_faker
;
1970 /* Register our ability to parse symbols for coff BFD files */
1972 static struct sym_fns coff_sym_fns
=
1974 "coff", /* sym_name: name or name prefix of BFD target type */
1975 4, /* sym_namelen: number of significant sym_name chars */
1976 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
1977 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
1978 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
1979 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
1980 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
1981 NULL
/* next: pointer to next struct sym_fns */
1985 _initialize_coffread ()
1987 add_symtab_fns(&coff_sym_fns
);